@weasel-js/core 1.1.0 → 1.3.0-pre.0

package/dist/index.d.ts

@@ -1,41 +1,44 @@
 import * as React$1 from 'react';
-import React__default, { RefObject, ReactNode, Ref, MouseEvent as MouseEvent$1, MutableRefObject } from 'react';
+import React__default, { RefObject, ReactNode, Ref, MouseEvent as MouseEvent$1, ComponentType, MutableRefObject } from 'react';
 import { a as ViewTransform, V as View, Z as ZoomBound, b as ZoomFactor } from './view-DSQgxBJB.js';
 export { s as screenToWorld, v as viewToTransform, w as worldToScreen } from './view-DSQgxBJB.js';
-import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-DqOi0Vgi.js';
-export { I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, c as Unit, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-DqOi0Vgi.js';
-import { R as RenderLayer, D as Dims, a as DeviceProfile, b as DetectedDeviceFacts, C as Condition, c as Rule, d as RuleCtx, V as VisibilityRules, e as ChromeCtx, f as ChromeId, A as Action, g as DepSchema, S as SliceDep, h as ActionsRegistry, T as Tool, i as AffordanceHit, j as Dispatcher, k as ToolDef, l as ViewportToolDef, m as AnyTool, O as OverlayPosition, n as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, o as ChromeState, p as SelectionApi, I as InsertExtras, G as GeometryProjection, q as ContentHandlerEntry, r as SvgIngestOptions, U as UseSelectionOptions, s as ActionsProp, t as Affordance, u as AffordanceRegion, v as AffordanceBinding, w as CommonAffordanceScratch, B as BooleansAdapter, E as Eligibility, x as BindingScope, y as Contribution, z as ScopedBinding } from './registry-DGBrjGbB.js';
-export { F as ALWAYS, J as ActionDeps, K as ActionDisabledReason, M as ActionEnabledResult, N as ActionEntry, P as ActionsProvider, Q as ActiveToolContextProvider, W as ActiveToolContextProviderIfRoot, X as ActiveToolContextProviderProps, Y as ActiveToolContextValue, Z as AreaSelectDep, _ as BindingOpts, $ as BooleanOp, a0 as BooleanOpResult, a1 as BoundGesture, a2 as BuildRuleCtxArgs, a3 as ClaimableGesture, a4 as ClipboardDep, a5 as ClipboardIngestCtx, a6 as CustomPaintContext, a7 as DepName, a8 as DepRegistry, a9 as DepRegistryProvider, aa as DispatcherContext, ab as DragSample, ac as EditAnchorsDep, ad as GestureBinding, ae as IDENTITY_POSE_COMPOSITION, af as ImmediateInvoker, ag as IngestCtx, ah as IngestionDep, ai as InsertDep, aj as InvocationCtx, ak as Invoker, al as LassoSelectDep, am as LayoutDep, an as MatchResult, ao as NEVER, ap as NodeAtPointDep, aq as OngoingHandle, ar as OngoingInvoker, as as OngoingOverlay, at as Point2, au as PointerContextProvider, av as PointerContextValue, aw as PointerWorldPos, ax as PoseAdapter, ay as PoseComposition, az as ResizePolicy, aA as ResolveAllOptions, aB as ResolveOnlyResult, aC as ResolvedCandidate, aD as SelectionExtendKey, aE as SelectionMode, aF as Selector, aG as SnapDep, aH as SvgUnpacker, aI as TextEditDep, aJ as ToolCtx, aK as ToolModifiers, aL as ToolPresentation, aM as ToolSlot, aN as UiOngoingControl, aO as ViewApi, aP as applyBooleanOp, aQ as buildRuleCtx, aR as clipboardCopyAction, aS as clipboardCutAction, aT as composeRectPose, aU as composeWorldPose, aV as createDispatcher, aW as decomposeRectPose, aX as describeRule, aY as drawLayers, aZ as enterTextEditAction, a_ as evaluate, a$ as evaluateEnabled, b0 as rebaseLocalPose, b1 as registerContentHandler, b2 as sliceAction, b3 as specificity, b4 as translateRectPose, b5 as useAction, b6 as useActionsRegistry, b7 as useActiveToolContext, b8 as useDepRegistry, b9 as useDepSource, ba as useOptionalActiveToolContext, bb as useOptionalDepRegistry, bc as usePointerContext, bd as useSelection, be as worldPoseLookup } from './registry-DGBrjGbB.js';
-import { S as Stroke, F as FillStyle, a as TextureHandle, T as TilePatternSpec, b as GradientKind, G as GradStop, c as GradientFill } from './paint-types-CnLIzqq1.js';
-export { d as GradientUnits, R as Region, e as StrokeAlign, f as alignedStrokeRect } from './paint-types-CnLIzqq1.js';
-import { B as Bounds, P as PoseProjection, F as FitViewToBoundsOptions, V as ViewportDims } from './geometry-C56YbnfD.js';
-export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-C56YbnfD.js';
-import { N as NodeId, S as Scene, a as Node$1, b as SerializedScene, R as RectPose, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-vqxpCFVp.js';
-export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, g as SerializedNode, h as SystemLayerRecord, i as SystemLayerSpec, j as UserLayerRecord, k as asNodeId } from './types-vqxpCFVp.js';
-import { M as ModifierState, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, a as RotatedPose, e as RotateBehavior, S as SnapStrategy, c as ResizeAnchor, b as MoveBehavior, I as InsertBehavior } from './types-BhrifbZ1.js';
-export { A as ActionBehavior, f as AreaSelectOverlay, g as BehaviorMoveResult, h as BehaviorResult, C as CloneBehavior, i as CloneLayer, j as ClonePose, G as GestureContext, k as GroupTransform, l as InsertMoveResult, m as InsertOverlay, n as InsertPoint, o as InsertProposed, p as LassoSelectMoveResult, q as LassoSelectOverlay, r as LassoSelectPose, s as LassoSelectProposed, t as PointSnapContext, d as PointSnapFrame, u as PointSnapResult, v as PointerState, w as ResizeMoveResult, x as ResizeOverlay, y as ResizeProposed, z as RotateMoveResult, D as RotateOverlay, E as RotateProposed } from './types-BhrifbZ1.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-BBtn5bus.js';
-export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-BBtn5bus.js';
-import { BodyClassification, IngestItem } from '@weasel-js/gestures';
+import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-nnXU4VjN.js';
+export { I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, c as Unit, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-nnXU4VjN.js';
+import { R as RenderLayer, D as Dims, a as DeviceProfile, b as DetectedDeviceFacts, C as Condition, c as Rule, d as RuleCtx, V as VisibilityRules, e as ChromeCtx, f as ChromeId, A as Action, g as ViewAnimationOptions, h as DepSchema, S as SliceDep, i as ActionsRegistry, T as Tool, j as AffordanceHit, k as Dispatcher, l as ToolDef, m as ViewportToolDef, n as AnyTool, O as OverlayPosition, o as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, p as OngoingOverlay, q as ChromeState, r as SelectionApi, U as UseSelectionOptions, I as InsertExtras, B as BuiltinShapeToolId, G as GeometryProjection, s as ContentHandlerEntry, t as SvgIngestOptions, u as ActionsProp, v as Animator, w as Affordance, x as AffordanceRegion, y as AffordanceBinding, z as CommonAffordanceScratch, E as ColorOverrideRegistry, F as BooleansAdapter, J as EasingFn, K as SpringPresetName, M as SpringPreset, N as UseAnimatorOptions, P as AnimationHandle, Q as VertexColorChannel, W as SampledTrack, X as Eligibility, Y as BindingScope, Z as Contribution, _ as ScopedBinding } from './registry-BU1_3L_C.js';
+export { $ as ALWAYS, a0 as ActionDeps, a1 as ActionDisabledReason, a2 as ActionEnabledResult, a3 as ActionEntry, a4 as ActionsProvider, a5 as ActiveToolContextProvider, a6 as ActiveToolContextProviderIfRoot, a7 as ActiveToolContextProviderProps, a8 as ActiveToolContextValue, a9 as AnimateToBoundsOptions, aa as AreaSelectDep, ab as BindingOpts, ac as BooleanOp, ad as BooleanOpResult, ae as BoundGesture, af as BuildRuleCtxArgs, ag as ClaimableGesture, ah as ClipboardDep, ai as ClipboardIngestCtx, aj as ColorOverride, ak as ColorOverrideFn, al as CustomPaintContext, am as DecayOptions, an as DepName, ao as DepRegistry, ap as DepRegistryProvider, aq as DispatcherContext, ar as DragSample, as as EditAnchorsDep, at as EventTrack, au as GestureBinding, av as IDENTITY_POSE_COMPOSITION, aw as ImmediateInvoker, ax as IngestCtx, ay as IngestionDep, az as InsertDep, aA as Interpolate, aB as InterpolatorFactory, aC as InvocationCtx, aD as Invoker, aE as KIT_SHAPE_KINDS, aF as Keyframe, aG as LassoSelectDep, aH as LayerCommandCache, aI as LayoutDep, aJ as LoopFactory, aK as LoopOptions, aL as MatchResult, aM as NEVER, aN as NestedTimeline, aO as NodeAtPointDep, aP as OngoingHandle, aQ as OngoingInvoker, aR as PhysicsHandle, aS as PhysicsOptions, aT as Point2, aU as PointerContextProvider, aV as PointerContextValue, aW as PointerWorldPos, aX as PoseAdapter, aY as PoseComposition, aZ as ResizePolicy, a_ as ResolveAllOptions, a$ as ResolveOnlyResult, b0 as ResolvedCandidate, b1 as SelectionExtendKey, b2 as SelectionMode, b3 as Selector, b4 as SnapDep, b5 as SpringOptions, b6 as StaggerBuilder, b7 as StaggerDelay, b8 as StaggerFactory, b9 as StaggerOptions, ba as StaggerPerItem, bb as StaggerSpringPoseOptions, bc as StaggerTweenOptions, bd as SvgUnpacker, be as TextEditDep, bf as TimelineHandle, bg as TimelineOptions, bh as TimelineTrack, bi as ToolCtx, bj as ToolModifiers, bk as ToolPresentation, bl as ToolSlot, bm as Track, bn as TweenLoopOptions, bo as TweenOptions, bp as UiOngoingControl, bq as VIEW_ANIMATION_KEY, br as ViewAnimationApi, bs as ViewApi, bt as ViewChannel, bu as actionBindings, bv as applyBooleanOp, bw as buildRuleCtx, bx as clipboardCopyAction, by as clipboardCutAction, bz as composeRectPose, bA as composeWorldPose, bB as createDispatcher, bC as decomposeRectPose, bD as describeRule, bE as drawLayers, bF as drawOneLayer, bG as enterTextEditAction, bH as evaluate, bI as evaluateEnabled, bJ as isLayerPainted, bK as isLayerVisible, bL as rebaseLocalPose, bM as registerContentHandler, bN as resolveParams, bO as sliceAction, bP as specificity, bQ as translateRectPose, bR as useAction, bS as useActionsRegistry, bT as useActiveToolContext, bU as useDepRegistry, bV as useDepSource, bW as useOptionalActiveToolContext, bX as useOptionalDepRegistry, bY as usePointerContext, bZ as useSelection, b_ as useViewAnimation, b$ as worldPoseLookup } from './registry-BU1_3L_C.js';
+import { Stroke, FillStyle, TextureHandle, TilePatternSpec, GradientKind, GradStop, GradientFill, GradientUnits, MarkerKey, MarkerRef } from '@weasel-js/paint';
+export { FillStyle, GradStop, GradientFill, GradientKind, GradientUnits, KitMarkerKey, MarkerKey, MarkerRef, Region, STROKE_DASH_RATIOS, Stroke, StrokeAlign, StrokeDashStyle, TextureHandle, TilePatternSpec, alignedStrokeRect, dashForStrokeStyle, strokeDashStyleOf } from '@weasel-js/paint';
+import { R as RectPose, S as Scene, N as NodeId, a as Node$1, b as SerializedScene, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-DIQAisSG.js';
+export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, P as PoseOverride, g as PoseOverrides, h as SerializedNode, i as SystemLayerRecord, j as SystemLayerSpec, k as UserLayerRecord, l as asNodeId } from './types-DIQAisSG.js';
+import { B as Bounds, P as PoseProjection, V as ViewportDims } from './geometry-Dtt_k6Dq.js';
+export { F as FitViewToBoundsOptions, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-Dtt_k6Dq.js';
+import { GestureSpec, BodyClassification, IngestItem } from '@weasel-js/gestures';
 export { ClickSpec, DragSpec, DropSpec, GestureSpec, IngestItem, InputEvent, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, TargetSpec, WheelSpec } from '@weasel-js/gestures';
-import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, a as LassoHitMode, b as LassoSelectAdapter, c as ResizeAdapter, d as SceneAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, f as LayoutSnap } from './types-DbysOO-2.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DbysOO-2.js';
+import { M as ModifierState, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, a as RotatedPose, e as RotateBehavior, S as SnapStrategy, c as ResizeAnchor, b as MoveBehavior, I as InsertBehavior } from './types-miXHGrZM.js';
+export { A as ActionBehavior, f as AreaSelectOverlay, g as BehaviorMoveResult, h as BehaviorResult, C as CloneBehavior, i as CloneLayer, j as ClonePose, G as GestureContext, k as GroupTransform, l as InsertMoveResult, m as InsertOverlay, n as InsertPoint, o as InsertProposed, p as LassoSelectMoveResult, q as LassoSelectOverlay, r as LassoSelectPose, s as LassoSelectProposed, t as PointSnapContext, d as PointSnapFrame, u as PointSnapResult, v as PointerState, w as ResizeMoveResult, x as ResizeOverlay, y as ResizeProposed, z as RotateMoveResult, D as RotateOverlay, E as RotateProposed } from './types-miXHGrZM.js';
+import { U as UseResizeOptions } from './pointSnapToGrid-Dmthv94u.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-Dmthv94u.js';
+import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, b as LassoHitMode, c as LassoSelectAdapter, d as ResizeAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, a as SceneAdapter, f as LayoutSnap } from './types-XBcDEp3Y.js';
+export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-XBcDEp3Y.js';
 import { D as DebugSink, a as DebugConfig, b as DebugSnapshot, c as DebugStrokes, d as DebugTheme } from './types-BHK2dkMu.js';
 export { e as DebugFeature, f as DebugStroke, H as HandleKind, g as HitShape, R as RecordedBounds, h as RecordedHandle, i as RecordedHitbox, j as RecordedLayer, k as RecordedOrigin, l as RecordedSnap } from './types-BHK2dkMu.js';
-import { a as PolygonPath, P as Path, b as PathFillRule, R as RectPath } from './path-B6MMiodD.js';
-export { c as PATH_C, d as PATH_CMD_LENGTHS, e as PATH_L, f as PATH_M, g as PATH_Q, h as PATH_Z } from './path-B6MMiodD.js';
+import { a as PolygonPath, P as Path, b as PathFillRule, R as RectPath } from './path-JEV2c5If.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, d as StyledRun, R as ResolvedTextStyle, e as TextStyle, f as TextVerticalAlign, M as Mat3$1 } from './DrawCommand-BbPrSTra.js';
-export { g as DEFAULT_TEXT_STYLE, G as GroupDrawCommand, I as ImageDrawCommand, h as ResolvedRun, a as ShaderDrawCommand, b as ShaderUniform, T as TextDrawCommand, i as fontString, j as markdownToRuns, m as mat3, k as resolveRuns, l as resolveTextStyle, n as runsToMarkdown, o as runsToPlainText, t as toRuns, v as verticalAlignOffset } from './DrawCommand-BbPrSTra.js';
-import { Op, CreateHistoryOptions, History } from '@weasel-js/history';
+import { D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, M as Mat3$1 } from './DrawCommand-BnZyQaDc.js';
+export { G as GroupDrawCommand, I as ImageDrawCommand, a as ShaderDrawCommand, b as ShaderUniform, T as TextDrawCommand, m as mat3 } from './DrawCommand-BnZyQaDc.js';
+import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
-import { Mat3 } from '@weasel-js/geom';
+import { TextRenderer, TextPose, StyledRun, TextStyle, TextPaint, TextVerticalAlign } from '@weasel-js/text';
+export { DEFAULT_TEXT_STYLE, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredText, PositionedRun, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, SCRIPT_METRICS, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextPaint, TextPose, TextRenderer, TextStyle, TextVerticalAlign, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, toRuns, verticalAlignOffset } from '@weasel-js/text';
+import { S as ShaderProgram } from './stroke-5pBwOm9s.js';
+export { I as ImageMinification, b as SpriteSheet, f as frameRect, r as resolveStrokeWidth, v as viewToMat3 } from './stroke-5pBwOm9s.js';
+import { Rect, Mat3 } from '@weasel-js/geom';
+export { PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Rect, pathCommandCoordCount } from '@weasel-js/geom';
 import { G as Guide } from './types-D2tTKEU0.js';
-export { U as UseInsertOptions } from './options-C6HYCKP7.js';
+export { U as UseInsertOptions } from './options-CdFl510T.js';
 export { UseClipboardOpsOptions, UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './clipboard.js';
 export { cloneByAltDrag } from './clone.js';
-export { I as ImageMinification, v as viewToMat3 } from './viewToMat3-CQW_YqDw.js';
 export { FontVariant, LocalFontOutlinesResult, OutlineFontStyle, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
 import { CapabilityTag } from '@weasel-js/modes';
 
@@ -189,6 +192,79 @@ interface CellHighlightLayerOpts {
 /** Build a `RenderLayer` that fills a single grid cell — typically a snap-target preview. */
 declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderLayer<unknown>;
 
+/**
+ * @experimental
+ *
+ * A view the resolver can route input to: a camera and the rect it paints
+ * into, in canvas CSS-pixel space. A viewport node supplies one of these per
+ * frame; so could any other per-view surface.
+ */
+interface ResolvableView {
+    id: string;
+    view: View;
+    rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+/**
+ * @experimental
+ *
+ * The view an input event belongs to. `id` is `null` for the root view —
+ * the whole canvas, when no viewport contains the point.
+ *
+ * `origin` is the client-space origin of that view's surface, ready to hand
+ * to `clientToWorld` — which is the whole reason this type carries it rather
+ * than leaving callers to add the canvas rect and the view rect themselves.
+ */
+interface ViewTarget {
+    id: string | null;
+    view: View;
+    origin: {
+        left: number;
+        top: number;
+    };
+}
+/**
+ * @experimental
+ *
+ * Routes client points to views, and holds a captured pointer on the view its
+ * gesture started in.
+ *
+ * Stickiness is the point. A drag that leaves its view's rect — over a
+ * neighbouring view, or off the canvas — must keep reporting coordinates in
+ * the space it began in, or a marquee crossing a panel edge silently starts
+ * measuring against the wrong camera.
+ */
+interface ViewResolver {
+    /** Resolve and pin `pointerId`. Call on pointerdown. */
+    begin(pointerId: number, clientX: number, clientY: number): ViewTarget;
+    /**
+     * The view for a point. A pinned `pointerId` gets its pinned view, looked
+     * up fresh so a rect that moved mid-gesture is honored. Pass `null` for
+     * input with no pointer to capture — wheel, hover, keys.
+     */
+    at(pointerId: number | null, clientX: number, clientY: number): ViewTarget;
+    /** Release `pointerId`. Call on pointerup and pointercancel. */
+    end(pointerId: number): void;
+    /** Release every pin. */
+    clear(): void;
+}
+interface CreateViewResolverOpts {
+    /** Candidate views in paint order — the last one containing a point wins. */
+    views: () => readonly ResolvableView[];
+    /** The camera for points no view claims. */
+    root: () => View;
+    /** Client-space origin of the canvas element. */
+    canvasOrigin: () => {
+        left: number;
+        top: number;
+    };
+}
+declare function createViewResolver(opts: CreateViewResolverOpts): ViewResolver;
+
 /**
  * @experimental
  *
@@ -202,33 +278,50 @@ declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderL
  * lenses on the source.
  *
  * **Inner view semantics.** The source layers draw as if the inner view
- * filled the screen at world-origin (their own `viewToMat3(innerView)` runs
- * normally). The viewport then translates the result so that the inner
- * view's origin lands at `bounds.x, bounds.y` and clips to `(bounds.w,
- * bounds.h)`. Caller chooses `innerView.{x,y,scale}` to control which slice
- * of source-world is shown.
+ * filled the screen at world-origin — each is wrapped in `viewToMat3(view)`
+ * by the same `drawOneLayer` the outer canvas uses. The viewport then
+ * translates the result so that the inner view's origin lands at `bounds.x,
+ * bounds.y` and clips to `(bounds.w, bounds.h)`. Caller chooses
+ * `innerView.{x,y,scale}` to control which slice of source-world is shown.
  *
  * **Input is re-projected on request, not automatically.** `reproject` maps a
  * screen point into the inner view's world; a consumer that wants a click
- * inside a viewport to mean something calls it from its own handler. The
- * dispatcher is untouched, so tools still target the outer view — making
- * tools work *inside* a viewport is a larger question (which view a pinch
- * zooms, what a drag leaving the rect does) and wants its own design.
+ * inside a viewport to mean something calls it from its own handler, or feeds
+ * `resolvable` to `createViewResolver` to route a whole pointer stream.
+ * `<CanvasView>` is that wiring done for you; build on this directly for a
+ * viewport that takes no input, or to route it yourself.
  *
  * **Screen-space source layers** (e.g., debug overlays, selection chrome)
- * still render to the outer canvas, not into the viewport. To include
- * them, wrap them as world-space layers first.
+ * draw in the viewport's own CSS-pixel space: their coords are relative to
+ * the rect's top-left, and they clip to it, rather than to the outer canvas.
  */
-interface CreateViewportLayerOpts<TData> {
+interface CreateViewportLayerOpts<TData, TSource = TData> {
     id: string;
     label: string;
     /** Layers re-rendered through `view`. Each receives `(data, view, dims)`
-     *  exactly as the outer Canvas would call it. */
-    source: RenderLayer<TData>[];
-    /** The inner view. Static for now — a future revision will accept
-     *  `View | (outer: View, dims: Dims) => View` so derivations like
-     *  parallax and node-anchored scroll can compose. */
-    view: View;
+     *  exactly as the outer Canvas would call it.
+     *
+     *  Pass a thunk for a stack that is assembled elsewhere — it is read fresh
+     *  on every `draw`, the same way a thunked `view` is. */
+    source: readonly RenderLayer<TSource>[] | (() => readonly RenderLayer<TSource>[]);
+    /**
+     * The `data` the source layers receive, derived from what the outer canvas
+     * passed down. Omit and they get the outer canvas's own.
+     *
+     * A viewport showing the same scene through a second camera wants its own
+     * per-view helpers here — selection, chrome state and gesture previews that
+     * belong to *this* view rather than the one hosting it.
+     */
+    data?: (outer: TData) => TSource;
+    /**
+     * The inner view. Pass a thunk for a camera that moves — it is read fresh
+     * on every `draw`, `reproject` and `resolvable`, so those three cannot
+     * disagree about where the viewport is looking mid-gesture.
+     *
+     * The thunk receives the outer view and dims, so a derived camera
+     * (parallax, node-anchored scroll) is a function of the one hosting it.
+     */
+    view: View | ((outer: View, dims: Dims) => View);
     /** Where on the outer canvas this viewport is painted, in screen-space
      *  CSS pixels. Recomputed every frame so the rect can track an outer
      *  pose, follow a corner, etc. */
@@ -260,9 +353,9 @@ interface ViewportLayer<TData> extends RenderLayer<TData> {
      * `bounds` is a pure function of those, so this reproduces the exact rect
      * that was painted rather than a remembered one.
      *
-     * This does not touch the dispatcher: tools still receive outer-view
-     * coords, and a consumer that wants a click inside a viewport to mean
-     * something calls this from its own handler.
+     * This does not touch the dispatcher: a consumer that wants a click inside
+     * a viewport to mean something calls this from its own handler, or declares
+     * the viewport as a `<CanvasView>` and lets the canvas route to it.
      */
     reproject(outer: View, dims: Dims, screen: {
         x: number;
@@ -271,12 +364,20 @@ interface ViewportLayer<TData> extends RenderLayer<TData> {
         x: number;
         y: number;
     } | null;
+    /**
+     * This viewport as a routing candidate for {@link createViewResolver} —
+     * its inner view and the rect it paints into for the given outer frame.
+     *
+     * Pass the `outer` view and `dims` the frame was drawn with, for the same
+     * reason `reproject` wants them: `bounds` is recomputed, not remembered.
+     */
+    resolvable(outer: View, dims: Dims): ResolvableView;
 }
 /** Build a layer that renders other layers through a second view, inside a
  *  sub-region of the canvas — a minimap, an inset, a magnifier. Its
  *  `reproject` maps screen points back through the inner view so the region
  *  can be interacted with. */
-declare function createViewportLayer<TData>(opts: CreateViewportLayerOpts<TData>): ViewportLayer<TData>;
+declare function createViewportLayer<TData, TSource = TData>(opts: CreateViewportLayerOpts<TData, TSource>): ViewportLayer<TData>;
 /**
  * @experimental
  *
@@ -454,6 +555,71 @@ declare const DEFAULT_VELOCITY_DECAY = 0.4;
  */
 declare function useSimulation<TNode extends SimulationNode>(opts: UseSimulationOptions<TNode>): Simulation<TNode>;
 
+/**
+ * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one
+ * scene node needs: the node's world box, the projection from that box's
+ * frame into overlay pixels, and the overlay's measured size.
+ *
+ * This is the frame half of `subscribeView`'s "DOM pinned to world
+ * coordinates" case. Consumers positioning chrome over a node — gradient
+ * handles, a badge, a caret — otherwise re-derive it, and the
+ * translate-and-scale inverse that derivation usually reaches for drops
+ * `pose.rotation`, so the chrome sits where the node would be unrotated.
+ *
+ * `toScreen` maps the node's **unrotated world box** frame, which is the
+ * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the
+ * one `pathInPoseFrame` projects geometry into. Rotation lives in this hook,
+ * not in those: a node's stored geometry is pre-rotation by definition.
+ */
+
+/** Structural point, matching every other `{ x, y }` the kit passes across a
+ *  boundary. */
+interface OverlayPoint {
+    x: number;
+    y: number;
+}
+/** The overlay frame for one node. `null` from the hook means there is no
+ *  frame yet — no node, or nothing measured to draw it on. */
+interface NodeOverlayFrame {
+    /** The node's composed world box, **unrotated**: the frame `toScreen` maps
+     *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Node box frame → overlay pixels, rotation and view included. */
+    toScreen: (p: OverlayPoint) => OverlayPoint;
+    /** Overlay pixels → node box frame. Inverts `toScreen`. */
+    toLocal: (p: OverlayPoint) => OverlayPoint;
+    /** The container's size in CSS pixels — the overlay's own box. */
+    width: number;
+    height: number;
+}
+interface UseNodeOverlayFrameOptions<TPose> {
+    /**
+     * Current viewport. A thunk is re-read on every projection, which is what
+     * an uncontrolled `SceneCanvas` needs — its camera lives in a ref and moves
+     * without a render, so pass the handle's `getView`. A plain `View` is the
+     * value from the render that supplied it, correct for a controlled
+     * consumer. Omit it and world units are handed through as screen pixels.
+     */
+    view?: View | (() => View);
+    /** Fold a child pose into its parent's frame. Default `composeRectPose`. */
+    compose?: (parent: TPose, child: TPose) => TPose;
+}
+/**
+ * Resolve the overlay frame for `nodeId` against `containerRef` — the element
+ * the overlay is positioned in, which must be the canvas's own box for the
+ * projection to land.
+ *
+ * Returns `null` when there is no node under `nodeId`, when the container has
+ * not been measured, or when the view collapses an axis to zero — the three
+ * states in which an overlay has nothing to draw.
+ */
+declare function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(scene: Scene<TData, TLayer, TPose>, containerRef: RefObject<HTMLElement | null>, nodeId: string | null | undefined, options?: UseNodeOverlayFrameOptions<TPose>): NodeOverlayFrame | null;
+
 /**
  * Stylus / Pencil pointer-event helpers.
  *
@@ -790,7 +956,7 @@ interface CanvasSizeSnapshot extends CanvasSize {
  *  so dragging a window to a different-density display without resizing it
  *  left the snapshot stale. The profile watches a re-armed resolution media
  *  query instead. */
-declare function useCanvasSize(containerRef: RefObject<HTMLDivElement | null>): CanvasSizeSnapshot;
+declare function useCanvasSize(containerRef: RefObject<HTMLElement | null>): CanvasSizeSnapshot;
 
 /**
  * Handle/hit multiplier applied on a coarse pointer.
@@ -820,25 +986,23 @@ declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?:
 declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
 
 /**
- * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`.
- *
- * These were six separate literal `8`s and one `24` scattered across
- * `SceneCanvas`, `features/selection/overlay`, `affordances/cornerResize`,
- * `canvas/affordanceAt`, and `interactions/actions/rotate/handle`. They are
- * consolidated here because paint and hit-test MUST scale together: chrome
- * you can see but cannot grab is the exact failure `chrome-caps` exists to
- * make impossible, and duplicated literals in five files is how that failure
- * gets reintroduced.
+ * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`, and the
+ * one accessor that resolves them for a live pointer type.
  *
- * Multiply by `DeviceProfile.targetScale` at the point of use — the profile
- * is a runtime value, these are not.
+ * Paint and hit-test MUST scale together: chrome you can see but cannot grab
+ * is the exact failure `chrome-caps` exists to make impossible, and a literal
+ * `8` copied into a fifth file is how that failure gets reintroduced. So every
+ * kit-internal use site goes through {@link targetSizesPx} — the selection
+ * overlay's handle size, `buildAffordanceAt`'s hit radii, and the slops debug
+ * overlay all read the same object. The bare constants below stay exported for
+ * consumers, who get the unscaled numbers they always got.
  */
 /** Selection corner-handle visual size and hit radius. */
-declare const HANDLE_BASE_PX = 8;
+declare const HANDLE_BASE_PX: 8;
 /** Path anchor / control-point hit radius. */
-declare const ANCHOR_HIT_BASE_PX = 8;
+declare const ANCHOR_HIT_BASE_PX: 8;
 /** Distance from a selection's top edge to the rotation handle's center. */
-declare const ROTATION_HANDLE_BASE_PX = 24;
+declare const ROTATION_HANDLE_BASE_PX: 24;
 
 /**
  * Read the ambient device profile.
@@ -1007,7 +1171,17 @@ interface UseZoomReturn {
 declare function useZoom(opts: UseZoomOptions): UseZoomReturn;
 
 /**
- * Run `computeFitView` once when the viewport first has non-zero size, and
+ * Compute zoom and pan that fit `contentW x contentH` (in content units)
+ * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of
+ * each axis to fill (default 0.85 — leaves a uniform 15% margin).
+ */
+declare function computeFitViewport(viewportW: number, viewportH: number, contentW: number, contentH: number, padRatio?: number): {
+    zoom: number;
+    panX: number;
+    panY: number;
+};
+/**
+ * Run `computeFitViewport` once when the viewport first has non-zero size, and
  * apply the result via the supplied setters. Subsequent size changes are
  * ignored — this hook centers exactly once.
  */
@@ -1219,10 +1393,9 @@ declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
 /**
  * useHoverTracking — last-hovered NodeId for chrome-caps rules.
  *
- * Attaches a `pointermove` listener to the supplied canvas; on each
- * move, converts client coords → world coords and runs the supplied
- * `getNodeAtPoint`, caching the resulting id on a ref. Cleared on
- * `pointerleave` (pointer left the canvas → nothing is hovered).
+ * Attaches a `pointermove` listener to the supplied canvas; on each move it
+ * runs the supplied `nodeAtClientPoint` and caches the resulting id on a ref.
+ * Cleared on `pointerleave` (pointer left the canvas → nothing is hovered).
  *
  * Returns a stable getter — call once per frame from `buildChromeCtx`.
  *
@@ -1234,13 +1407,11 @@ declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
 /** Options for `useHoverTracking`. */
 interface UseHoverTrackingArgs {
     canvasRef: RefObject<HTMLCanvasElement | null>;
-    /** Client → world conversion. Same shape as the dispatcher's. */
-    clientToWorld: (clientX: number, clientY: number) => {
-        x: number;
-        y: number;
-    };
-    /** Topmost-id resolver. Returns null when the world point hits nothing. */
-    getNodeAtPoint: (worldX: number, worldY: number) => {
+    /** Topmost id under a client point, or null. One lookup rather than a
+     *  client→world thunk beside a world-space picker: a screen-pixel pick
+     *  tolerance converts against the camera the point resolved to, and two
+     *  thunks are two chances to disagree about which view that is. */
+    nodeAtClientPoint: (clientX: number, clientY: number) => {
         id: NodeId;
     } | null;
     enabled?: boolean;
@@ -1250,28 +1421,75 @@ interface UseHoverTrackingArgs {
  *  the component on every pointer move. */
 declare function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null;
 
+/**
+ * Project an action's keyboard bindings into the shape a shortcut chip
+ * renders from (`formatShortcut` / `formatShortcutParts` in
+ * `@weasel-js/ui`). Palette and menu surfaces show what an action answers
+ * to; the dispatcher reads the specs themselves.
+ */
+
+/** One keyboard shortcut, flattened for display. Structurally the
+ *  `ShortcutInput` weasel-ui formats — kept local so core doesn't depend on
+ *  the UI package. */
+interface ActionShortcut {
+    key: string;
+    mod: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/**
+ * The chip form of a single gesture spec, or `undefined` when the spec has
+ * none.
+ *
+ * Two kinds of collapsing, both because a binding list is written for a
+ * matcher rather than for a reader:
+ *
+ * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
+ *   shifted bracket reports as `'{'`). The first is the shortcut's name.
+ * - A modifier declared `'optional'` matches held or unheld, so it isn't
+ *   part of what the user has to press.
+ *
+ * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
+ * *required* `ctrl` or `meta` — nothing in the kit declares one, and the
+ * display shape carries only `mod`.
+ */
+declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
+/**
+ * Every keyboard shortcut an action answers to, in declaration order.
+ * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
+ * identical are emitted once; an action bound only to those returns empty.
+ */
+declare function actionShortcuts(action: Action): readonly ActionShortcut[];
+
 /**
  * `moveAction` — first `ongoing`-timing Action descriptor.
  *
  * Mirrors the per-frame translate semantics of the `useMove` hook:
  *   - `start`: capture origin poses for all selected nodes; record the
  *     current drag delta in scratch each frame.
- *   - `onMove`: update the in-scratch `currentDelta` only — no scene writes.
- *     This avoids polluting the undo stack with O(N-frames) entries.
+ *   - `onMove`: update the in-scratch `currentDelta`, and publish the frame's
+ *     poses as ephemeral overrides. No *document* writes, so the undo stack
+ *     still sees one entry for the whole drag.
  *   - `onEnd('commit')`: emit the final delta as transform ops and route
  *     them through the consumer `applyOps` hook when present, else
  *     `scene.applyBatch(ops, 'Move', adapter)` — either way a single batch
  *     → exactly one undo entry for the whole drag.
- *   - `onEnd('cancel')`: no scene writes — the scene was never mutated during
- *     the drag, so no restoration is needed.
+ *   - `onEnd('cancel')`: drop the overrides — the document was never mutated,
+ *     so the committed poses are the restoration.
  *
- * ## Why no per-frame scene writes
+ * ## Why no per-frame document writes
  *
  * `Scene.setPose` calls `executeAndLog`, which immediately records an undo
- * entry on the scene's history engine. Per-frame writes during drag would create
- * O(frames) history entries — matching `useMove`'s approach of tracking
- * poses only in React state (overlay) during the drag and committing a
- * single `createTransformOp` batch at the end.
+ * entry on the scene's history engine. Per-frame writes during drag would
+ * create O(frames) history entries, so the drag commits one
+ * `createTransformOp` batch at the end.
+ *
+ * The per-frame poses still go *somewhere* the scene can see: the ephemeral
+ * override table, which bypasses history entirely. That is what lets a node
+ * deriving its geometry from a dragged one follow the drag — `scenePoseLookup`
+ * and the pick source both read overrides, and neither can see this action's
+ * scratch. Keeping the frame in scratch alone is why the edge used to stay
+ * anchored to the old endpoint and jump on drop.
  *
  * The behavior pipeline (snap-to-grid, snap-back-or-delete, snap-to-container,
  * etc.) via `opts.behaviors` from `BindingOpts` IS wired: `start` builds a
@@ -1680,7 +1898,10 @@ declare const viewportDragPanAction: Action & {
  *
  * ## Bindings (parametric — each passes `params.kind`)
  * - `{ kind: 'wheel', mods: { mod: true } }` → Cmd+wheel, params: `{ kind: 'wheel' }`
- *   (also covers Mac trackpad pinch, which the browser synthesizes as ctrl+wheel)
+ * - `{ kind: 'wheel', mods: { ctrl: true } }` → trackpad pinch, params: `{ kind: 'wheel' }`.
+ *   Browsers synthesize a trackpad pinch as ctrl+wheel. On a Mac that is a
+ *   *different* event from the `mod` binding above (`mod` is metaKey there), so
+ *   pinch needs its own binding or nothing claims it and the page zooms instead.
  * - `{ kind: 'key', key: '=' }` → zoom in, params: `{ kind: 'in' }`
  * - `{ kind: 'key', key: '-' }` → zoom out, params: `{ kind: 'out' }`
  * - `{ kind: 'key', key: '0' }` → reset zoom, params: `{ kind: 'reset' }`
@@ -1694,13 +1915,27 @@ declare const viewportDragPanAction: Action & {
  * - `'in'`/`'out'`: step zoom by ×1.25 / ×0.8, anchored at the host center
  *   when the `view` dep wires `hostSize()` (SceneCanvas does), falling back
  *   to the canvas top-left origin for consumers that don't.
- * - `'reset'`: resets scale to 1, translation to 0.
+ * - `'reset'`: resets scale to 1, translation to 0, or calls the `view` dep's
+ *   `recenter()`.
+ *
+ * The three discrete branches glide instead of jumping when the `animate`
+ * option is configured and the `view` dep implements `animate` — they hand the
+ * action a target and nothing in between, which is the whole condition for
+ * tweening. `'wheel'` always jumps per sample.
  *
  * ## Key binding modifier notes
  * The key bindings (`=`, `-`, `0`) require `mod: true` (Cmd on Mac, Ctrl elsewhere).
  * This matches the behaviour of the dissolved `useKeyboardZoomTool`.
  */
 
+/**
+ * @experimental
+ * Tuning for the animated form of the discrete zoom steps.
+ */
+interface ViewportZoomAnimateOptions extends ViewAnimationOptions {
+    /** Duration for the Cmd+0 reset branch. Defaults to `ms`. */
+    resetMs?: number;
+}
 /**
  * @experimental
  * Tuning for {@link makeViewportZoomAction}.
@@ -1709,7 +1944,8 @@ interface ViewportZoomOptions {
     /**
      * Which wheel gesture triggers zoom.
      * - `'mod'` (default): Cmd/Ctrl+wheel — coexists with plain-wheel pan
-     *   (`viewport.wheelPan`) and Mac trackpad pinch (ctrl+wheel).
+     *   (`viewport.wheelPan`). A Mac trackpad pinch arrives as ctrl+wheel, which
+     *   `mod: true` forbids on Mac; nothing here handles it.
      * - `'plain'`: bare wheel, no modifier. Pair with `viewport.pan: false`,
      *   since plain wheel otherwise drives pan and the two would compete.
      */
@@ -1718,6 +1954,13 @@ interface ViewportZoomOptions {
     min?: number;
     /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */
     max?: number;
+    /**
+     * Glide the discrete steps (Cmd+=, Cmd+-, Cmd+0) instead of jumping.
+     * `true` uses the kit defaults; an object tunes them. Wheel and pinch never
+     * animate — their input already samples every frame. Requires a `view` dep
+     * that implements `animate`; without one this is ignored.
+     */
+    animate?: boolean | ViewportZoomAnimateOptions;
 }
 /**
  * @experimental
@@ -1865,12 +2108,31 @@ declare const lassoSelectAction: Action & {
 
 /**
  * @experimental
- * Static descriptor for the `viewport.pinchZoom` Action.
+ * Tuning for {@link makePinchZoomAction}.
+ */
+interface PinchZoomOptions {
+    /** Lower clamp on the resulting view scale, forwarded to `zoomAt`. Default 0.1. */
+    min?: number;
+    /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */
+    max?: number;
+}
+/**
+ * @experimental
+ * Build a `viewport.pinchZoom` Action descriptor with a configurable scale
+ * clamp. The binding (two-finger multitouch) is fixed; only the clamp varies.
  *
  * Requires dep-schema entries: `view`.
  *
  * The invoker is `ongoing`. Zoom is applied per-frame via `view.set(zoomAt(...))`.
  */
+declare function makePinchZoomAction(opts?: PinchZoomOptions): Action & {
+    requires: string[];
+};
+/**
+ * @experimental
+ * Default `viewport.pinchZoom` descriptor: two-finger pinch with the kit's
+ * default 0.1–8 scale clamp. Equivalent to `makePinchZoomAction()`.
+ */
 declare const pinchZoomAction: Action & {
     requires: string[];
 };
@@ -1916,10 +2178,9 @@ declare function useStandardActions(opts: UseStandardActionsOptions): void;
  * this adapter. It carries the scene-backed op-apply methods (`setPose` /
  * `setParent` / `setData` / `setLayer` / `removeNode` / `insertNode` /
  * `setChildOrder`) plus the read-side queries (`getNode` / `getNodes` /
- * `getPose` / `getParent` / `getChildren`). Known exclusions from the op
- * factory roster — surfaces the scene doesn't own: `setSelection` (spread
- * `SelectionApi.adapterMethods` over this adapter when selection-carrying
- * ops must replay), `setPath`, and `setText`.
+ * `getPose` / `getParent` / `getChildren` / `getSelection`) and
+ * `setSelection`. Known exclusions from the op factory roster — surfaces the
+ * scene doesn't own: `setPath` and `setText`.
  *
  * Lives in `interactions/actions/` (not `canvas/sceneAdapter.ts`) so default
  * actions never import from `canvas/` — that back-edge would create an
@@ -1929,12 +2190,14 @@ declare function useStandardActions(opts: UseStandardActionsOptions): void;
 
 /** Build the adapter the default actions commit through when the consumer
  *  supplies no `applyOps` hook of its own — it applies ops straight to the
- *  scene. Selection, path and text ops are not covered; those surfaces belong
- *  to their own owners. */
+ *  scene. Path and text ops are not covered; those surfaces belong to their
+ *  own owners. */
 declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose>): {
     getNode: (id: string) => Node$1<unknown, string, TPose> | undefined;
     getNodes: () => Node$1<unknown, string, TPose>[];
     getPose: (id: string) => TPose;
+    getSelection: () => string[];
+    setSelection: (ids: string[]) => void;
     getParent: (id: string) => string | null;
     getChildren: (parentId: string | null) => string[];
     setChildOrder: (parentId: string | null, orderedIds: string[]) => void;
@@ -1962,6 +2225,63 @@ declare function useResizePolicy<TPose>(options: UseResizePolicyOptions<TPose>):
  *  run against the consumer's geometry. */
 declare function useSliceDep(dep: SliceDep): void;
 
+/**
+ * Everything about handling an input event that depends on *which view* it
+ * landed in: the dispatcher that runs it, and the three lookups that resolve
+ * a client point against that view's camera.
+ *
+ * @internal One per view. The hook builds the `id: null` one from its flat
+ *   options; `views` supplies the rest, and the hook chooses between them per
+ *   event, so that it — and its listener set — still mounts exactly once.
+ */
+interface DispatcherViewTarget {
+    /** `null` is the root view — the whole canvas. Matches `ViewTarget.id`. */
+    id: string | null;
+    dispatcher: Dispatcher;
+    affordanceAt: UseGestureDispatcherOptions['affordanceAt'];
+    classifyTarget: UseGestureDispatcherOptions['classifyTarget'];
+    clientToWorld: UseGestureDispatcherOptions['clientToWorld'];
+    /**
+     * The deps this view answers for itself — its camera, its selection, and
+     * whatever else is per-view rather than per-canvas. Read per event; every
+     * name it does not carry still resolves through the canvas registry.
+     *
+     * This is why a view does not get a `DepRegistryProvider` of its own. The
+     * registry is where a consumer registers *sources*, and one per view would
+     * fragment that: a consumer overriding `insert` would have to know how many
+     * views exist and override each. An overlay keeps one place to register and
+     * one authority per dep, with the view claiming only what is genuinely its.
+     *
+     * Without this a gesture inside a panel pans the whole canvas and selects
+     * into the canvas's selection — correct coordinates alone do not make
+     * routing correct.
+     */
+    deps?: () => Partial<DepSchema>;
+    /**
+     * This view's chrome-caps rule context, for the eligibility filter. The rule
+     * table is the surface's, but a rule keyed on selection or the in-flight
+     * action answers per view — so an action hidden in one panel must not
+     * decline a gesture in another. `undefined` means "nothing gates here", the
+     * same answer a surface with no mode registry gives.
+     */
+    getRuleCtx?: () => RuleCtx | undefined;
+}
+/**
+ * The part of `features/viewports`' `ViewResolver` the dispatcher needs: which
+ * view a client point belongs to, pinned to the view a gesture began in.
+ *
+ * @internal Structural on purpose — a `ViewResolver` satisfies it, and the
+ *   dispatcher stays free of the viewport module.
+ */
+interface ViewIdResolver {
+    begin(pointerId: number, clientX: number, clientY: number): {
+        id: string | null;
+    };
+    at(pointerId: number | null, clientX: number, clientY: number): {
+        id: string | null;
+    };
+    end(pointerId: number): void;
+}
 /** Options for `useGestureDispatcher`: the element to listen on, the actions
  *  and tools in play, and the hooks that turn raw DOM events into the world
  *  coordinates and hit targets bindings match against. */
@@ -2088,7 +2408,25 @@ interface UseGestureDispatcherOptions {
      * `Action.eligible` rule (omitted => always eligible). `<SceneCanvas>`
      * wires this; tests / harnesses without chrome-caps state can omit it.
      */
-    getRuleCtx?: () => RuleCtx;
+    getRuleCtx?: () => RuleCtx | undefined;
+    /**
+     * Routing for a canvas hosting more than one view: the non-root dispatch
+     * records to choose between, read fresh per event, and the resolver that
+     * chooses. Omit for a single view — then every event runs on the record the
+     * flat options above describe, which is what they are: view zero.
+     *
+     * A resolved id with no live record falls back to the root, so a view that
+     * unmounts mid-gesture degrades instead of dropping the event.
+     *
+     * Keyboard and paste have no coordinates to resolve; they run on the view
+     * the last coordinate-bearing event resolved to.
+     *
+     * @internal
+     */
+    views?: {
+        targets: () => readonly DispatcherViewTarget[];
+        resolver: ViewIdResolver;
+    };
 }
 /**
  * Attach the input pipeline to a canvas: DOM pointer, wheel, keyboard and
@@ -2101,6 +2439,56 @@ interface UseGestureDispatcherOptions {
  */
 declare function useGestureDispatcher(opts: UseGestureDispatcherOptions): void;
 
+/**
+ * The one place weasel decides whether a frame may run, so that "a loop does no
+ * work nobody can see" holds by construction rather than by every loop author
+ * remembering. Nothing runs while the document is hidden; a loop that names an
+ * element also stops while that element is outside the viewport.
+ *
+ * A request made while suspended is held, not dropped, and re-armed when the
+ * surface comes back — so a loop never needs to poll visibility itself.
+ */
+
+/** What a loop names as its element, resolved every time the gate is consulted
+ *  so a ref filled in after mount still starts the observer. */
+type VisibleRafTarget = RefObject<Element | null> | (() => Element | null);
+interface VisibleRafOptions {
+    /** Also gate on this element's intersection with the viewport. Omit it and
+     *  the loop is gated on document visibility alone. */
+    target?: VisibleRafTarget;
+    /**
+     * Run frames regardless of visibility. The escape hatch for a loop that is
+     * not painting for a viewer — an offscreen recording, an export driving its
+     * own frames. It is the wrong fix for a loop that stalls after a tab switch:
+     * that is a missing `request()`, and setting this hides it.
+     */
+    dangerouslyRunWhenHidden?: boolean;
+    /** Frame clock. Read live, so a test may inject one after mount. */
+    requestFrame?: (cb: FrameRequestCallback) => number;
+    cancelFrame?: (handle: number) => void;
+    /**
+     * Runs once when the loop leaves suspension, before the frame that follows
+     * it. Where a loop that measures elapsed time drops the interval it spent
+     * suspended — without it, an hour hidden arrives as one hour-long frame.
+     */
+    onResume?: () => void;
+}
+interface VisibleRaf {
+    /** Ask for a frame. Idempotent while one is outstanding, and held rather than
+     *  dropped while suspended. Identity is stable for the component's lifetime. */
+    request(): void;
+    /** Drop the outstanding request, held or scheduled. */
+    cancel(): void;
+    /** Whether a frame would run right now. */
+    isVisible(): boolean;
+}
+/**
+ * @param frame Runs on the frame, with the timestamp the clock supplied.
+ *   A continuous loop calls `request()` again from inside it; a one-shot loop
+ *   does not.
+ */
+declare function useVisibleRaf(frame: (time: number) => void, options?: VisibleRafOptions): VisibleRaf;
+
 /**
  * Pure wheel-event reducer. Stateless sibling of `useZoom`'s
  * `onWheel` handler — useful in tests, in non-React reducers, or anywhere
@@ -2194,17 +2582,6 @@ declare function useDecayLoop(): {
     cancel: () => void;
 };
 
-/** Animate the view from where it is to a target view — zoom-to-fit,
- *  zoom-to-selection, and anything else that should glide rather than jump. */
-declare function useViewTween(setView: (v: View) => void): {
-    animateTo: (from: View, to: View, opts?: {
-        duration?: number;
-        easing?: (t: number) => number;
-    }) => void;
-    cancel: () => void;
-    isAnimating: React$1.RefObject<boolean>;
-};
-
 /**
  * Detects two-finger pinch on a canvas element.
  *
@@ -2218,31 +2595,11 @@ declare function usePinchGesture(canvasRef: React.RefObject<HTMLCanvasElement |
     y: number;
 }, scaleFactor: number) => void, enabled?: boolean): void;
 
-/** Options accepted by {@link useViewAnimation}'s `animateToBounds`. */
-interface AnimateToBoundsOptions extends FitViewToBoundsOptions {
-    /** Tween duration in ms (forwarded to `animateTo`). */
-    duration?: number;
-    /** Tween easing (forwarded to `animateTo`). */
-    easing?: (t: number) => number;
-}
 /**
- * Tween the viewport `View` between values. Wraps `useViewTween`'s `animateTo`
- * + `cancel`, and adds an `animateToBounds` convenience that composes
- * `fitViewToBounds` with the existing tween so consumers can say "zoom to this
- * bounds with animation" in one call.
- *
- * `animateToBounds` needs the current `View` and the current viewport
- * dimensions to compute the target — both are passed as arguments so this
- * hook stays a leaf (no canvas-size subscription, no `View` storage).
+ * `InterpolatorFactory<View>` for camera animation — built once per animation,
+ * called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.
  */
-declare function useViewAnimation(setView: (v: View) => void): {
-    animateTo: (from: View, to: View, opts?: {
-        duration?: number;
-        easing?: (t: number) => number;
-    }) => void;
-    animateToBounds: (bounds: Bounds, currentView: View, viewportDims: ViewportDims, opts?: AnimateToBoundsOptions) => void;
-    cancel: () => void;
-};
+declare function interpolateView(from: View, to: View): (t: number) => View;
 
 /**
  * Build a `Tool<TScratch>` from a declarative `ToolDef<TScratch>`.
@@ -2358,7 +2715,7 @@ interface UseKeybindingsOptions {
 declare function useKeybindings(tools: ToolsApi, options?: UseKeybindingsOptions): void;
 
 /** The value types a built-in pref leaf can hold. */
-type ToolPrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint';
+type ToolPrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint' | 'object';
 interface ToolPrefBase<K extends string, Value> {
     kind: K;
     /** Human-readable label. */
@@ -2373,6 +2730,12 @@ interface ToolPrefBase<K extends string, Value> {
      *  (weasel-ui `PrefsForm` honors this for leaves whose control brings
      *  its own chrome). */
     block?: boolean;
+    /** Glyph naming this leaf in a host UI's icon set (weasel-ui resolves it
+     *  against `ICON_PATHS`). A plain string because core ships no icon set and
+     *  cannot depend on one. Read where a leaf's `name` has nowhere to go — a
+     *  `pair`ed row is labeled by the pair, so its fields have only the glyph
+     *  to tell them apart. */
+    icon?: string;
     /** Row-pairing hint for compact property UIs (weasel-ui
      *  `SelectionPanel`): leaves sharing a `pair` id render side-by-side
      *  on one row labeled with the `pair` string (e.g. `'Position'` for
@@ -2386,7 +2749,7 @@ type ToolPrefBooleanControl = 'checkbox' | 'switch';
 /** How a schema-driven UI should present a string pref. */
 type ToolPrefStringControl = 'input' | 'textarea';
 /** How a schema-driven UI should present an enum pref. */
-type ToolPrefEnumControl = 'select' | 'radio';
+type ToolPrefEnumControl = 'select' | 'radio' | 'toggle';
 /** Display-unit conversion for number leaves whose stored value uses a
  *  canonical unit the user shouldn't see (e.g. radians stored, degrees
  *  shown). The stored value stays canonical; UIs convert at the edge. */
@@ -2413,13 +2776,51 @@ interface ToolPrefBoolean extends ToolPrefBase<'boolean', boolean> {
 interface ToolPrefString extends ToolPrefBase<'string', string> {
     control?: ToolPrefStringControl;
 }
+/**
+ * Stored-value bridge for an enum leaf whose value is not the option string —
+ * the counterpart of {@link ToolPrefNumberUnit}, which does the same for a
+ * number stored in a canonical unit.
+ *
+ * A dash array is the case that needs it: `Stroke.dash` stores lengths, and
+ * the thing a person chooses is a style. The presets scale by the stroke's
+ * width, so both directions are given the object's other fields — a style is
+ * meaningless without the width it is a multiple of.
+ */
+interface ToolPrefEnumEncoding<T extends string = string> {
+    /**
+     * The option `stored` reads as, or `undefined` for none — which a UI shows
+     * the way it shows a mixed selection, by selecting nothing.
+     *
+     * `siblings` is the object the leaf is a field of, or `undefined` when the
+     * node does not hold that object (and for a top-level leaf, which has none).
+     */
+    read: (stored: unknown, siblings: Record<string, unknown> | undefined) => T | undefined;
+    /** What to store for `option`. `undefined` removes the field. */
+    write: (option: T, siblings: Record<string, unknown> | undefined) => unknown;
+}
 /** A pref with a fixed set of labeled choices. */
 interface ToolPrefEnum<T extends string = string> extends ToolPrefBase<'enum', T> {
+    /** `short` is the label a segmented control uses when a full one would not
+     *  fit — a capital or two. `icon` names a glyph in the host UI's set
+     *  (weasel-ui resolves it against `ICON_PATHS`) and outranks `short` where
+     *  it resolves. It is a plain string because core ships no icon set and
+     *  cannot depend on one. The full `label` stays the accessible name, so
+     *  neither the abbreviation nor the glyph becomes the only thing naming
+     *  the option.
+     *
+     *  `disabled` marks an option a control reports but cannot author — the
+     *  value a stored form reads as when it matches nothing offered. Dropping it
+     *  from the list instead would leave the control selecting nothing and
+     *  claiming the field is unset. */
     options: readonly {
         value: T;
         label: string;
+        short?: string;
+        icon?: string;
+        disabled?: boolean;
     }[];
     control?: ToolPrefEnumControl;
+    encoding?: ToolPrefEnumEncoding<T>;
 }
 /** A single color, stored as a hex string. For a value that may also be a
  *  gradient or a pattern, use {@link ToolPrefPaint} instead. */
@@ -2434,8 +2835,7 @@ interface ToolPrefColor extends ToolPrefBase<'color', string> {
  * app-supplied renderer. Deliberately NOT index-signatured so concrete
  * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.
  */
-interface ToolPrefCustom extends ToolPrefBase<string, unknown> {
-}
+type ToolPrefCustom = ToolPrefBase<string, unknown>;
 /**
  * A whole `FillStyle`, not a color inside one. Use it wherever the value is
  * the tagged paint union — a solid color, a pattern, a gradient — rather
@@ -2451,13 +2851,60 @@ interface ToolPrefPaint extends ToolPrefBase<'paint', unknown> {
     /** Offer an opacity control alongside the color. */
     alpha?: boolean;
 }
+/**
+ * A leaf whose value is one object, with its own fields hanging off it.
+ *
+ * A compound value — a stroke, a shadow, a pattern spec — could be described
+ * as several sibling leaves addressing into it (`data.stroke.width`,
+ * `data.stroke.cap`). It shouldn't be: each control would then write one field
+ * of a value it can only half see, and writing into something that is not an
+ * object yet corrupts it. Here the fields are `children` of one leaf, and
+ * every edit commits the parent object whole.
+ *
+ * `children` paths are relative to the object. They are ordinary leaves, so a
+ * field that is itself a union (a stroke's `paint`) declares the kind that
+ * edits that union. A child may also be a {@link ToolPrefGroup}, which
+ * organises the fields under a heading without contributing to the path —
+ * the same rule group keys follow at the top level. A `TextStyle` needs it:
+ * its character and paragraph fields belong to one value but read as two
+ * lists.
+ */
+interface ToolPrefObject extends ToolPrefBase<'object', unknown> {
+    children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
+    /**
+     * Lift a non-object value into the object form, for a consumer field that
+     * may also be held as a scalar. Called before a child edit is applied;
+     * without it a scalar-valued leaf shows its children empty and refuses the
+     * edit.
+     */
+    fromScalar?: (value: unknown) => Record<string, unknown>;
+}
 /** One built-in pref leaf. `ToolPrefLeaf` widens this to include
  *  app-defined kinds. */
-type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor | ToolPrefPaint;
+type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor | ToolPrefPaint | ToolPrefObject;
+/**
+ * The built-in kinds, as a table. A kind added to {@link ToolPrefKind} is a
+ * compile error here, and from here it is one in every renderer's `never`
+ * guard — the only thing standing between a new kind and rendering as
+ * nothing in four places at once.
+ */
+declare const TOOL_PREF_KINDS: Record<ToolPrefKind, true>;
+/**
+ * Narrows a leaf to the built-in union, so a renderer's switch discriminates
+ * on {@link ToolPrefKind} instead of the open `string` that
+ * {@link ToolPrefCustom} widens `kind` to. An app-defined kind answers false
+ * and belongs to the renderer's custom-renderer path.
+ */
+declare function isBuiltinToolPref(leaf: ToolPrefLeaf): leaf is ToolPref;
 /** Built-in or app-defined leaf. */
 type ToolPrefLeaf = ToolPref | ToolPrefCustom;
 /** Nestable group: branch nodes a tool can use to organize its prefs. */
 interface ToolPrefGroup {
+    /** Heading for the group's rows. **Empty means no heading** — for a group
+     *  that exists to organise, not to name: one whose children are themselves
+     *  groups carrying the labels a reader needs. Give it a name whenever the
+     *  name is the referent (a `Border` group over `Top` / `Right` / `Bottom`
+     *  reads as nothing without it). */
     name: string;
     description?: string;
     children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
@@ -2558,8 +3005,8 @@ declare function useSelectTool<TNode extends {
     id: string;
 }, TPose>(adapter: SelectAdapter<TNode, TPose>, options: UseSelectToolOptions<TPose>): Tool<null>;
 
-/** Options for `useRotateTool` — mostly the placement and hit size of the
- *  rotation handle. */
+/** Options for `useRotateTool` — mostly the placement of the rotation
+ *  handle's hover band. */
 interface UseRotateToolOptions<TNode extends {
     id: string;
 }, _TPose> {
@@ -2569,10 +3016,10 @@ interface UseRotateToolOptions<TNode extends {
      *  backwards-compat with consumers (notably `SceneCanvas`'s
      *  `rotateOptions`) that still pass a value. */
     rotate?: unknown;
-    /** Distance from top edge of bounds to rotation handle center. Default: 24. */
+    /** Minimum thickness of the rotate band outside the selection AABB, in
+     *  screen px. Defaults to {@link ROTATION_HANDLE_BASE_PX}; `<SceneCanvas>`
+     *  passes the device-scaled value. */
     rotationHandleDistance?: number;
-    /** Square hit-radius for the rotation handle. Default: 8. */
-    handleHitRadius?: number;
     /** World-space bounds lookup. Required for the rotation affordance hit-test
      *  in consumers that wire a `boundsOf` source separately from the
      *  ChromeState-driven affordance pipeline. Retained for parity with
@@ -2706,12 +3153,29 @@ declare function useHandTool(opts?: UseHandToolOptions): Tool<HandScratch | null
  *  factories and hit gating belong on those deps, not on the tool. */
 declare function useTextTool(): Tool<undefined>;
 
+/** The camera a pinch acts on, and the origin its anchor is measured from. */
+interface PinchZoomTarget {
+    view: View;
+    setView: (v: View) => void;
+    /** Client-space origin of the surface this camera paints into. */
+    origin: {
+        left: number;
+        top: number;
+    };
+}
 /** Options for `usePinchZoomTool`: the zoom limits, and whether it is wired
  *  at all. */
 interface PinchZoomToolOpts {
     min?: number;
     max?: number;
     enabled?: boolean;
+    /**
+     * Which camera the anchor point belongs to. Return `null` — or omit this —
+     * for the canvas's own. A canvas hosting several views resolves the point
+     * here, so a pinch inside a panel zooms the panel rather than the canvas
+     * underneath it.
+     */
+    resolveTarget?: (clientX: number, clientY: number) => PinchZoomTarget | null;
 }
 /**
  * Two-finger pinch zoom on the canvas. Standalone hook (not a Tool record)
@@ -2719,8 +3183,12 @@ interface PinchZoomToolOpts {
  *
  * The anchor point under the gesture midpoint stays fixed on screen as the
  * view scales.
+ *
+ * @param getView Read at gesture time, not at render time: each pinch move
+ *   applies a per-frame delta to the view the previous move produced, and the
+ *   canvas does not re-render between them.
  */
-declare function usePinchZoomTool(canvasRef: React.RefObject<HTMLCanvasElement | null>, view: View, setView: (v: View) => void, opts?: PinchZoomToolOpts): void;
+declare function usePinchZoomTool(canvasRef: React.RefObject<HTMLCanvasElement | null>, getView: () => View, setView: (v: View) => void, opts?: PinchZoomToolOpts): void;
 
 /**
  * In-progress pen anchor. `outHandle` is set when the anchor was placed via
@@ -3132,6 +3600,35 @@ interface CanvasExtensionApi {
      *  (Replaces the pre-A2 pattern where `ref.current` directly *was* the element.) */
     readonly element: HTMLCanvasElement | null;
     requestRedraw(): void;
+    /**
+     * Run `fn` after every paint, on the frame that painted — for chrome that
+     * must observe landed pixels (a loupe readback, a frame counter). Returns
+     * an unsubscribe.
+     */
+    subscribeFrame(fn: () => void): () => void;
+    /** The current view. Readable mid-frame — this is the value the next paint
+     *  will use, not a value from the last React commit. */
+    getView(): View;
+    /**
+     * Set the view without a React render: the ref updates now and the next
+     * frame paints with it.
+     *
+     * Not applied locally when the canvas is controlled by a `view` prop — there
+     * the prop is the authority and a local write would only desynchronize
+     * pixels from props. The value still goes out through `onViewChange`, so a
+     * controlled owner can honor it; without an `onViewChange` it is dropped.
+     * Either way the canvas warns once per mount.
+     */
+    setView(next: View | ((current: View) => View)): void;
+    /** Called after each view change, for chrome that mirrors the camera — a
+     *  zoom readout, a minimap, DOM pinned to world coordinates. Returns an
+     *  unsubscribe. */
+    subscribeView(fn: (view: View) => void): () => void;
+    /** The `contentVersion` the current pixels were painted from — on
+     *  `<SceneCanvas>`, the scene version. Chrome in lockstep with canvas
+     *  content compares this against the version it is about to render and
+     *  defers a frame when they differ. `0` until the first paint lands. */
+    getPaintedVersion(): number;
     /** Register an externally-owned RenderLayer. The layer participates in the
      *  draw stack and, if it implements `hitTest`, in {@link hitTestExtras}. */
     registerLayer(layer: RenderLayer<unknown>): () => void;
@@ -3148,8 +3645,17 @@ interface CanvasExtensionApi {
      * `strength` carry through from the hit when the layer sets them.
      * A layer's owner binds a `kindOf` predicate on that kind to claim the
      * gesture; see `@weasel-js/hud` for the worked example.
+     *
+     * `frame` names the camera and surface size the point is expressed against.
+     * Omit it for the canvas's own view — the only case until a caller routes
+     * input to a viewport node, where the point is in that node's inner world
+     * and a layer resolving screen-pixel tolerances needs its view and rect
+     * size rather than the canvas's.
      */
-    hitTestExtras(worldX: number, worldY: number): {
+    hitTestExtras(worldX: number, worldY: number, frame?: {
+        view: View;
+        dims: Dims;
+    }): {
         layerId: string;
         hit: LayerHit;
     } | null;
@@ -3180,21 +3686,50 @@ interface SceneCanvasApi extends CanvasExtensionApi {
         x: number;
         y: number;
     }): void;
+    /**
+     * Glide the camera to `to` rather than jumping there — a fit-to-selection, a
+     * recenter, a scripted tour. A thunk receives the pending target when an
+     * animation is already in flight, so steps compound. Any other view write
+     * cancels it.
+     */
+    animateView(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;
+    /** Cancel a camera animation. The view stays where it is. */
+    stopViewAnimation(): void;
+    isViewAnimating(): boolean;
 }
 
 /**
- * Union math behind `CanvasHelpers.getGestureBounds()`.
+ * The seam `<Canvas>` reads in-flight gesture state through.
  *
  * `getGestureBounds` answers "where is the thing the user is dragging right
  * now, in total?" — a question every other lookup on `CanvasHelpers` can't
  * answer because they're keyed by node id, and a drag-to-insert has no node
- * yet. Canvas collects the parts (preview bounds per in-flight id, plus any
- * id-less nascent-insert AABBs) and folds them here.
+ * yet. `<Canvas>` collects the parts named here and folds them with
+ * `unionAABB` (`core/geometry/unionBounds`).
  *
- * Kept free of tool / dispatcher types so it stays a pure geometry fold that
- * both `<Canvas>` and its tests can call without a render.
+ * Kept free of the dispatcher itself so `<Canvas>` stays dispatcher-agnostic:
+ * it owns the `CanvasHelpers` contract, and the live gesture state lives in
+ * the dispatcher. The overlay and preview shapes an action publishes are data,
+ * and travel through here as such.
  */
 
+/**
+ * A source of in-flight preview state — a tool from the tools registry, or an
+ * `OngoingHandle` from the dispatcher's in-flight map. Readers merge several
+ * with first-non-null semantics.
+ *
+ * @public
+ */
+interface GesturePreviewSource {
+    previewIds?(): Iterable<string> | null;
+    previewPose?(id: string): unknown;
+    /** Companion to `previewPose` for actions that mutate node data (anchor
+     *  edits on `data.path` nodes). Absent/null falls back to committed data. */
+    previewData?(id: string): unknown;
+    /** Subset of `previewIds` painted at full opacity rather than as a ghost —
+     *  a layout sibling reflowing to its destination is not in flight. */
+    previewOpaqueIds?(): Iterable<string> | null;
+}
 /**
  * Everything `<Canvas>` needs to know about in-flight gestures that it can't
  * see for itself.
@@ -3226,58 +3761,391 @@ interface GestureSource {
     subscribe(fn: () => void): () => void;
     /** Monotonic counter bumped on the same events `subscribe` fires on. */
     getVersion(): number;
+    /** The in-flight handles' preview surfaces, in dispatch order. What a ghost
+     *  layer paints from — read off the draw envelope so a layer drawn for one
+     *  view cannot report another's gesture. */
+    previewSources(): readonly GesturePreviewSource[];
+    /** The overlay shapes the in-flight handles publish — marquee, lasso, insert
+     *  preview, raw commands. */
+    overlays(): readonly OngoingOverlay[];
 }
 
 /**
- * Selection overlay primitives — render layers for drawing selection
- * outlines and corner resize handles in world space.
- *
- * Three pieces:
- *   - `composeSelectionPose` resolves the live pose for a selected id by
- *     consulting the move overlay first, then the resize overlay, then the
- *     stored pose. When `getChildren`/`isContainer` are supplied and the id
- *     resolves to a container, the returned pose is the union AABB of all
- *     transitive leaf poses (with the same precedence rules applied per leaf).
- *   - `createSelectionOutlineLayer` draws the outline rect for each selected
- *     id (container ids resolve to a union AABB via `getChildren`/`isContainer`).
- *   - `createSelectionHandlesLayer` draws resize-handle rects (default 4
- *     corners) for each selected id, with the same container-resolution rules.
- *
- * `createSelectionOverlayLayer` is a thin convenience that returns a single
- * `RenderLayer` whose draw runs the outline pass then the handles pass.
- *
- * **Pose shape:** TPose is generic; callers must supply `getBounds(pose)`
- * to project any pose into the AABB the renderer needs. For rect-shaped
- * poses (`{x, y, width, height}`) pass the identity. For `Path` poses pass
- * `boundsOfPath`. Container ids reduce via `unionBounds` over the projected
- * AABBs.
+ * The half of {@link CanvasHelpers} that belongs to one view — everything
+ * answered by a camera's own tools, gestures and selection. A canvas hosting
+ * several viewports needs one of these per view; the surface half is shared.
  */
-
-/** Options for `composeSelectionPose`. */
-interface ComposeSelectionPoseOpts<TPose> {
-    /** Move overlay; when present its `poses` map wins over everything else. */
-    moveOverlay?: {
-        poses: Map<string, TPose>;
-    } | null;
-    /**
-     * Resize overlay; consulted only when move overlay does not own the id.
-     * For container resize, `leafPoses` (when present) maps each leaf id under
-     * the container to its overlay pose. If absent the container falls back to
-     * stored leaf poses (defensive — container-resize integration is in flight).
-     */
-    resizeOverlay?: {
-        id: string;
-        currentPose: TPose;
-        leafPoses?: Map<string, TPose>;
-    } | null;
-    /** Fallback pose lookup (typically the stored/committed pose). */
-    getStoredPose: (id: string) => TPose;
+interface CanvasViewHelpers<TPose> {
+    /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,
+     *  otherwise the committed pose from the adapter. Returns `null` if the id
+     *  isn't known. */
+    getEffectivePose(id: string): TPose | null;
+    /** Overlay-aware bounds for `id`. */
+    getEffectiveBounds(id: string): Bounds | null;
     /**
-     * Project a pose into its AABB. Used when reducing a group of leaf poses
-     * into a single union AABB. Defaults to the identity — rect-shaped poses
-     * (`{x, y, width, height}`) need no override. For `Path` poses pass
-     * `boundsOfPath`.
-     */
+     * World-space AABB of everything the in-flight gesture proposes — the
+     * displaced poses of nodes being moved / resized / rotated / cloned, plus
+     * any nascent insert that has no scene node yet. `null` when no gesture is
+     * in flight.
+     *
+     * This reports the *gesture*, not the document: committed content the
+     * gesture isn't touching is excluded, so a consumer that wants the union
+     * with the rest of the scene still walks its own ids through
+     * `getEffectiveBounds`. It exists because every other lookup here is keyed
+     * by node id, which can't answer "where is the shape the user is drawing
+     * right now" — a drag-to-insert has no id until pointer-up.
+     *
+     * Select-only gestures are deliberately excluded: a marquee or lasso has
+     * geometry but proposes no content, and a consumer sizing itself to the
+     * gesture must not grow because the user swept a selection rectangle.
+     *
+     * The result is a plain AABB — never rotated. Rotated parts are folded in
+     * by their rotated extent (a union of several oriented boxes has no single
+     * orientation to report).
+     */
+    getGestureBounds(): Bounds | null;
+    /**
+     * Subscribe to the gesture layer's change signal — the other half of the
+     * `useSyncExternalStore` contract for everything on this object that moves
+     * during a drag (`getEffectivePose`, `getEffectiveBounds`,
+     * `getGestureBounds`). Returns an unsubscribe.
+     *
+     * Fires once per dispatcher pump: gesture start, every pointermove that
+     * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing
+     * actions (a slider bound to an ongoing action pumps the same way). It
+     * fires on the pump, not on a diff: a pump that changed nothing observable
+     * still notifies, so don't hang expensive work directly off the callback.
+     *
+     * It does **not** cover committed scene edits (subscribe to the scene for
+     * those) or previews a consumer's own tool publishes from React state
+     * (that tool re-renders on its own).
+     *
+     * Without a gesture source wired — a bare `<Canvas>` — this is a no-op
+     * subscription that never fires.
+     */
+    subscribeGestures(fn: () => void): () => void;
+    /**
+     * Monotonic counter bumped on exactly the events `subscribeGestures` fires
+     * on. Pair the two for `useSyncExternalStore`:
+     *
+     * ```ts
+     * const gestureVersion = useSyncExternalStore(
+     *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),
+     *   () => helpersRef.current?.getGestureVersion() ?? 0,
+     * );
+     * ```
+     *
+     * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with
+     * no gesture source reports, forever.
+     */
+    getGestureVersion(): number;
+    /** Returns the live ChromeState built once per render. Affordances and
+     *  custom layers that need overlay-aware selection state (selection ids,
+     *  bounds, multi-union AABB, modifier flags) read from this. */
+    getChromeState(): ChromeState;
+    /**
+     * Everything publishing an in-flight preview for this view, in resolution
+     * order: tool-side first (hotkey → active → registry → ambient), then the
+     * handles in flight on this view's dispatcher. Readers take the first
+     * non-null answer per id.
+     *
+     * A ghost layer must read this off its draw envelope rather than close over
+     * a dispatcher: one layer array paints every view, so a closure ghosts view
+     * zero's drag into every panel.
+     */
+    getPreviewSources(): readonly GesturePreviewSource[];
+    /** Overlay shapes this view's in-flight handles publish — marquee, lasso,
+     *  insert preview, raw commands. Same envelope rule as
+     *  {@link CanvasViewHelpers.getPreviewSources}. */
+    getGestureOverlays(): readonly OngoingOverlay[];
+    /**
+     * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and
+     * affordances call it per element to decide whether to draw / hit-test.
+     *
+     * The rule table is the surface's; the context it resolves against is this
+     * view's selection, camera and in-flight action — so the predicate belongs
+     * here rather than on {@link CanvasSurfaceHelpers}. Unwired, it is the
+     * universal `() => true`.
+     */
+    getIsVisible(): (id: string) => boolean;
+}
+/**
+ * The half of {@link CanvasHelpers} that belongs to the surface — one GL
+ * context, one debug sink, however many views are drawn on it.
+ */
+interface CanvasSurfaceHelpers {
+    /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that
+     *  want to participate in `hitboxes`/`bounds`/etc. visualization can
+     *  call into this from their `draw` callback. Returns `null` when
+     *  debug is off — no-op for production renders. */
+    getDebug(): DebugSink | null;
+}
+/** Live overlay-aware lookups exposed to custom layers via `helpersRef`.
+ *  What a layer receives as its `data` argument, unchanged: the two halves
+ *  are split so a per-view set can be built independently of the surface's,
+ *  not to make layers ask for one. */
+interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {
+}
+
+/**
+ * NodeShape — the **shape trait's** registry. Each trait of a node
+ * (shape, routing, label, icon, affordances, …) is its own registry;
+ * this one holds the per-kind `paint` + `silhouette` (and future
+ * fields) used by `defaultDrawOne`, clipping, non-rect hit-testing,
+ * and lasso/area-select.
+ *
+ * Teaching the kit about a new kind of shape goes through this registry
+ * rather than by overriding `drawOne`. Overrides are still possible but
+ * shouldn't be the default seam: most consumers want the same dispatch
+ * logic, just extended with their own shape kinds (images, custom paths,
+ * SVG fragments, etc.).
+ *
+ * Built-in entries (`kit:text`, `kit:path`, `kit:rect-fallback`) are
+ * registered at module load. Consumer entries added via
+ * `registerNodeShape` join the chain; the first entry whose
+ * `matches` predicate returns true paints the node.
+ *
+ * Two priority tiers:
+ *   - `'high'` — checked before all `'normal'` entries. Use this to
+ *     override a kit built-in for a specific data shape (e.g. a custom
+ *     text renderer that wins over `kit:text`).
+ *   - `'normal'` (default) — appended after the built-ins.
+ *
+ * Within a tier, entries run in registration order. Each
+ * `registerNodeShape` call returns a disposer that removes the
+ * entry — useful for tests, for plugin lifecycles, and for swapping
+ * implementations at runtime.
+ *
+ * See `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`
+ * for the trait taxonomy.
+ */
+
+/** Optional per-call paint context, threaded through `defaultDrawOne`'s third
+ *  argument. Lets a rendering entry point override ambient environment reads
+ *  — the headless `renderSceneToPixels` path supplies its own bitmap resolver
+ *  here so consumers reuse their own decode caches. Custom painters may
+ *  ignore it entirely. */
+interface NodePaintCtx {
+    /** Override bitmap resolution for image nodes. When set it is authoritative:
+     *  the global `imageCache` is not consulted, and an `undefined` result
+     *  paints the deterministic grey placeholder outline (never the ambient
+     *  load-status error variant). */
+    resolveImage?: (node: Node$1<unknown, string, unknown>) => ImageBitmap | undefined;
+    /** The node's derived path, resolved by the scene-aware `drawOne` wrapper
+     *  before painting: `paint` has no scene handle, and deriving needs the
+     *  dependencies' poses. **Absent** for a node that derives from nothing —
+     *  the wrapper hands such a node the caller's own ctx untouched. `null`
+     *  means the node derives but has nothing to draw. */
+    derivedPath?: Path | null;
+}
+/**
+ * Per-node draw function — the scene-slot `drawOne` signature shared by
+ * `<SceneCanvas>`, `renderSceneToCanvas` and `renderSceneToPixels`, so a
+ * consumer can reuse one callback across a main canvas and a detached view.
+ *
+ * Called once per node in the walk. Returned commands are world-space; the
+ * caller applies the view transform at the group level. `ctx` is supplied by
+ * the scene-aware wrappers — see {@link NodePaintCtx}.
+ */
+type SceneViewDrawOne<TData, TLayer extends string, TPose> = (node: Node$1<TData, TLayer, TPose>, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];
+/** A painter for one kind of node: which nodes it claims, and the draw
+ *  commands it emits for them. Registering one is how a consumer teaches the
+ *  default renderer to draw its own node kinds. */
+interface NodeShapeEntry<TData = unknown, TPose = unknown> {
+    /** Stable identifier — used for unregistration and debugging. Pick
+     *  something descriptive: `'kit:text'`, `'app:image'`, etc. */
+    id: string;
+    /** Returns true when this painter renders the node. The first matching
+     *  painter (`'high'` tier first, then `'normal'`) wins. */
+    matches(node: Node$1<TData, string, TPose>): boolean;
+    /** Emits the draw commands for the node's primary visual. `ctx` is an
+     *  optional per-call paint context (see `NodePaintCtx`); painters that
+     *  don't need it can keep a two-argument signature.
+     *
+     *  **The returned array belongs to the painter.** Callers must treat it as
+     *  immutable and copy before appending — a painter is free to memoize its
+     *  command list (`kit:shape` and `kit:path` do), and an in-place `push`
+     *  would grow that list on every frame. `defaultDrawOne` copies before
+     *  adding its label overlay for exactly this reason. */
+    paint(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];
+    /** Optional: derive the node's silhouette path from its pose.
+     *  Used by clipping (when the container has no explicit
+     *  `clipFromPose`), by non-rect hit-testing, and by lasso/area-select.
+     *  Painters whose visual has no meaningful closed silhouette (e.g. text)
+     *  leave this undefined. */
+    silhouette?(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodeSilhouetteCtx): Path | null;
+    /** Optional: how the silhouette is inked — whether the interior is filled,
+     *  and how wide the outline is. Read by picking, so that an unfilled shape
+     *  is grabbable by its outline rather than by its empty middle.
+     *
+     *  This is declared separately from `paint` rather than read back off the
+     *  emitted draw commands because picking runs on every pointer move, and
+     *  `paint` is allowed to be expensive (`kit:text` lays out glyphs). Keep it
+     *  to cheap field reads.
+     *
+     *  Painters that leave it undefined are treated as {@link DEFAULT_INK} —
+     *  the pre-`ink` behavior, where the whole silhouette interior is grabbable
+     *  and the outline adds nothing.
+     *
+     *  `ctx.scale` carries the view scale so a `{ px }` stroke width resolves to
+     *  world units; without it a screen-pixel width is read as world units. */
+    ink?(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodeInkCtx): NodeInk | null;
+}
+/** How a painter inks its silhouette. See {@link NodeShapeEntry.ink}.
+ *
+ *  Reach is per-side because `align` decides which side the ribbon lands on:
+ *  a centered stroke straddles the outline, `'inner'` puts nothing outside it,
+ *  `'outer'` nothing inside. */
+interface NodeInk {
+    /** True when the silhouette's interior is painted, and so grabbable. */
+    filled: boolean;
+    /** How far the ink reaches outside the outline, world units. */
+    outset: number;
+    /** How far it reaches inside. */
+    inset: number;
+}
+/** Per-call context for {@link NodeShapeEntry.silhouette}. */
+interface NodeSilhouetteCtx {
+    /** The node's derived path, resolved by the caller — a painter has no scene
+     *  handle and deriving needs the dependencies' poses. Same convention as
+     *  {@link NodePaintCtx.derivedPath}: absent for a node that derives from
+     *  nothing, `null` when it derives but has nothing to draw. */
+    derivedPath?: Path | null;
+}
+/** Per-call context for {@link NodeShapeEntry.ink}. */
+interface NodeInkCtx {
+    /** View scale, for resolving `{ px }` stroke widths to world units. */
+    scale?: number;
+}
+/** Options for `registerNodeShape`. */
+interface RegisterNodeShapeOptions {
+    /** `'high'` puts the painter ahead of all normally-registered ones (so
+     *  it can win over a kit built-in). `'normal'` appends at the end. */
+    priority?: 'high' | 'normal';
+}
+/** Register a shape painter. Returns a disposer that removes it. */
+declare function registerNodeShape<TData, TPose>(painter: NodeShapeEntry<TData, TPose>, opts?: RegisterNodeShapeOptions): () => void;
+/** Find the painter that will render `node` — first match in priority
+ *  order. Returns undefined if no painter (including the built-in
+ *  fallback) accepts the node. */
+declare function findNodeShape<TData, TPose>(node: Node$1<TData, string, TPose>): NodeShapeEntry<TData, TPose> | undefined;
+/** Find the painter for `node` and ask it for the node's silhouette path,
+ *  in **world** coords. Returns null if no painter matches, or the matching
+ *  painter has no `silhouette` method, or the method returns null. Used by
+ *  clipping, generic non-rect hit-testing and lasso/area-select — anywhere
+ *  the kit needs the "closed boundary" of whatever this kind of node draws as.
+ *
+ *  Painters return their silhouette in the pose's local (unrotated) frame;
+ *  this bakes `pose.rotation` on top via the shared rotation convention, so
+ *  clips/area-select of a rotated node use the rotated boundary the renderer
+ *  draws. (`paint()` is unaffected — it applies rotation via the render wrap,
+ *  not the silhouette, so there is no double-rotation.) */
+declare function findShapeSilhouette<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodeSilhouetteCtx): Path | null;
+/** Find the painter for `node` and ask how it inks its silhouette. Returns
+ *  the painter's declared {@link NodeInk}, or `null` when no painter matches
+ *  or it declares none — callers substitute {@link DEFAULT_INK}. */
+declare function findShapeInk<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodeInkCtx): NodeInk | null;
+/** Options for {@link shapeCoversPoint}. */
+interface ShapeCoversPointOptions {
+    /** Extra grab distance around the outline, in **world** units. Callers
+     *  derive it from a screen-pixel slop and the view scale, the same way
+     *  affordance hit radii work.
+     *
+     *  Without slop a hairline is a mathematically zero-width target: the
+     *  stroke of a 1px outline is half a world unit wide at scale 1, which no
+     *  one can hit. Defaults to `0` so a caller that hasn't thought about the
+     *  view still gets exact geometry rather than a wrong guess. */
+    tolerance?: number;
+    /** View scale, passed to the painter's `ink` so a `{ px }` stroke width
+     *  resolves to world units. Defaults to 1. */
+    scale?: number;
+    /** The node's derived path — see {@link NodeSilhouetteCtx.derivedPath}.
+     *  Without it a derived node reports no silhouette and this answers `true`
+     *  everywhere, which degrades picking to the caller's AABB: for an edge,
+     *  a zero-sized pose. */
+    derivedPath?: Path | null;
+}
+/**
+ * Does the shape `node` actually paints cover the world point?
+ *
+ * The pose rect says a node covers its whole bounding box. That is wrong for
+ * everything that is not a rectangle: the concave notch of a star, the corner
+ * outside an ellipse, the blank right half of a text box. This asks the
+ * painter's silhouette instead, which is the same boundary used for clipping
+ * and area-select, so "what you can click" and "what is drawn" answer
+ * together.
+ *
+ * "What is drawn" includes the *ink*, not just the boundary. A shape whose
+ * interior isn't filled — an outlined rect, a pencil stroke, a bare line — is
+ * grabbable along its outline and not through its empty middle, which is the
+ * opposite of what a fill test alone answers. The outline's grab width is the
+ * stroke's half-width plus `tolerance`.
+ *
+ * A painter with no `silhouette`, or one that returns `null` for this node
+ * (`kit:text` does, for a node with no non-blank lines), reports `true` —
+ * "no opinion", leaving the caller's own AABB test as the answer. Callers
+ * should keep that AABB test as a cheap pre-filter; this is the refinement,
+ * not a replacement.
+ *
+ * Rotation is already baked by `findShapeSilhouette`, so the point is in
+ * plain world coordinates.
+ */
+declare function shapeCoversPoint<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose, x: number, y: number, opts?: ShapeCoversPointOptions): boolean;
+/** Snapshot of the current painters in evaluation order — `'high'` tier
+ *  first, then `'normal'`. Useful for debugging which painter handles a
+ *  given node. */
+declare function getNodeShapes(): readonly NodeShapeEntry[];
+
+/**
+ * Selection overlay primitives — render layers for drawing selection
+ * outlines and corner resize handles in world space.
+ *
+ * Three pieces:
+ *   - `composeSelectionPose` resolves the live pose for a selected id by
+ *     consulting the move overlay first, then the resize overlay, then the
+ *     stored pose. When `getChildren`/`isContainer` are supplied and the id
+ *     resolves to a container, the returned pose is the union AABB of all
+ *     transitive leaf poses (with the same precedence rules applied per leaf).
+ *   - `createSelectionOutlineLayer` draws the outline rect for each selected
+ *     id (container ids resolve to a union AABB via `getChildren`/`isContainer`).
+ *   - `createSelectionHandlesLayer` draws resize-handle rects (default 4
+ *     corners) for each selected id, with the same container-resolution rules.
+ *
+ * `createSelectionOverlayLayer` is a thin convenience that returns a single
+ * `RenderLayer` whose draw runs the outline pass then the handles pass.
+ *
+ * **Pose shape:** TPose is generic; callers must supply `getBounds(pose)`
+ * to project any pose into the AABB the renderer needs. For rect-shaped
+ * poses (`{x, y, width, height}`) pass the identity. For `Path` poses pass
+ * `boundsOfPath`. Container ids reduce via `unionAABB` over the projected
+ * AABBs.
+ */
+
+/** Options for `composeSelectionPose`. */
+interface ComposeSelectionPoseOpts<TPose> {
+    /** Move overlay; when present its `poses` map wins over everything else. */
+    moveOverlay?: {
+        poses: Map<string, TPose>;
+    } | null;
+    /**
+     * Resize overlay; consulted only when move overlay does not own the id.
+     * For container resize, `leafPoses` (when present) maps each leaf id under
+     * the container to its overlay pose. If absent the container falls back to
+     * stored leaf poses (defensive — container-resize integration is in flight).
+     */
+    resizeOverlay?: {
+        id: string;
+        currentPose: TPose;
+        leafPoses?: Map<string, TPose>;
+    } | null;
+    /** Fallback pose lookup (typically the stored/committed pose). */
+    getStoredPose: (id: string) => TPose;
+    /**
+     * Project a pose into its AABB. Used when reducing a group of leaf poses
+     * into a single union AABB. Defaults to the identity — rect-shaped poses
+     * (`{x, y, width, height}`) need no override. For `Path` poses pass
+     * `boundsOfPath`.
+     */
     getBounds?: (pose: TPose) => Bounds;
     /**
      * Wrap an AABB back into a TPose. Called only when the resolver collapses
@@ -3300,15 +4168,10 @@ interface ComposeSelectionPoseOpts<TPose> {
  * precedence rules). Containers with no leaves resolve to `null`.
  */
 declare function composeSelectionPose<TPose>(opts: ComposeSelectionPoseOpts<TPose>): (id: string) => TPose | null;
-/** Shared options between outline and handles layers. */
+/** Options every selection layer shares. `getSelection` and `getPose` are
+ *  declared on {@link SelectionOverlayLayerOpts}, which makes both optional —
+ *  omitted, they come off the draw envelope. */
 interface SelectionLayerCommon<TPose> {
-    getSelection: () => readonly NodeId[];
-    /** Return null to skip rendering for an id (e.g. resolved pose unavailable).
-     *  Takes `string` rather than `NodeId` because the container-aware bounds
-     *  resolver internally walks expanded leaf ids via `getChildren`, which is
-     *  generic over arbitrary string ids. NodeIds flow in fine — a NodeId is a
-     *  string. */
-    getPose: (id: string) => TPose | null;
     /**
      * Project a pose into its AABB. Defaults to the identity — rect-shaped
      * poses (`{x, y, width, height}`) need no override. For `Path` poses pass
@@ -3322,46 +4185,38 @@ interface SelectionLayerCommon<TPose> {
     /** True when `id` is a structural container. */
     isContainer?: (id: string) => boolean;
 }
-/** Options for `createSelectionOutlineLayer`. */
-interface SelectionOutlineLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
-    /** Outline stroke style + outset distance from the pose rect. */
-    outline?: Stroke & {
-        pad?: number;
-    };
-}
-/** Options for `createSelectionHandlesLayer`. */
-interface SelectionHandlesLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
-    /** Handle visuals. Omit for defaults. */
-    handles?: {
-        size?: number;
-        fill?: FillStyle;
-        outline?: Stroke;
-    };
-    /** Override handle placement. Default: 4 corners of the AABB. */
-    handlesOf?: (bounds: Bounds) => {
-        x: number;
-        y: number;
-    }[];
-    /** Render a rotation handle above the (rotated) top-center of the AABB.
-     *  When `true`, uses default visuals + distance. When an object, override
-     *  the world-space distance from the top edge. Defaults to `false` —
-     *  consumers opt in only when wiring `useRotate`. */
-    rotationHandle?: boolean | {
-        /** World-pixel distance from the top edge to the handle center. */
-        distance?: number;
-    };
-}
+/** Options for `createSelectionOutlineLayer`. The overlay layer's options
+ *  minus the handle visuals — the two run the same body. */
+type SelectionOutlineLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'handles' | 'handlesOf' | 'rotationHandle'>;
+/** Options for `createSelectionHandlesLayer`. The overlay layer's options
+ *  minus the outline stroke — the two run the same body. */
+type SelectionHandlesLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'outline'>;
 /** Options for `createSelectionOverlayLayer`. */
 interface SelectionOverlayLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
+    /**
+     * Which ids to draw chrome for. Omit to take them from the `ChromeState` on
+     * the draw envelope, which is what makes one canvas's several views each
+     * outline their own selection — the layer is shared, the envelope is not.
+     *
+     * A multi-selection resolves to the synthetic union id, with the real
+     * members going to the outline pass, exactly as the explicit form does.
+     */
+    getSelection?: () => readonly NodeId[];
+    /**
+     * Resolve an id to the pose to draw chrome around. Return null to skip an
+     * id. Omit to take bounds from the same envelope `getSelection` omitted
+     * takes ids from — one cascade, the one the chrome state was built with,
+     * rather than a second one here that has to agree with it.
+     *
+     * Takes `string` rather than `NodeId` because the container-aware resolver
+     * walks expanded leaf ids via `getChildren`, which is generic over strings.
+     */
+    getPose?: (id: string) => TPose | null;
     outline?: Stroke & {
         pad?: number;
     };
     /** Pass `false` to render outlines only. */
-    handles?: {
-        size?: number;
-        fill?: FillStyle;
-        outline?: Stroke;
-    } | false;
+    handles?: SelectionHandleStyle | false;
     handlesOf?: (bounds: Bounds) => {
         x: number;
         y: number;
@@ -3382,10 +4237,16 @@ interface SelectionOverlayLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
      *  per-anchor chrome takes over. */
     getSuppressedIds?: () => ReadonlySet<string>;
 }
+/** Handle visuals, as a consumer supplies them. */
+interface SelectionHandleStyle {
+    size?: number;
+    fill?: FillStyle;
+    outline?: Stroke;
+}
 /**
  * `RenderLayer` that draws selection outlines only. Stack alongside
- * `createSelectionHandlesLayer` (or just use `createSelectionOverlayLayer`
- * for the common case) when both passes are wanted.
+ * `createSelectionHandlesLayer` (or use `createSelectionOverlayLayer`, which
+ * runs both passes in one layer) when both are wanted.
  */
 declare function createSelectionOutlineLayer<TPose>(opts: SelectionOutlineLayerOpts<TPose>): RenderLayer<unknown>;
 /**
@@ -3394,10 +4255,9 @@ declare function createSelectionOutlineLayer<TPose>(opts: SelectionOutlineLayerO
  */
 declare function createSelectionHandlesLayer<TPose>(opts: SelectionHandlesLayerOpts<TPose>): RenderLayer<unknown>;
 /**
- * Convenience wrapper that draws outlines then handles in a single layer.
- * Equivalent to stacking `createSelectionOutlineLayer` and
- * `createSelectionHandlesLayer` in a layer sequence. Pass `handles: false` to
- * render outlines only.
+ * Draws outlines then handles in a single layer. Exactly equivalent to
+ * stacking `createSelectionOutlineLayer` and `createSelectionHandlesLayer` —
+ * all three run the same body. Pass `handles: false` to render outlines only.
  */
 declare function createSelectionOverlayLayer<TPose>(opts: SelectionOverlayLayerOpts<TPose>): RenderLayer<unknown>;
 
@@ -3475,8 +4335,15 @@ interface SceneSlotConfig<TNode extends {
     objects?: TNode[];
     /** Project an object to its committed pose. Defaults to `adapter.getPose(obj.id)`. */
     toPose?: (obj: TNode) => TPose;
-    /** Draw a single object as a `DrawCommand` tree. */
-    drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[];
+    /** Draw a single object as a `DrawCommand` tree. `ctx` carries what only a
+     *  scene-aware caller can supply (a node's derived path); `<SceneCanvas>`
+     *  fills it in, bare `<Canvas>` never does. */
+    drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];
+    /** The path a container derives from its dependencies' poses, for the clip
+     *  it imposes on its subtree. The other half of what only a scene-aware
+     *  caller can supply — `drawOne`'s `ctx` carries the derived path a node
+     *  *paints*, this one the clip it *imposes*. */
+    derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;
     /** Default ghost alpha for the move-overlay slot. Default 0.85. */
     ghostAlpha?: number;
     /**
@@ -3575,6 +4442,20 @@ interface CanvasProps<TNode extends {
      *  same contract the headless `renderSceneToPixels` path follows (that
      *  path never reads ambient density at all). */
     dpr?: number;
+    /** The version of whatever content this canvas draws, sampled at paint time
+     *  and reported by {@link CanvasExtensionApi.getPaintedVersion}.
+     *  `<SceneCanvas>` wires this to `scene.getVersion`. Chrome that must not
+     *  show DOM ahead of pixels compares the two and defers a frame. */
+    contentVersion?: () => number;
+    /** Paint inside the React commit rather than on the next animation frame.
+     *  Costs a synchronous paint per commit and per redraw request; buys
+     *  single-commit consistency between React-rendered DOM and canvas pixels.
+     *  For consumers with DOM chrome pinned to canvas content that cannot
+     *  tolerate a frame of skew. Live: toggling it switches modes from the next
+     *  redraw on. A redraw requested from inside a layer's `draw`, or from a
+     *  `subscribeFrame` callback, still waits for a frame — painting it in place
+     *  would recurse. */
+    syncPaint?: boolean;
     /**
      * Combined adapter for scene-slot rendering, bounds computation, and
      * move/resize/rotate gesture math. Optional — bare-Canvas consumers that
@@ -3638,6 +4519,12 @@ interface CanvasProps<TNode extends {
     className?: string;
     style?: React__default.CSSProperties;
     tabIndex?: number;
+    /** Fired when the canvas element gains focus. The canvas is focusable by
+     *  default (`tabIndex` 0), so consumers driving focus-dependent chrome —
+     *  a focus ring, a "keyboard shortcuts active" hint — need to observe it. */
+    onFocus?: React__default.FocusEventHandler<HTMLCanvasElement>;
+    /** Fired when the canvas element loses focus. */
+    onBlur?: React__default.FocusEventHandler<HTMLCanvasElement>;
     /**
      * When `true` (default), the canvas element receives focus on `pointerdown`
      * so keyboard events (tool hotkeys, undo/redo) are captured without a
@@ -3746,7 +4633,9 @@ interface CanvasProps<TNode extends {
      * Hand tool registration, wheel pan/zoom action descriptors, and keyboard
      * zoom shortcuts are SceneCanvas-level concerns and are NOT owned by Canvas.
      * Those belong with the tool registry and gesture dispatcher that live in
-     * SceneCanvas.
+     * SceneCanvas — which is also why SceneCanvas does not pass this prop: it
+     * drives pinch through the `viewport.pinchZoom` action instead, and both
+     * paths at once would apply one gesture's zoom factor twice.
      *
      * When omitted, no pinch-zoom listener is attached.
      */
@@ -3819,528 +4708,26 @@ interface CanvasProps<TNode extends {
      * every chrome element visible (pre-chrome-caps behavior).
      */
     getIsVisible?: () => (id: string) => boolean;
-}
-/** Live overlay-aware lookups exposed to custom layers via `helpersRef`. */
-interface CanvasHelpers<TPose> {
-    /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,
-     *  otherwise the committed pose from the adapter. Returns `null` if the id
-     *  isn't known. */
-    getEffectivePose(id: string): TPose | null;
-    /** Overlay-aware bounds for `id`. */
-    getEffectiveBounds(id: string): Bounds | null;
-    /**
-     * World-space AABB of everything the in-flight gesture proposes — the
-     * displaced poses of nodes being moved / resized / rotated / cloned, plus
-     * any nascent insert that has no scene node yet. `null` when no gesture is
-     * in flight.
-     *
-     * This reports the *gesture*, not the document: committed content the
-     * gesture isn't touching is excluded, so a consumer that wants the union
-     * with the rest of the scene still walks its own ids through
-     * `getEffectiveBounds`. It exists because every other lookup here is keyed
-     * by node id, which can't answer "where is the shape the user is drawing
-     * right now" — a drag-to-insert has no id until pointer-up.
-     *
-     * Select-only gestures are deliberately excluded: a marquee or lasso has
-     * geometry but proposes no content, and a consumer sizing itself to the
-     * gesture must not grow because the user swept a selection rectangle.
-     *
-     * The result is a plain AABB — never rotated. Rotated parts are folded in
-     * by their rotated extent (a union of several oriented boxes has no single
-     * orientation to report).
-     */
-    getGestureBounds(): Bounds | null;
     /**
-     * Subscribe to the gesture layer's change signal — the other half of the
-     * `useSyncExternalStore` contract for everything on this object that moves
-     * during a drag (`getEffectivePose`, `getEffectiveBounds`,
-     * `getGestureBounds`). Returns an unsubscribe.
+     * Show or hide whole render layers by id. An id absent from the map falls
+     * back to the layer's own `defaultVisible`, and a layer marked `alwaysOn`
+     * ignores the map entirely.
      *
-     * Fires once per dispatcher pump: gesture start, every pointermove that
-     * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing
-     * actions (a slider bound to an ongoing action pumps the same way). It
-     * fires on the pump, not on a diff: a pump that changed nothing observable
-     * still notifies, so don't hang expensive work directly off the callback.
+     * Hiding a layer also stops it claiming pointer events through
+     * `hitTestExtras` — a layer nobody can see must not swallow a click.
      *
-     * It does **not** cover committed scene edits (subscribe to the scene for
-     * those) or previews a consumer's own tool publishes from React state
-     * (that tool re-renders on its own).
-     *
-     * Without a gesture source wired — a bare `<Canvas>` — this is a no-op
-     * subscription that never fires.
+     * This is `getIsVisible`'s coarser sibling: that one gates individual
+     * chrome elements *within* a layer, this one gates the layer.
      */
-    subscribeGestures(fn: () => void): () => void;
+    layerVisibility?: Record<string, boolean>;
     /**
-     * Monotonic counter bumped on exactly the events `subscribeGestures` fires
-     * on. Pair the two for `useSyncExternalStore`:
-     *
-     * ```ts
-     * const gestureVersion = useSyncExternalStore(
-     *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),
-     *   () => helpersRef.current?.getGestureVersion() ?? 0,
-     * );
-     * ```
+     * Draw order, by layer id, bottom first. Omit for the order the layers
+     * arrive in.
      *
-     * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with
-     * no gesture source reports, forever.
+     * **A listed order is the whole list:** any layer whose id is missing from
+     * it is not drawn. Reordering two layers means naming all of them.
      */
-    getGestureVersion(): number;
-    /** Returns the live ChromeState built once per render. Affordances and
-     *  custom layers that need overlay-aware selection state (selection ids,
-     *  bounds, multi-union AABB, modifier flags) read from this. */
-    getChromeState(): ChromeState;
-    /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that
-     *  want to participate in `hitboxes`/`bounds`/etc. visualization can
-     *  call into this from their `draw` callback. Returns `null` when
-     *  debug is off — no-op for production renders. */
-    getDebug(): DebugSink | null;
-    /** Chrome-caps visibility predicate, keyed by chrome id. Returns a
-     *  function that affordance/overlay layers can call per-element to
-     *  decide whether to draw / hit-test. When the parent didn't supply
-     *  a resolver, this returns the universal `() => true`. */
-    getIsVisible(): (id: string) => boolean;
-}
-
-/** Which of a node's two per-anchor color arrays an override applies to. */
-type VertexColorChannel = 'fill' | 'stroke';
-/** Function-form override: receives the consumer-supplied base color
- *  array and the current animation timestamp (ms, from the animator's
- *  clock). Returns a flat RGBA float array (values in 0..1, matching
- *  the renderer's `stroke.vertexColors` / `PathDrawCommand.vertexColors`
- *  color space) of the same length as `base`. */
-type ColorOverrideFn = (base: readonly number[], tMs: number) => number[];
-/** Either a static per-anchor RGBA float array (0..1) or a function-form
- *  override (see {@link ColorOverrideFn}). */
-type ColorOverride = readonly number[] | ColorOverrideFn;
-/** Per-node, per-channel store of color overrides consulted by `createPathLayer`
- *  before falling back to the consumer's `getVertexColors` / `getStrokeVertexColors`
- *  accessor. Attached to `useAnimator` as `animator.colorOverrides`. */
-declare class ColorOverrideRegistry {
-    private readonly map;
-    private _version;
-    set(id: string, channel: VertexColorChannel, override: ColorOverride): void;
-    clear(id: string, channel: VertexColorChannel): void;
-    clearAll(): void;
-    get(id: string, channel: VertexColorChannel): ColorOverride | undefined;
-    version(): number;
-}
-
-/** One keyframe. `easing` shapes the approach INTO this key from the previous
- *  one, so the first key's easing is never consulted. */
-interface Keyframe<T> {
-    /** Time within the track's timeline, in ms. */
-    t: number;
-    value: T;
-    easing?: EasingFn;
-}
-/** A track sampled as a pure function of the playhead. Scrubbing one is free
- *  and order-independent. */
-interface SampledTrack<T> {
-    kind: 'sampled';
-    label?: string;
-    /** Sorted ascending by `t`. `sampleTrack` assumes this and does not sort. */
-    keys: Keyframe<T>[];
-    /** Required when T is not `number`; defaults to numeric lerp otherwise. */
-    interpolate?: Interpolate<T>;
-    /** Built once per segment and cached. Takes precedence over `interpolate`. */
-    interpolator?: InterpolatorFactory<T>;
-    onTick: (value: T) => void;
-}
-/** A track of edge crossings. Fires only when the playhead advances forward
- *  under playback — never on `seek`. */
-interface EventTrack {
-    kind: 'event';
-    label?: string;
-    /** Sorted ascending by `t`. */
-    events: {
-        t: number;
-        fire: () => void;
-    }[];
-}
-/** A nested timeline, evaluated at `playhead - at`. Children are NOT registered
- *  with the animator separately; the parent evaluates them. */
-interface TimelineTrack {
-    kind: 'timeline';
-    label?: string;
-    at: number;
-    timeline: NestedTimeline;
-}
-type Track = SampledTrack<any> | EventTrack | TimelineTrack;
-/** What a child timeline may declare. The parent owns playback, so `loop`,
- *  `autoplay`, `onDone` and `cancelKey` have no meaning below the root. */
-interface NestedTimeline {
-    tracks: Track[];
-    /** Defaults to the largest end time across `tracks`. */
-    duration?: number;
-}
-interface TimelineOptions extends NestedTimeline {
-    /** `true` loops forever, `n` loops n additional times. Default false. */
-    loop?: boolean | number;
-    /** Default true. When false the timeline registers but holds at t=0 until resumed. */
-    autoplay?: boolean;
-    onDone?: () => void;
-    cancelKey?: string;
-}
-interface TimelineHandle extends AnimationHandle {
-    /** Move the playhead. Never fires event tracks, at any depth. */
-    seek(t: number): void;
-    /** Current playhead in ms. */
-    time(): number;
-    duration(): number;
-    tracks(): readonly Track[];
-    /** Run `fn`, then recompute duration, drop cached interpolators, and notify.
-     *  Every mutation must go through this — an edited keyframe otherwise keeps
-     *  interpolating toward its old value with no visible error. */
-    edit(fn: () => void): void;
-    /** Notified after each `edit`. Returns an unsubscribe. */
-    subscribe(cb: () => void): () => void;
-}
-
-/** An easing curve: maps normalized progress `t ∈ [0, 1]` to eased progress.
- *  Curves may leave the 0–1 range in the middle (back, elastic) but should
- *  pass through 0 at 0 and 1 at 1. */
-type EasingFn = (t: number) => number;
-/** Blends two `T` values at eased progress `t`. Called once per frame; see
- *  {@link InterpolatorFactory} when the blend has setup worth hoisting. */
-type Interpolate<T> = (from: T, to: T, t: number) => T;
-/** Factory interpolator: built ONCE at tween start with (from, to), the returned
- *  function is called with `t ∈ [0, 1]` each frame. Use for interpolators with
- *  expensive setup (color-space conversion, path-string parsing) — d3-interpolate's
- *  shape exactly. For cheap interpolations the per-tick `Interpolate<T>` form is
- *  fine; this is the escape hatch when setup-per-tick is wasteful. */
-type InterpolatorFactory<T> = (from: T, to: T) => (t: number) => T;
-/** A spring's physical parameters. Higher stiffness settles faster, higher
- *  damping overshoots less, higher mass makes both sluggish. */
-interface SpringPreset {
-    stiffness: number;
-    damping: number;
-    mass: number;
-}
-/** One of the tunings in `SPRING_PRESETS`. */
-type SpringPresetName = 'gentle' | 'wobbly' | 'stiff' | 'slow';
-/** A running animation. Cancel it, or bend its time — pausing and time-scaling
- *  act on this animation's own virtual clock, independent of the animator's. */
-interface AnimationHandle {
-    /** Monotonic id assigned by the animator. */
-    id: number;
-    /** Cancel this animation. Idempotent — no-op once already finished/canceled. */
-    cancel(): void;
-    /** Freeze this animation's virtual clock. Idempotent. */
-    pause(): void;
-    /** Resume this animation's virtual clock. Idempotent. */
-    resume(): void;
-    /** Multiply this animation's virtual-clock rate by `scale`. 1 = normal. */
-    setTimeScale(scale: number): void;
-    /** True iff this handle is currently paused. */
-    isPaused(): boolean;
-}
-/** A duration-based animation from `from` to `to` over `ms`, shaped by an
- *  easing curve. Reach for a spring instead when the motion should respond to
- *  where the value already is rather than restart from a fixed duration. */
-interface TweenOptions<T> {
-    from: T;
-    to: T;
-    ms: number;
-    easing?: EasingFn;
-    /** Required when T is not `number`. For T = number, defaults to linear numeric lerp.
-     *  Called per-tick with `(from, to, t)`. For interpolators with expensive setup,
-     *  prefer `interpolator` which is built once at tween start. */
-    interpolate?: Interpolate<T>;
-    /** Factory interpolator built once at tween start. Takes precedence over
-     *  `interpolate` when both are provided. Use this for d3-interpolate or any
-     *  `(from, to) => (t) => v` shape. */
-    interpolator?: InterpolatorFactory<T>;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    /** Any new animation passed the same cancelKey cancels the prior one in flight. */
-    cancelKey?: string;
-}
-/** A spring animation: runs until the value settles on `to` rather than for a
- *  set duration, so it absorbs an initial velocity naturally. Non-numeric `T`
- *  needs the four vector helpers. */
-interface SpringOptions<T> {
-    from: T;
-    to: T;
-    /** Initial velocity in T-units per second. Default: zero (T-shape-aware). */
-    velocity?: T;
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    interpolate?: Interpolate<T>;
-    /** Vector helpers — required for non-numeric T. */
-    add?: (a: T, b: T) => T;
-    subtract?: (a: T, b: T) => T;
-    scale?: (v: T, k: number) => T;
-    magnitude?: (v: T) => number;
-    /** Velocity magnitude below which the spring is considered settled. Default 0.01. */
-    restThreshold?: number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-}
-/** Spring and decay as one animation. With a `to`, a spring pulls toward it;
- *  with `to: null`, the value coasts on its velocity. Either can become the
- *  other mid-flight through the handle. */
-interface PhysicsOptions<T> {
-    from: T;
-    /** Target. `null` ⇒ no spring force (decay-mode). */
-    to?: T | null;
-    /** Initial velocity in T-units per second. */
-    velocity?: T;
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    restThreshold?: number;
-    /** Vector helpers — required for non-numeric T. */
-    add?: (a: T, b: T) => T;
-    subtract?: (a: T, b: T) => T;
-    scale?: (v: T, k: number) => T;
-    magnitude?: (v: T) => number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-}
-/** An `AnimationHandle` that can also be steered while it runs — the point of
- *  the physics primitive. */
-interface PhysicsHandle<T = unknown> extends AnimationHandle {
-    /** Retarget mid-flight. `null` ⇒ switch to decay-mode (no spring force). */
-    setTarget(to: T | null): void;
-    /** Replace the current velocity in T-units per second. */
-    setVelocity(v: T): void;
-}
-/** Momentum: coast from `from` at `velocity`, slowing by `friction` each
- *  second until below `threshold`. What a flick-to-pan leaves behind. */
-interface DecayOptions<T> {
-    from: T;
-    velocity: T;
-    /** Per-second velocity multiplier in (0, 1). Default 0.95. */
-    friction?: number;
-    /** Velocity magnitude below which decay stops. Default 0.5. */
-    threshold?: number;
-    add: (a: T, b: T) => T;
-    scale: (v: T, k: number) => T;
-    magnitude: (v: T) => number;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
-}
-/** Options for `useAnimator`. Everything here is an injection seam for tests;
- *  the defaults are the real clock, rAF, and `setTimeout`. */
-interface UseAnimatorOptions {
-    /** Optional clock injection for tests. Returns ms since some epoch. */
-    now?: () => number;
-    /** Optional rAF / cAF injection for tests. Defaults to window.requestAnimationFrame. */
-    requestFrame?: (cb: (t: number) => void) => number;
-    cancelFrame?: (handle: number) => void;
-    /** Optional `setTimeout` injection used by `stagger` for per-item delays.
-     *  Defaults to the global `setTimeout`. Tests inject a virtual scheduler. */
-    setTimer?: (cb: () => void, ms: number) => unknown;
-    /** Companion to `setTimer`. Defaults to global `clearTimeout`. */
-    clearTimer?: (handle: unknown) => void;
-}
-/**
- * Owns every running animation on a canvas and drives them from one rAF loop.
- * Beyond the primitives (`tween`, `spring`, `decay`, `physics`) it offers
- * composition — `loop`, `stagger` — and bulk control by handle, by cancel-key,
- * or over everything at once.
- *
- * An animator does not know about the scene: animations report values through
- * `onTick` and the caller decides what to do with them.
- */
-interface Animator {
-    tween<T>(opts: TweenOptions<T>): AnimationHandle;
-    spring<T>(opts: SpringOptions<T>): AnimationHandle;
-    decay<T>(opts: DecayOptions<T>): AnimationHandle;
-    /** Unified spring/decay primitive. With `to` set, behaves as a spring;
-     *  with `to: null`, behaves as a velocity-driven decay. Supports
-     *  mid-flight retargeting via the returned handle's `setTarget`. */
-    physics<T>(opts: PhysicsOptions<T>): PhysicsHandle<T>;
-    /** Cancel a specific animation by handle. Pose stays at current value (no jump). */
-    cancel(handle: AnimationHandle): void;
-    /** Cancel every animation currently active under `key`. */
-    cancelKey(key: string): void;
-    /** Cancel everything. Useful from a destructor or "reset scene" path. */
-    cancelAll(): void;
-    /** True iff at least one animation is active. With `key`, scoped to that cancelKey. */
-    isActive(key?: string): boolean;
-    /**
-     * True while the animator is currently executing an animation tick. Useful
-     * for adapter wrappers (e.g. `animateOnSetPose`) that need to detect
-     * "this `setPose` was called from inside another animation's onTick"
-     * (momentum decay, in-flight tween, spring) and avoid recursively
-     * scheduling a new wrap-animation that would fight the caller.
-     */
-    isTicking(): boolean;
-    /** Freeze every animation managed by this animator. */
-    pause(): void;
-    /** Resume every animation managed by this animator. */
-    resume(): void;
-    /** True iff the animator is currently globally paused. */
-    isPaused(): boolean;
-    /** Multiply every animation's virtual-clock rate by `scale`. 1 = normal. */
-    setTimeScale(scale: number): void;
-    /** Freeze every animation whose `cancelKey` matches. */
-    pauseKey(key: string): void;
-    /** Resume every animation whose `cancelKey` matches. */
-    resumeKey(key: string): void;
-    /** Set per-animation timeScale for every animation whose `cancelKey` matches. */
-    setTimeScaleByKey(key: string, scale: number): void;
-    /**
-     * Loop primitive: repeatedly invoke `factory` to produce a child animation.
-     * The factory must wire its returned handle's `onDone` to call `next` so
-     * the loop advances. Returns a handle whose pause/resume/setTimeScale/cancel
-     * delegate to the current in-flight child (and prevent future iterations
-     * on cancel).
-     *
-     * The loop is registered with the animator under a supervisor entry so
-     * `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
-     * `animator.isActive(opts.cancelKey)` all work for it.
-     */
-    loop(factory: LoopFactory, opts?: LoopOptions): AnimationHandle;
-    /** Sugar over `loop` for the common case of looping a tween between two
-     *  values with optional direction handling (`restart` | `reverse` |
-     *  `alternate`). Registered with the animator like `loop`. */
-    tweenLoop<T>(opts: TweenLoopOptions<T>): AnimationHandle;
-    /**
-     * Stagger primitive: schedule a per-item animation, offset by `delay` ms
-     * per index (or a custom function of the index). Two forms:
-     *   - Factory form: pass `factory` directly, returns a composite
-     *     `AnimationHandle`.
-     *   - Builder form: omit `factory`, get a `StaggerBuilder` for fluent
-     *     `.each` / `.tween` / `.springPose` calls.
-     *
-     * The composite handle's `cancel` cancels pending timers AND in-flight
-     * children. `pause` / `resume` / `setTimeScale` propagate to in-flight
-     * children; `pause`/`resume` also freeze and thaw pending per-item timers
-     * (the remaining time before each pending fire is preserved across the
-     * pause).
-     *
-     * The stagger is registered with the animator under a supervisor entry so
-     * `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
-     * `animator.isActive(opts.cancelKey)` all work for it.
-     */
-    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay): StaggerBuilder<TItem>;
-    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay, factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
-    /**
-     * Keyframe timeline. Registered like any other animation, so its playhead
-     * responds to `pause`, `setTimeScale` and `cancelKey`. Sampled tracks are a
-     * pure function of the playhead; event tracks fire only on forward playback.
-     */
-    timeline(opts: TimelineOptions): TimelineHandle;
-    /** Per-node, per-channel color override registry consulted by the renderer's
-     *  path layer before reading consumer accessors. Used by `tweenVertexColors`,
-     *  `springVertexColors`, `cycleVertexColors`, `staggerVertexColors`. Cleared
-     *  automatically on animator unmount. */
-    colorOverrides: ColorOverrideRegistry;
-    /**
-     * Subscribe to a callback fired once per RAF frame while any animation is
-     * active. Returns an unsubscribe function. Used by consumers (typically
-     * `<SceneCanvas>`) that need to repaint when an animation's side-effect
-     * is read from a non-scene channel (e.g. `colorOverrides` consulted from
-     * a custom `drawOne`) — scene mutations naturally trigger a repaint, but
-     * `colorOverrides` writes do not.
-     *
-     * The callback fires AFTER the per-frame tick of each registered
-     * animation, so by the time it runs `colorOverrides.get(...)` returns
-     * the latest values. If no animations are active, no tick fires.
-     */
-    onTick(cb: () => void): () => void;
-    /**
-     * Keep the animator's RAF loop running until the returned cancel
-     * function is called. Use for animations whose effect is read on every
-     * frame but which don't have a natural progress state (e.g.
-     * `cycleVertexColors`, which expresses its current value as a function
-     * of `performance.now()` rather than as a tween from `from` to `to`).
-     * Without a keep-alive entry the loop would idle and `onTick` would
-     * stop firing even though the override is still installed.
-     */
-    keepAlive(): () => void;
-}
-/** Options for `Animator.loop`. */
-interface LoopOptions {
-    /** Maximum number of iterations. Default Infinity. */
-    count?: number;
-    /** Invoked when the loop reaches `count` iterations naturally (not on cancel). */
-    onDone?: () => void;
-    /** Any new animation passed the same cancelKey cancels the prior one in flight.
-     *  Also enables `animator.cancelKey` / `animator.isActive(key)` for this loop. */
-    cancelKey?: string;
-}
-/** Options for the top-level `Animator.stagger` factory form (third overload). */
-interface StaggerOptions {
-    /** Cancel-key for the supervising registration. `animator.cancelKey(key)`
-     *  cancels the whole stagger; `animator.isActive(key)` returns true while
-     *  any timer or child is alive. */
-    cancelKey?: string;
-}
-/** Produces one iteration of a loop. Must arrange for `next` to be called when
- *  the animation it returns finishes, or the loop stalls after one pass. */
-type LoopFactory = (iteration: number, next: () => void) => AnimationHandle;
-/** Per-index delay schedule. Number ⇒ `index * delay` ms. Function ⇒ caller
- *  decides the absolute delay for each index (e.g. `i => i * i * 30`). */
-type StaggerDelay = number | ((index: number) => number);
-/** Produces the animation for one staggered item. */
-type StaggerFactory<TItem> = (item: TItem, index: number) => AnimationHandle;
-/** A `T` value or a function that derives one from the per-item context. Used
- *  by the fluent builder methods (`.tween`, `.springPose`) so each item can
- *  vary an option (e.g. `to: (_item, i) => (i + 1) * 10`). */
-type StaggerPerItem<T, TItem> = T | ((item: TItem, index: number) => T);
-/** Options for the stagger builder's `.tween`: a tween per item, where
- *  `from`, `to` and `ms` may each vary by item. */
-interface StaggerTweenOptions<T, TItem> {
-    from: StaggerPerItem<T, TItem>;
-    to: StaggerPerItem<T, TItem>;
-    ms: StaggerPerItem<number, TItem>;
-    easing?: EasingFn;
-    interpolate?: Interpolate<T>;
-    onTick: (value: T, item: TItem, index: number) => void;
-    onDone?: (item: TItem, index: number) => void;
-}
-/** Options for the stagger builder's `.springPose`: the spring tuning, and
- *  whether each item's settle is recorded as an undoable op. */
-interface StaggerSpringPoseOptions<TPose> {
-    preset?: SpringPresetName;
-    stiffness?: number;
-    damping?: number;
-    mass?: number;
-    geometry?: PoseProjection<TPose>;
-    recordOp?: boolean;
-    opLabel?: string;
-}
-/** Fluent form of `Animator.stagger`: pick what to run per item after the
- *  items and the delay schedule are already fixed. */
-interface StaggerBuilder<TItem> {
-    /** Run an arbitrary per-item factory. */
-    each(factory: StaggerFactory<TItem>): AnimationHandle;
-    /** Sugar: per-item `animator.tween` with per-item-varying options. */
-    tween<T>(opts: StaggerTweenOptions<T, TItem>): AnimationHandle;
-    /** Sugar: per-item `springPose` against an adapter. `poseFn` returns the
-     *  target pose for each item. Each item must either be a primitive
-     *  (string/number) or expose a string `id` field — otherwise pose ids
-     *  would collide on `"[object Object]"` and successive tweens would
-     *  cancel each other. Throws on items that satisfy neither. */
-    springPose<TPose>(adapter: SceneAdapter<{
-        id: string;
-    }, TPose>, poseFn: (item: TItem, index: number) => TPose, opts?: StaggerSpringPoseOptions<TPose>): AnimationHandle;
-}
-/** Options for `Animator.tweenLoop` — a tween's options plus how each
- *  iteration relates to the last. */
-interface TweenLoopOptions<T> {
-    from: T;
-    to: T;
-    ms: number;
-    easing?: EasingFn;
-    /** `restart` (default): from→to every iteration.
-     *  `reverse`: to→from every iteration.
-     *  `alternate`: even iterations from→to, odd iterations to→from. */
-    direction?: 'restart' | 'reverse' | 'alternate';
-    count?: number;
-    interpolate?: Interpolate<T>;
-    onTick: (value: T) => void;
-    onDone?: () => void;
-    cancelKey?: string;
+    layerOrder?: string[];
 }
 
 /** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /
@@ -4487,21 +4874,61 @@ interface UseRotateOptions<TPose> {
      *  Has no effect on single-id gestures. */
     pivot?: 'each' | 'union';
 }
-
+
+/** A rect on the surface, in CSS pixels from the canvas top-left. */
+interface ViewRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Props for `<CanvasView>`. @experimental */
+interface CanvasViewProps {
+    /** Identifies the view to the surface and to input routing. Must be unique
+     *  among the views on one canvas. */
+    id: string;
+    /** Where this view paints, recomputed every frame so the rect can track the
+     *  outer camera. A plain rect is accepted for a fixed panel. */
+    bounds: ViewRect | ((outer: View, dims: Dims) => ViewRect);
+    /** Camera. Supply this to control it; otherwise the view keeps its own,
+     *  seeded from `defaultView`. `onViewChange` fires either way. */
+    view?: View;
+    defaultView?: View;
+    onViewChange?: (v: View) => void;
+    /** Pan limits, applied to every camera change the same way `<Canvas>`
+     *  applies its own. */
+    viewBounds?: Bounds;
+    /** Which of the surface's layers this view paints. Defaults to all of them —
+     *  the same content through a second camera. */
+    layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];
+    /** Opaque ground painted before the source layers, so the surface does not
+     *  show through where the inner camera sees nothing. */
+    background?: string;
+    /** Paint and hit order. Defaults to `Infinity` — after every view the
+     *  surface declared as a prop. */
+    order?: number;
+    /** Label for debug overlays. Defaults to the id. */
+    label?: string;
+    /** A selection of this view's own, which actions dispatched inside it read
+     *  and write instead of the surface's. Omit both this and
+     *  `selectionOptions` and the view shares the surface's selection — the
+     *  default, so undo restores one selection rather than N. */
+    selection?: SelectionApi;
+    /** Opts this view into owning a selection, configured thus. Ignored when
+     *  `selection` is supplied. */
+    selectionOptions?: UseSelectionOptions;
+}
 /**
- * Built-in shape tool ids handled by `useBuiltinShapeTools`. Each maps to a
- * kit tool hook + a default `create` that produces a leaf node compatible
- * with `PATH_PAINTER`.
+ * @experimental
  *
- * Runtime mirror in `KIT_SHAPE_KINDS` below — keep the two in sync. The
- * `src/index.barrel.test.ts` parity gate enforces that every member of this
- * union is present in the exported tuple.
+ * One view on a shared canvas. Owns a camera, contributes the viewport node
+ * that paints it, and registers the dispatch record that sends gestures inside
+ * its rect to that camera rather than to the canvas's.
+ *
+ * Renders nothing itself — it is a declaration, and the surface does the
+ * drawing. Outside a surface that mounts a view registry it is inert.
  */
-type BuiltinShapeToolId = 'rect' | 'ellipse' | 'line' | 'polygon' | 'star' | 'pen' | 'pencil' | 'lasso' | 'text';
-/** Runtime, iterable list of the shape-tool ids in `BuiltinShapeToolId`.
- *  Surfaced so consumers (e.g. the Bundle Inspector) can enumerate the
- *  builtin shape kinds without re-encoding the union. */
-declare const KIT_SHAPE_KINDS: readonly ["rect", "ellipse", "line", "polygon", "star", "pen", "pencil", "lasso", "text"];
+declare function CanvasView(props: CanvasViewProps): null;
 
 /** Per-tool option overrides for the built-in shape/lasso tools.
  *  Each entry is a narrow subset of the underlying hook's options surface
@@ -4640,182 +5067,6 @@ declare function createNodeRouting(): NodeRouting;
  *  matches `poseRotationOf` (the shared rotation convention). */
 declare function rotateAroundAABBCenter(x: number, y: number, width: number, height: number, rotation: number): Float32Array;
 
-/**
- * NodeShape — the **shape trait's** registry. Each trait of a node
- * (shape, routing, label, icon, affordances, …) is its own registry;
- * this one holds the per-kind `paint` + `silhouette` (and future
- * fields) used by `defaultDrawOne`, clipping, non-rect hit-testing,
- * lasso/area-select, and SVG export.
- *
- * Teaching the kit about a new kind of shape goes through this registry
- * rather than by overriding `drawOne`. Overrides are still possible but
- * shouldn't be the default seam: most consumers want the same dispatch
- * logic, just extended with their own shape kinds (images, custom paths,
- * SVG fragments, etc.).
- *
- * Built-in entries (`kit:text`, `kit:path`, `kit:rect-fallback`) are
- * registered at module load. Consumer entries added via
- * `registerNodeShape` join the chain; the first entry whose
- * `matches` predicate returns true paints the node.
- *
- * Two priority tiers:
- *   - `'high'` — checked before all `'normal'` entries. Use this to
- *     override a kit built-in for a specific data shape (e.g. a custom
- *     text renderer that wins over `kit:text`).
- *   - `'normal'` (default) — appended after the built-ins.
- *
- * Within a tier, entries run in registration order. Each
- * `registerNodeShape` call returns a disposer that removes the
- * entry — useful for tests, for plugin lifecycles, and for swapping
- * implementations at runtime.
- *
- * See `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`
- * for the trait taxonomy.
- */
-
-/** Optional per-call paint context, threaded through `defaultDrawOne`'s third
- *  argument. Lets a rendering entry point override ambient environment reads
- *  — the headless `renderSceneToPixels` path supplies its own bitmap resolver
- *  here so consumers reuse their own decode caches. Custom painters may
- *  ignore it entirely. */
-interface NodePaintCtx {
-    /** Override bitmap resolution for image nodes. When set it is authoritative:
-     *  the global `imageCache` is not consulted, and an `undefined` result
-     *  paints the deterministic grey placeholder outline (never the ambient
-     *  load-status error variant). */
-    resolveImage?: (node: Node$1<unknown, string, unknown>) => ImageBitmap | undefined;
-}
-/** A painter for one kind of node: which nodes it claims, and the draw
- *  commands it emits for them. Registering one is how a consumer teaches the
- *  default renderer to draw its own node kinds. */
-interface NodeShapeEntry<TData = unknown, TPose = unknown> {
-    /** Stable identifier — used for unregistration and debugging. Pick
-     *  something descriptive: `'kit:text'`, `'app:image'`, etc. */
-    id: string;
-    /** Returns true when this painter renders the node. The first matching
-     *  painter (`'high'` tier first, then `'normal'`) wins. */
-    matches(node: Node$1<TData, string, TPose>): boolean;
-    /** Emits the draw commands for the node's primary visual. `ctx` is an
-     *  optional per-call paint context (see `NodePaintCtx`); painters that
-     *  don't need it can keep a two-argument signature.
-     *
-     *  **The returned array belongs to the painter.** Callers must treat it as
-     *  immutable and copy before appending — a painter is free to memoize its
-     *  command list (`kit:shape` and `kit:path` do), and an in-place `push`
-     *  would grow that list on every frame. `defaultDrawOne` copies before
-     *  adding its label overlay for exactly this reason. */
-    paint(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];
-    /** Optional: derive the node's silhouette path from its pose.
-     *  Used by clipping (when the container has no explicit
-     *  `clipFromPose`), by non-rect hit-testing, by lasso/area-select,
-     *  and by SVG export. Painters whose visual has no meaningful closed
-     *  silhouette (e.g. text) leave this undefined. */
-    silhouette?(node: Node$1<TData, string, TPose>, pose: TPose): Path | null;
-    /** Optional: how the silhouette is inked — whether the interior is filled,
-     *  and how wide the outline is. Read by picking, so that an unfilled shape
-     *  is grabbable by its outline rather than by its empty middle.
-     *
-     *  This is declared separately from `paint` rather than read back off the
-     *  emitted draw commands because picking runs on every pointer move, and
-     *  `paint` is allowed to be expensive (`kit:text` lays out glyphs). Keep it
-     *  to cheap field reads.
-     *
-     *  Painters that leave it undefined are treated as `{ filled: true,
-     *  strokeWidth: 0 }` — the pre-`ink` behavior, where the whole silhouette
-     *  interior is grabbable and the outline adds nothing. */
-    ink?(node: Node$1<TData, string, TPose>, pose: TPose): NodeInk | null;
-}
-/** How a painter inks its silhouette. See {@link NodeShapeEntry.ink}. */
-interface NodeInk {
-    /** True when the silhouette's interior is painted, and so grabbable. */
-    filled: boolean;
-    /** Stroke width in world units. `0` for no stroke. */
-    strokeWidth: number;
-}
-/** Options for `registerNodeShape`. */
-interface RegisterNodeShapeOptions {
-    /** `'high'` puts the painter ahead of all normally-registered ones (so
-     *  it can win over a kit built-in). `'normal'` appends at the end. */
-    priority?: 'high' | 'normal';
-}
-/** Register a shape painter. Returns a disposer that removes it. */
-declare function registerNodeShape<TData, TPose>(painter: NodeShapeEntry<TData, TPose>, opts?: RegisterNodeShapeOptions): () => void;
-/** Find the painter that will render `node` — first match in priority
- *  order. Returns undefined if no painter (including the built-in
- *  fallback) accepts the node. */
-declare function findNodeShape<TData, TPose>(node: Node$1<TData, string, TPose>): NodeShapeEntry<TData, TPose> | undefined;
-/** Find the painter for `node` and ask it for the node's silhouette path,
- *  in **world** coords. Returns null if no painter matches, or the matching
- *  painter has no `silhouette` method, or the method returns null. Used by
- *  clipping, generic non-rect hit-testing, lasso, and SVG export — anywhere
- *  the kit needs the "closed boundary" of whatever this kind of node draws as.
- *
- *  Painters return their silhouette in the pose's local (unrotated) frame;
- *  this bakes `pose.rotation` on top via the shared rotation convention, so
- *  clips/area-select of a rotated node use the rotated boundary the renderer
- *  draws. (`paint()` is unaffected — it applies rotation via the render wrap,
- *  not the silhouette, so there is no double-rotation.) */
-declare function findShapeSilhouette<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose): Path | null;
-/** Find the painter for `node` and ask how it inks its silhouette. Returns
- *  the painter's declared {@link NodeInk}, or `null` when no painter matches
- *  or it declares none — callers substitute {@link DEFAULT_INK}. */
-declare function findShapeInk<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose): NodeInk | null;
-/** Options for {@link shapeCoversPoint}. */
-interface ShapeCoversPointOptions {
-    /** Extra grab distance around the outline, in **world** units. Callers
-     *  derive it from a screen-pixel slop and the view scale, the same way
-     *  affordance hit radii work.
-     *
-     *  Without slop a hairline is a mathematically zero-width target: the
-     *  stroke of a 1px outline is half a world unit wide at scale 1, which no
-     *  one can hit. Defaults to `0` so a caller that hasn't thought about the
-     *  view still gets exact geometry rather than a wrong guess. */
-    tolerance?: number;
-}
-/**
- * Does the shape `node` actually paints cover the world point?
- *
- * The pose rect says a node covers its whole bounding box. That is wrong for
- * everything that is not a rectangle: the concave notch of a star, the corner
- * outside an ellipse, the blank right half of a text box. This asks the
- * painter's silhouette instead, which is the same boundary used for clipping
- * and SVG export, so "what you can click" and "what is drawn" answer together.
- *
- * "What is drawn" includes the *ink*, not just the boundary. A shape whose
- * interior isn't filled — an outlined rect, a pencil stroke, a bare line — is
- * grabbable along its outline and not through its empty middle, which is the
- * opposite of what a fill test alone answers. The outline's grab width is the
- * stroke's half-width plus `tolerance`.
- *
- * A painter with no `silhouette`, or one that returns `null` for this node
- * (`kit:text` does, for a node with no non-blank lines), reports `true` —
- * "no opinion", leaving the caller's own AABB test as the answer. Callers
- * should keep that AABB test as a cheap pre-filter; this is the refinement,
- * not a replacement.
- *
- * Rotation is already baked by `findShapeSilhouette`, so the point is in
- * plain world coordinates.
- */
-declare function shapeCoversPoint<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose, x: number, y: number, opts?: ShapeCoversPointOptions): boolean;
-/** Snapshot of the current painters in evaluation order — `'high'` tier
- *  first, then `'normal'`. Useful for debugging which painter handles a
- *  given node. */
-declare function getNodeShapes(): readonly NodeShapeEntry[];
-/**
- * What a node's `data.fill` means to the built-in painters.
- *
- * A string is a color, `'none'` skips the fill, and an object is a
- * {@link FillStyle} used as-is — which is how a gradient or a pattern reaches
- * the renderer without a consumer registering a painter of its own. The
- * renderer has taken every `FillStyle` variant since the paint model landed;
- * only these two painters were narrower than it.
- *
- * `undefined` falls back to `data.color`, then to a default fill — but only
- * when there is no stroke, since a stroke-only path (pencil) should not
- * acquire one.
- */
-type NodeFill = string | FillStyle;
-
 /**
  * `defaultDrawOne` — the kit's default per-node draw function.
  *
@@ -4845,7 +5096,7 @@ type NodeFill = string | FillStyle;
 /** Paint one node the way the kit does by default: dispatch to the first
  *  registered node-shape painter that matches, then draw its `data.label` on
  *  top when it has one. Consumers replace or wrap this via `drawOne`. */
-declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$1<TData, TLayer, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];
+declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$1<TData, TLayer, TPose>, pose: TPose, _view?: View, ctx?: NodePaintCtx): DrawCommand[];
 
 /** Default size in CSS pixels for selection corner-handles AND their
  *  hit-test radius, at `targetScale = 1`. Used by the SceneCanvas defaults;
@@ -4855,10 +5106,13 @@ declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$
  *  Deliberately unscaled: consumers reading this constant keep getting the
  *  number they always got. Kit-internal use sites multiply by
  *  `DeviceProfile.targetScale`. */
-declare const DEFAULT_HANDLE_SIZE = 8;
+declare const DEFAULT_HANDLE_SIZE: 8;
+/** Built-in tool ids that aren't shape tools — the ones with no entry in
+ *  the `core/shapeKinds` table. */
+declare const NON_SHAPE_BUILTIN_TOOLS: readonly ["select", "rotate", "hand"];
 /** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop
  *  is supplied. Pass a subset via `defaultTools` to slim the registered set. */
-type BuiltinToolId = 'select' | 'rotate' | 'hand' | BuiltinShapeToolId;
+type BuiltinToolId = (typeof NON_SHAPE_BUILTIN_TOOLS)[number] | BuiltinShapeToolId;
 /** Named preset tool collections for the `toolBundle` prop. Maps to a
  *  `BuiltinToolId[]` consumed by SceneCanvas's internal `useTools`. */
 type ToolBundle = 'minimal' | 'standard' | 'exhaustive';
@@ -4877,7 +5131,7 @@ interface SceneCanvasHit {
 /** Props for `<SceneCanvas>`. Most are optional: a scene is the only thing it
  *  truly needs, and everything else — tools, layers, selection handling,
  *  layouts, animation — layers onto sensible defaults. */
-type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<Node$1<TData, TLayer, TPose>, TPose>, 'adapter' | 'moveOptions' | 'resizeOptions' | 'rotateOptions' | 'snap' | 'pickEvery' | 'boundsOf' | 'handleHitRadius' | 'selection' | 'selectionOptions' | 'tools' | 'geometry' | 'layers' | 'onBackgroundClick' | 'getIsVisible'> & {
+type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<Node$1<TData, TLayer, TPose>, TPose>, 'adapter' | 'moveOptions' | 'resizeOptions' | 'rotateOptions' | 'snap' | 'pickEvery' | 'boundsOf' | 'handleHitRadius' | 'selection' | 'selectionOptions' | 'tools' | 'geometry' | 'layers' | 'onBackgroundClick' | 'getIsVisible' | 'contentVersion'> & {
     /** A `Scene` (typically from `useScene`) — or a `SerializedScene`
      *  JSON object, which SceneCanvas bakes into a Scene internally on
      *  first render. The serialized form is read once; subsequent
@@ -5133,17 +5387,19 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
     ambient?: AnyTool[];
     /** Viewport feature wiring.
      *
-     *  - `inertia`, `pinchZoom`, `animatedZoom` are opt-in: pass `true`
-     *    for defaults or an object to tune. Omitted means off.
-     *  - `pan` (wheel pan) and `zoom` (Cmd+wheel + Cmd+=/-/0) are opt-OUT:
-     *    on by default; pass `false` to disable. They are wired by registering
-     *    the kit's `viewport.pan` / `viewport.zoom` action descriptors with
-     *    the actions registry — disabling via the `actions` prop
-     *    (`actions: { 'viewport.wheelPan': null }`) also works and runs after this.
+     *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or
+     *    an object to tune. Omitted means off.
+     *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0) and `pinchZoom`
+     *    (two-finger pinch) are opt-OUT: on by default; pass `false` to
+     *    disable. All three are wired by registering the kit's `viewport.*`
+     *    action descriptors with the actions registry — disabling via the
+     *    `actions` prop (`actions: { 'viewport.wheelPan': null }`) also works
+     *    and runs after this.
      *
-     *  When omitted entirely, no hand/pinch tools are registered but the
-     *  default wheel pan + Cmd+wheel/key zoom remain wired (canvas-first
-     *  default). Pass `{ pan: false, zoom: false }` to opt out entirely. */
+     *  When omitted entirely, no hand tool is registered but the default wheel
+     *  pan, Cmd+wheel/key zoom and pinch zoom remain wired (canvas-first
+     *  default). Pass `{ pan: false, zoom: false, pinchZoom: false }` to opt
+     *  out entirely. */
     viewport?: {
         inertia?: boolean | {
             friction?: number;
@@ -5151,15 +5407,14 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
             boundary?: 'stop' | 'bounce' | 'spring';
             bounds?: PanBounds;
         };
-        pinchZoom?: boolean | {
-            min?: number;
-            max?: number;
-        };
-        animatedZoom?: boolean | {
-            duration?: number;
-            resetDuration?: number;
-            easing?: (t: number) => number;
-        };
+        /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8
+         *  clamp; `false` disables. An object sets the scale clamp. */
+        pinchZoom?: boolean | PinchZoomOptions;
+        /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults
+         *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes
+         *  duration, easing, interpolator and the reset-branch duration. Wheel
+         *  and pinch are unaffected — their input already samples every frame. */
+        animatedZoom?: boolean | ViewportZoomAnimateOptions;
         pan?: boolean;
         /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the
          *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}
@@ -5168,10 +5423,11 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
         zoom?: boolean | ViewportZoomOptions;
         /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).
          *  When supplied, replaces the default reset-to-identity behavior —
-         *  consumers typically refit the document page into the workspace
-         *  via `fitViewToBounds`. The callback owns its own bounds + host
-         *  dims and dispatches the resulting view via `onViewChange`. */
-        recenter?: () => void;
+         *  consumers typically refit the document page into the workspace via
+         *  `fitViewToBounds`. Return the target `View` to let the kit animate
+         *  there when `animatedZoom` is on; return nothing to dispatch it
+         *  yourself, which is what a controlled canvas does. */
+        recenter?: () => View | void;
     };
     /**
      * @experimental
@@ -5231,6 +5487,17 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * subscriber list stays quiet).
      */
     animator?: Animator;
+    /**
+     * Extra views on this canvas: each is a camera over a rect of the same
+     * surface, drawn through one GL context, with input routed to it. The flat
+     * `view` / `onViewChange` props above stay the canvas's own camera — view
+     * zero — and are unaffected by anything declared here.
+     *
+     * Order is paint and hit order, low to high. Each entry is a
+     * `<CanvasView>`; mounting one as a child is the same declaration, and
+     * children land after every entry here.
+     */
+    views?: readonly CanvasViewProps[];
     /**
      * Children rendered alongside the canvas. Useful for siblings that need
      * the same `<ActionsProvider>` scope (e.g. shortcuts overlays, probes).
@@ -5572,17 +5839,6 @@ declare const inferredNodeProperties: readonly NodePropertiesEntry[];
  * in sync by hand where it matters (DPR handling, viewToMat3 wrap).
  */
 
-/**
- * Per-node draw function. Mirrors the scene-slot `drawOne` signature on
- * `<SceneCanvas>` (`SceneSlotConfig.drawOne`) so consumers can reuse the
- * same callback (or a simplified variant) between a main canvas and a
- * detached scene-view canvas.
- *
- * The function is called once per node in `scene.renderOrder()`. Returned
- * commands are in world coords; the caller's `view` is applied at the
- * group level (see `renderSceneToCanvas`'s implementation).
- */
-type SceneViewDrawOne<TData, TLayer extends string, TPose> = (node: Node$1<TData, TLayer, TPose>, pose: TPose, view: View) => DrawCommand[];
 /** What to draw into an existing canvas: the scene, the view, and the same
  *  painting hooks `<SceneCanvas>` takes. */
 interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
@@ -5706,6 +5962,14 @@ declare const SceneViewCanvas: typeof SceneViewCanvasInner;
  *  this in tests, in headless rendering, or wherever a scene must outlive a
  *  component. Throws if no system layers are declared. */
 declare function createScene<TData, TLayer extends string, TPose = RectPose>(options: UseSceneOptions<TData, TLayer, TPose>): Scene<TData, TLayer, TPose>;
+/** The scene's selection in the shape `createHistory` wants, for a consumer
+ *  building a second History over the same scene (a modality machine, a
+ *  journal owner) that should restore selection the way the scene's own
+ *  history does. */
+declare function sceneSelectionStore(scene: {
+    getSelection(): readonly NodeId[];
+    setSelection(ids: readonly NodeId[]): void;
+}): HistorySelection;
 /** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.
  *  Function fields (e.g., `clipFromPose`) are resolved by string key via the
  *  registry passed in `options`. Throws on unknown version, unknown registry
@@ -5732,12 +5996,16 @@ interface UseSceneTrivialOptions<TItem extends {
     items: readonly TItem[];
     historyLimit?: number;
     generateId?: () => NodeId;
+    /** Re-render the host on every scene mutation. Default `true`. See
+     *  {@link UseSceneOptions.subscribe}. */
+    subscribe?: boolean;
 }
 declare const DEFAULT_LAYER: "default";
 type DefaultLayer = typeof DEFAULT_LAYER;
 /** React hook returning a kit-owned `Scene`. The Scene is constructed once
  *  per host component and tracked via `useSyncExternalStore`, so React re-
- *  renders on every Scene mutation (including undo/redo).
+ *  renders on every Scene mutation (including undo/redo) unless
+ *  `subscribe: false` opts out.
  *
  *  Two call shapes:
  *  - **Trivial**: `useScene({ items })` — one auto-registered system layer
@@ -5855,7 +6123,12 @@ interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
      *  can reuse it (typically simplified — just colored AABBs). */
     drawOne: SceneViewDrawOne<TData, TLayer, TPose>;
     /** Fit policy. Defaults to `"scene"` (AABB union of leaf poses). See
-     *  `MinimapFit` for the full shape. */
+     *  `MinimapFit` for the full shape.
+     *
+     *  Framing is derived from **document** poses, not `scene.overrides` — a
+     *  node moved by an override paints where the override puts it, outside the
+     *  frame if it goes there, rather than making the whole minimap rescale on
+     *  every frame of a drag or a settle. */
     fit?: MinimapFit<TData, TLayer, TPose>;
     /** Pose → AABB. Defaults to identity (`pose as Bounds`), matching
      *  `sceneAdapter` / `useSelectTool`. */
@@ -5914,9 +6187,10 @@ interface RenderSceneToPixelsArgs<TData, TLayer extends string, TPose> {
         y: number;
     };
     /** Per-node draw callback. Default: `defaultDrawOne` with `resolveImage`
-     *  threaded as its `NodePaintCtx`. Custom `drawOne` callers that still
-     *  want resolver injection should call `defaultDrawOne(node, pose, ctx)`
-     *  themselves. */
+     *  merged into the `NodePaintCtx` the scene walk supplies. Custom `drawOne`
+     *  callers that still want resolver injection should call
+     *  `defaultDrawOne(node, pose, view, { ...ctx, resolveImage })` themselves —
+     *  dropping the walk's `ctx` drops derived geometry with it. */
     drawOne?: SceneViewDrawOne<TData, TLayer, TPose>;
     /** Bitmap resolver for image nodes — lets consumers reuse their own decode
      *  caches. `undefined` results paint the deterministic grey placeholder
@@ -6397,8 +6671,6 @@ declare const PATH_ANCHOR_CHROME_ID = "path-edit.anchors";
  */
 declare function createPathAnchorAffordances(getAnchorState: () => AnchorState | null, opts?: PathAnchorAffordanceOptions): Affordance[];
 
-/** Pluggable text-painting strategy. The default fills white at `(x, y)`; markdown renderers replace this. */
-type TextRenderer = (ctx: CanvasRenderingContext2D, text: string, x: number, y: number) => void;
 /** Visual options for `renderLabel`. */
 interface LabelOptions {
     align?: 'center' | 'left';
@@ -6420,112 +6692,6 @@ declare function renderLabel(ctx: CanvasRenderingContext2D, text: string, x: num
 /** Default `TextRenderer` used by `renderLabel`: white fill, no styling. */
 declare const defaultLabelTextRenderer: TextRenderer;
 
-/** Width-measurement strategy for `layoutMarkdown`; canvas-backed default supplied by `createMarkdownRenderer`. */
-type MeasureFn = (text: string, fontSize: number, bold: boolean, italic: boolean) => number;
-/** A `StyledRun` with its computed x-offset relative to the start of its line. */
-interface PositionedRun extends StyledRun {
-    x: number;
-}
-/** A single laid-out line of text: its positioned runs, total width, and computed line height. */
-interface LayoutLine {
-    runs: PositionedRun[];
-    width: number;
-    height: number;
-}
-/** Output of `layoutMarkdown`: per-line breakdown plus overall block dimensions. */
-interface LayoutResult {
-    lines: LayoutLine[];
-    width: number;
-    height: number;
-}
-/** Word-wrap parsed runs into lines bounded by `maxWidth`; pass `Infinity` for single-line layout. */
-declare function layoutMarkdown(runs: StyledRun[], maxWidth: number, fontSize: number, measure: MeasureFn, lineHeightFactor?: number): LayoutResult;
-
-/** Font styling options threaded through `createMarkdownRenderer`. */
-interface MarkdownFontOptions {
-    /** Font-family spec (e.g. `'"Iowan Old Style", Georgia, serif'`). Defaults to `sans-serif`. */
-    family?: string;
-    /** Numeric weight applied to non-bold runs. Bold runs always use `bold`. Default `normal`. */
-    weight?: string | number;
-    /** Override fill color. When set, used for all runs (italic and bold). */
-    color?: string;
-    /** Multiplier applied to font size for line height. Default 1.3. */
-    lineHeight?: number;
-}
-/** Build a fill+stroke `TextRenderer` pair for a markdown string at the given size; pre-computes layout once. */
-declare function createMarkdownRenderer(ctx: CanvasRenderingContext2D, text: string, fontSize: number, maxWidth?: number, fontOpts?: MarkdownFontOptions): {
-    renderer: TextRenderer;
-    strokeRenderer: TextRenderer;
-    width: number;
-    height: number;
-};
-
-/**
- * Wrap-aware text measurement. Greedy word-wrap against `maxWidth` using
- * `ctx.measureText`. Lines explicitly broken by `\n` are preserved; long
- * single words that exceed `maxWidth` are emitted on their own line without
- * mid-word breaking (caller can decide to clip).
- *
- * Returns the laid-out lines, the total block height in world units
- * (`lines.length * fontSize * lineHeight`), and per-line `lineStarts` —
- * the offset of each line's first character in the original `text`. The
- * starts are used by `caretIndexAt` to map a clicked (x, y) back to a
- * character offset in the source string. Trailing whitespace consumed by
- * the wrap is not included in `lines[i]` but is implicit in the gap
- * between `lineStarts[i] + lines[i].length` and `lineStarts[i + 1]`.
- *
- * The caller owns the `ctx.font` setup — pass a context whose `font`
- * already matches `style` (use `fontString(style)`).
- */
-
-/**
- * Advance width of `text` in world units, tracking included.
- *
- * `letter-spacing` is not part of the CSS `font` shorthand, so a context
- * whose `font` was set from `fontString(style)` measures glyphs only. The
- * GL path (`layoutRuns`) adds `letterSpacing` after **every** code point
- * including the last, matching CSS, so this does too — and every 2D-side
- * width has to go through here or the two paths disagree about where a line
- * breaks.
- */
-declare function measuredWidth(ctx: CanvasRenderingContext2D, text: string, style: ResolvedTextStyle): number;
-/** Result of `measureText`: wrapped lines, per-line source offsets, and total block height. */
-interface MeasuredText {
-    lines: string[];
-    lineStarts: number[];
-    height: number;
-}
-/** Greedy word-wrap text measurement against `maxWidth`; preserves explicit `\n` breaks. */
-declare function measureText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number, style: ResolvedTextStyle): MeasuredText;
-
-/** Options for `measureTextBounds`. */
-interface MeasureTextBoundsOpts {
-    /** Wrap width; words exceeding it start a new line. Default `Infinity` (no wrap). */
-    maxWidth?: number;
-    /** Overrides `style`'s `lineHeight` multiplier for this measurement. */
-    lineHeight?: number;
-}
-/**
- * Measure how the GL/MSDF renderer will lay out a single plain-text string,
- * using the registered font atlas metrics. Mirrors {@link textCommand} exactly
- * (`resolveTextStyle` → `resolveRuns` → `layoutRuns`), so the returned bounds
- * match what actually gets drawn — use it to size backgrounds/pills, place
- * labels, or test overlap without guessing widths.
- *
- * Pass `opts.maxWidth` to measure word-wrapped height (e.g. for a fixed-width
- * text box); omitting it measures the unwrapped single-line width. `opts.lineHeight`
- * overrides the style's multiplier without changing `style` itself.
- *
- * Returns `{ width, height }` in the same units as `style.fontSize`. The font
- * must already be registered via `registerFont`; an unregistered family falls
- * back to the atlas fallback glyph (and warns), so register fonts at app boot
- * before measuring.
- */
-declare function measureTextBounds(text: string, style?: TextStyle, opts?: MeasureTextBoundsOpts): {
-    width: number;
-    height: number;
-};
-
 /**
  * Text RenderLayer. Emits one TextDrawCommand per text node carrying the
  * node's resolved runs and bounding rect. Word wrap and multi-line layout
@@ -6538,135 +6704,70 @@ declare function measureTextBounds(text: string, style?: TextStyle, opts?: Measu
  * `TextDrawCommand`'s contract).
  */
 
-/** Pose for a text node: bounding rect plus the text and optional style. */
-interface TextPose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text: string;
-    /** Rich-text runs. When present, `runsToPlainText(runs)` must equal `text`. */
-    runs?: StyledRun[];
-    style?: TextStyle;
-    /** Box vertical alignment within `[y, y+height]`. Default 'top'. */
-    verticalAlign?: TextVerticalAlign;
-}
 /** Options for `createTextLayer`. */
 interface CreateTextLayerOpts<T> {
     id?: string;
     label?: string;
-    getTexts: () => readonly T[];
-    getPose: (node: T) => TextPose;
-    /** Optional per-node hide hook (e.g., suppress while editing). */
-    isHidden?: (node: T) => boolean;
-    /** When `true`, each text command is wrapped in a clipped group so any
-     *  overflow beyond the pose's `(width × height)` is hidden. Default
-     *  `false` (legacy: text can spill outside the declared bounds). Opt-in
-     *  so existing consumers who rely on overflow keep working. */
-    clipToBounds?: boolean;
-}
-/** Build a `RenderLayer` that emits one `TextDrawCommand` per text node. */
-declare function createTextLayer<T>(opts: CreateTextLayerOpts<T>): RenderLayer<unknown>;
-
-/**
- * Hit-testing for text nodes.
- *
- * `pointInTextPose` does a coarse pose-rect test — suitable for click-to-edit
- * where the pose rect is the authoritative bounding box (selection outline,
- * drag target).
- *
- * `caretIndexAt` does the finer test: given a world-space (x, y) inside the
- * pose, returns the corresponding character offset in `pose.text` so the
- * consumer can place the caret on click. Re-runs the wrap to map the click
- * back through `lineStarts`; respects `style.align` for line anchoring.
- */
-
-/** Options for `pointInTextPose`. */
-interface PointInTextPoseOpts {
-    /** Extra padding (world units) added to the rect on all sides. Default 0. */
-    padding?: number;
-}
-/** Coarse pose-rect hit-test for a text node — suitable for click-to-edit dispatch. */
-declare function pointInTextPose(x: number, y: number, pose: TextPose, opts?: PointInTextPoseOpts): boolean;
-/**
- * Map a world-space point inside `pose` to a character offset into
- * `pose.text` (0..text.length). Clicks above the first line clamp to 0;
- * clicks below the last line clamp to `text.length`. Within a line, the
- * caret lands between two glyphs at whichever side of the glyph midpoint
- * `x` falls on — the standard "snap caret to nearest character boundary"
- * rule.
- *
- * The `ctx` is used only for `measureText`; its `font` is set internally
- * to match the resolved text style. Pass any 2D context (the same one used
- * to render is fine).
- */
-declare function caretIndexAt(ctx: CanvasRenderingContext2D, x: number, y: number, pose: TextPose): number;
-
-/**
- * Polygon-vs-axis-aligned-rect tests. Pure functions; no React/kit deps.
- *
- * `polygon` is a closed polyline given as an ordered vertex array; the
- * closing edge from `polygon[N-1]` to `polygon[0]` is implicit. Even-odd
- * fill rule (matches `pointInPath`).
- */
-/** A 2D point or vector. */
-interface Vec2 {
-    x: number;
-    y: number;
-}
-/** An axis-aligned rectangle. */
-interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+    getTexts: () => readonly T[];
+    getPose: (node: T) => TextPose;
+    /** Optional per-node hide hook (e.g., suppress while editing). */
+    isHidden?: (node: T) => boolean;
+    /** When `true`, each text command is wrapped in a clipped group so any
+     *  overflow beyond the pose's `(width × height)` is hidden. Default
+     *  `false` (legacy: text can spill outside the declared bounds). Opt-in
+     *  so existing consumers who rely on overflow keep working. */
+    clipToBounds?: boolean;
 }
+/** Build a `RenderLayer` that emits one `TextDrawCommand` per text node. */
+declare function createTextLayer<T>(opts: CreateTextLayerOpts<T>): RenderLayer<unknown>;
 
 /**
- * Where a text node's lines actually sit inside its pose box.
- *
- * A text pose is a *wrap box*, not a bounding box: `"Away"` in a 309-unit-wide
- * box leaves most of the box empty, and anything that treats the pose as the
- * node's extent — picking, lasso, clipping, SVG export — claims that empty
- * space. `textLineBoxes` returns the per-line rectangles instead.
+ * Hit-testing for text nodes.
  *
- * The numbers come from `layoutRuns`, the same walk that positions the glyphs,
- * through the same `resolveTextStyle` → `resolveRuns` → `layoutRuns` chain as
- * `textCommand` — so the boxes cannot drift from what is painted. In
- * particular they honor `align` (a centered line reports its own span, not the
- * wrap width) and `verticalAlign` (the block shifts inside `[y, y + height]`
- * exactly as `drawText` shifts the quads).
+ * `pointInTextPose` does a coarse pose-rect test — suitable for click-to-edit
+ * where the pose rect is the authoritative bounding box (selection outline,
+ * drag target).
  *
- * These are line boxes, not ink boxes: each is `fontSize * lineHeight` tall
- * from the pen's line top. Ink can escape vertically at a `lineHeight` low
- * enough — see the `bounds` note at the end of `layoutRuns` — which is the
- * right trade for hit-testing, where a box that hugged the ink would make
- * an `x` harder to click than an `X`.
+ * `caretIndexAt` does the finer test: given a world-space (x, y) inside the
+ * pose, returns the corresponding character offset so the consumer can place
+ * the caret on click. It reads the caret stops off the same
+ * `cachedLayoutRuns` result the renderer paints and `textLineBoxes` picks
+ * against, so the caret cannot land on a different line — or between
+ * different glyphs — than the one under the pointer.
  */
 
-/** Options for {@link textLineBoxes}. */
-interface TextLineBoxesOpts {
-    /** Grow every box by this much on all four sides (world units). Default 0.
-     *  Picking wants a little slack so a single hairline row of text is still
-     *  grabbable; clipping and export want none. */
+/** Options for `pointInTextPose`. */
+interface PointInTextPoseOpts {
+    /** Extra padding (world units) added to the rect on all sides. Default 0. */
     padding?: number;
-    /** Keep boxes for blank lines (zero width). Default `false` — a blank line
-     *  covers no area, so for hit-testing and silhouettes it is noise. Pass
-     *  `true` when the indices have to line up with the wrapped lines. */
-    includeEmpty?: boolean;
+}
+/** Coarse pose-rect hit-test for a text node — suitable for click-to-edit dispatch. */
+declare function pointInTextPose(x: number, y: number, pose: TextPose, opts?: PointInTextPoseOpts): boolean;
+/** Options for `caretIndexAt`. */
+interface CaretIndexAtOpts {
     /**
      * Wrap width. Default `pose.width`, which is what `createTextLayer` passes
      * and what `TextPose` means by its box.
      *
      * Pass `Infinity` for a node painted by the built-in `kit:text` painter:
-     * that painter deliberately does **not** forward `maxWidth` (see
-     * `NodeShape.ts`), so its text does not wrap, and boxes computed with a
-     * finite width would wrap where the paint did not.
+     * that painter deliberately does not forward `maxWidth`, so its text does
+     * not wrap, and a caret mapped through a finite width would answer for a
+     * line break the paint never made. Mirrors `textLineBoxes`.
      */
     maxWidth?: number;
 }
-/** Per-line rectangles for a text pose, in world units, in layout order. */
-declare function textLineBoxes(pose: TextPose, opts?: TextLineBoxesOpts): Rect[];
+/**
+ * Map a world-space point inside `pose` to a character offset into the pose's
+ * text (0..length). Clicks above the first line clamp to 0; clicks below the
+ * last line clamp to the end. Within a line, the caret lands between two
+ * glyphs at whichever side of the advance cell's midpoint `x` falls on — the
+ * standard "snap caret to nearest character boundary" rule.
+ *
+ * Honors `pose.runs` (a mixed-size line snaps on the cells each run actually
+ * produced) and `pose.verticalAlign`. The offset is into the runs'
+ * concatenated text, which `TextPose` requires to equal `pose.text`.
+ */
+declare function caretIndexAt(x: number, y: number, pose: TextPose, opts?: CaretIndexAtOpts): number;
 
 /**
  * Resize a text node's pose to fit its content. Pure helper — does not own
@@ -6700,7 +6801,60 @@ interface FitTextPoseOptions {
     };
 }
 /** Recompute a `TextPose`'s `width`/`height` to fit its content; pure helper, doesn't mutate scene state. */
-declare function fitTextPose(ctx: CanvasRenderingContext2D, pose: TextPose, opts?: FitTextPoseOptions): TextPose;
+declare function fitTextPose(pose: TextPose, opts?: FitTextPoseOptions): TextPose;
+
+/**
+ * Turning a run-level flag **off** inside a node that sets it.
+ *
+ * Run flags are additive over the node's `TextStyle` — a run turns `bold` /
+ * `italic` / `underline` / `strikethrough` on, never off (see the contract at
+ * the top of `rangeStyle.ts`). So "select a word inside an underlined node and
+ * hit U" is unrepresentable by the stored shape, and the character bar can
+ * only refuse.
+ *
+ * This resolves it by rewriting rather than by widening the model: clear the
+ * flag on the node, and set it on every run *outside* the range. The rendered
+ * result is identical and the edit becomes expressible, with `StyledRun`
+ * unchanged — so nothing a document can already contain changes meaning, which
+ * matters while the flags are heading for a persisted format.
+ *
+ * The alternative was a tri-state run flag (`true` / `false` / inherit). It
+ * cannot cover `bold` or `italic`: those are booleans on a run but
+ * `fontWeight` and `fontStyle` on the node, so a run's `false` has no node-level
+ * boolean to override. Tri-state fixes two of the five flags; this fixes all
+ * five.
+ */
+
+/** The additive run flags. */
+type FlagKey = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'overline';
+/** The result of toggling a style flag over a text range: the rewritten runs
+ *  and node style, and whether the change could be made at all. */
+interface SetFlagResult {
+    runs: StyledRun[];
+    style: TextStyle;
+    /**
+     * False when the node flag could not be lowered without changing what is
+     * drawn, and nothing was written. The only case is a `fontWeight` the run
+     * boolean cannot express: `run.bold` resolves to exactly 700 everywhere, so
+     * a node at 900 cannot have its weight pushed onto its runs. Callers should
+     * disable the control rather than apply a silent downgrade.
+     */
+    applied: boolean;
+}
+/** Does the node style carry this flag? */
+declare function nodeHasFlag(style: TextStyle, key: FlagKey): boolean;
+/**
+ * Set `key` to `value` over `[start, end)`.
+ *
+ * Turning a flag **on**, or off in a node that doesn't set it, is the ordinary
+ * additive write and leaves `style` alone. Turning it off in a node that *does*
+ * set it takes the rewrite: the node flag is cleared and the flag is written
+ * onto the complement of the range.
+ *
+ * `runs` is normalized on every path, so the complement collapses back to one
+ * run when the range is empty and the whole array coalesces as usual.
+ */
+declare function setFlagOverRange(runs: readonly StyledRun[], style: TextStyle, start: number, end: number, key: FlagKey, value: boolean): SetFlagResult;
 
 /**
  * The kit-wide "these values disagree" sentinel. Used wherever a value is
@@ -6791,6 +6945,13 @@ declare function applyStyleToRange(runs: readonly StyledRun[], start: number, en
  * (`isHidden: (n) => n.id === editingId`) so the overlay isn't drawn twice.
  */
 
+type StyleFlag = FlagKey;
+/**
+ * A styling a shortcut or a control toggles. The additive booleans, plus the
+ * two `script` values — which are exclusive rather than additive, so they
+ * toggle against one enum rather than each owning a boolean.
+ */
+type StyleToggle = StyleFlag | 'super' | 'sub';
 /**
  * The caret's character range within the text being edited. Half-open
  * `[start, end)` over the concatenated run text, normalized so `start <= end`
@@ -6845,6 +7006,13 @@ interface UseTextEditOptions {
     getText: (id: string) => string;
     /** Read style for `id` (used for font setup on the overlay). */
     getStyle: (id: string) => TextStyle | undefined;
+    /**
+     * Read the node's paint for `id` — its `data.fill` / `data.stroke`. The
+     * overlay paints its text and caret from the fill, so omitting this
+     * renders every node's editor in the default black however the node
+     * itself is painted.
+     */
+    getPaint?: (id: string) => TextPaint | undefined;
     /**
      * Write style back for `id`. Optional; needed only to turn a flag **off**
      * inside a node whose own `TextStyle` sets it. Run flags are additive, so
@@ -6909,8 +7077,8 @@ interface UseTextEditReturn {
     /**
     * The caret's character range, or `null` when nothing is being edited. A
     * collapsed caret reports `{ start: n, end: n }`, so `null` and "caret at
-    * n" stay distinguishable — a character-styling control routes the
-    * collapsed case to the node's `TextStyle` instead of to a range.
+    * n" stay distinguishable — a styling written at a collapsed caret arms
+    * {@link UseTextEditReturn.pendingStyle} instead of restyling a range.
     *
     * Follows the DOM selection, which browsers (and jsdom) report from a task
     * rather than synchronously; anything this hook writes itself updates it
@@ -6924,33 +7092,82 @@ interface UseTextEditReturn {
     /**
      * The styling shared by every run in `selection` — a concrete value where
      * the range agrees, `MIXED` where it doesn't. `null` exactly when
-     * `selection` is `null`. A collapsed caret reports `{}`: no run is in
-     * range, so the range reader has nothing to say and the node's style is
-     * what applies.
+     * `selection` is `null`. A collapsed caret reports the styling *at* the
+     * caret (the run to its left, or the run to its right at offset 0), which
+     * is what the next typed character inherits.
+     *
+     * This does not include {@link UseTextEditReturn.pendingStyle}. A control
+     * showing what the next character will look like wants both, merged in
+     * that order; one showing what is already written wants only this.
      */
     rangeStyle: RangeStyle | null;
     /**
-     * Write `patch` over `selection`. A no-op with no active edit, with a
-     * collapsed caret (there is no range to style — patch the node's
-     * `TextStyle` instead), or with an empty patch. The caret survives, so a
-     * second style can be applied without re-selecting, and `rangeStyle`
-     * reflects the write before this returns.
+     * Styling armed at a collapsed caret, applied to the next character typed
+     * and then dropped. `{}` when nothing is armed — which is always the case
+     * while `selection` covers a real range, since a range is styled directly.
+     *
+     * Moving the caret abandons it, as in any other editor.
+     */
+    pendingStyle: RunStylePatch;
+    /**
+     * Write `patch` over `selection`. A no-op with no active edit or an empty
+     * patch. Over a real range this restyles the runs under it; at a collapsed
+     * caret it merges into `pendingStyle` instead, so the styling lands on
+     * what gets typed next rather than on text the user didn't select.
+     *
+     * Lowering a flag the *node* sets is neither of those — a run cannot say
+     * "not bold" — so it rewrites instead: the node flag is cleared and raised
+     * on every run outside the range. That path can decline (a node at
+     * `fontWeight: 900` has no run boolean to move it to), in which case
+     * nothing is written.
+     *
+     * The caret survives, so a second style can be applied without
+     * re-selecting, and `rangeStyle` reflects the write before this returns.
      */
     applyStyleToSelection: (patch: RunStylePatch) => void;
+    /**
+     * Toggle one styling over `selection` — set it if the range doesn't
+     * uniformly carry it, clear it if it does. The shape a B / I / x² control
+     * or a keyboard shortcut wants, and what this hook's own shortcuts call.
+     */
+    toggleStyle: (toggle: StyleToggle) => void;
 }
 /** In-place text editing via a contenteditable overlay positioned over the text node's screen-space pose. */
 declare function useTextEdit(opts: UseTextEditOptions): UseTextEditReturn;
 
 /**
- * Compute the union AABB of a set of rectangle-shaped poses.
+ * Union math over rect-shaped poses.
  *
- * Returns null when the input is empty. Useful for selection overlay
- * rendering of groups (where the displayed bounds are the envelope of
- * all transitive leaf members).
+ * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*
+ * boxes and is what commit-time actions want, because they go on to write
+ * poses back in that same frame. `unionAABB` expands each rotated member to
+ * the extent of its ink first, and is what anything a user looks at or clicks
+ * wants — selection chrome, gesture bounds, an export viewBox. Folding the
+ * unrotated box there under-reports the extent of a rotated member exactly
+ * when the consumer is watching it move.
  */
 
-/** Compute the AABB envelope of a set of rect-shaped poses; returns null when empty. */
+/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any
+ *  rotation they carry. See the module docstring before reaching for this
+ *  over {@link unionAABB}. */
 declare function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null;
+/**
+ * Axis-align a pose that carries a `rotation`: returns the AABB of the
+ * rotated rectangle, with `rotation` dropped. Follows the kit's rotation
+ * convention (`poseRotationOf`): rotate about the unrotated AABB center.
+ *
+ * Unrotated input is returned as-is.
+ */
+declare function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose;
+/**
+ * Fold every part into one world-space AABB, skipping `null` / `undefined`
+ * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;
+ * the result never carries a `rotation` (a union of several oriented boxes
+ * has no single orientation to report).
+ *
+ * Returns `null` when nothing was contributed.
+ */
+declare function unionAABB<TPose extends RectPose>(parts: Iterable<TPose | null | undefined>): RectPose | null;
 
 /**
  * `useSceneTextEdit` — scene-aware wrapper around `useTextEdit`.
@@ -6983,6 +7200,8 @@ interface DefaultTextData {
     text?: string;
     style?: TextStyle;
     runs?: readonly StyledRun[];
+    fill?: FillStyle | null;
+    stroke?: Stroke | null;
 }
 /** All-optional projections + fontSize fallback. */
 interface UseSceneTextEditOptions<TData> {
@@ -6990,6 +7209,8 @@ interface UseSceneTextEditOptions<TData> {
     getText?: (data: TData) => string;
     /** Read style from `data`. Default: `data.style`. */
     getStyle?: (data: TData) => TextStyle | undefined;
+    /** Read the node's paint from `data`. Default: `data.fill` / `data.stroke`. */
+    getPaint?: (data: TData) => TextPaint | undefined;
     /** Read rich-text runs from `data`. Default: `data.runs`. */
     getRuns?: (data: TData) => readonly StyledRun[] | undefined;
     /** Produce updated data with new text. Default: `{ ...data, text }`. */
@@ -7017,8 +7238,13 @@ interface UseSceneTextEditOptions<TData> {
      * The overlay takes a single scale factor, so a non-uniform view scale is
      * represented by its `scale.x`; text under `scale.x !== scale.y` will not
      * match the canvas.
+     *
+     * A thunk is re-read on every projection, which is what an uncontrolled
+     * `SceneCanvas` needs — its camera lives in a ref and moves without a
+     * render, so pass the handle's `getView`. A plain `View` is the value from
+     * the render that supplied it, which is correct for a controlled consumer.
      */
-    view?: View;
+    view?: View | (() => View);
     /**
      * Forwarded to `useTextEdit`: is `el` part of the editor's own chrome?
      * Focus moving into it does not end the edit. Wire it to whatever renders
@@ -7041,59 +7267,6 @@ interface UseSceneTextEditReturn extends UseTextEditReturn {
  *  over the node being edited and writes the result back as an undoable op. */
 declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends string, TPose extends RectPose = RectPose>(scene: Scene<TData, TLayer, TPose>, container: HTMLElement | null, options?: UseSceneTextEditOptions<TData>): UseSceneTextEditReturn;
 
-/**
- * Turning a run-level flag **off** inside a node that sets it.
- *
- * Run flags are additive over the node's `TextStyle` — a run turns `bold` /
- * `italic` / `underline` / `strikethrough` on, never off (see the contract at
- * the top of `rangeStyle.ts`). So "select a word inside an underlined node and
- * hit U" is unrepresentable by the stored shape, and the character bar can
- * only refuse.
- *
- * This resolves it by rewriting rather than by widening the model: clear the
- * flag on the node, and set it on every run *outside* the range. The rendered
- * result is identical and the edit becomes expressible, with `StyledRun`
- * unchanged — so nothing a document can already contain changes meaning, which
- * matters while the flags are heading for a persisted format.
- *
- * The alternative was a tri-state run flag (`true` / `false` / inherit). It
- * cannot cover `bold` or `italic`: those are booleans on a run but
- * `fontWeight` and `fontStyle` on the node, so a run's `false` has no node-level
- * boolean to override. Tri-state fixes two of the four flags; this fixes all
- * four.
- */
-
-/** The additive run flags. */
-type FlagKey = 'bold' | 'italic' | 'underline' | 'strikethrough';
-/** The result of toggling a style flag over a text range: the rewritten runs
- *  and node style, and whether the change could be made at all. */
-interface SetFlagResult {
-    runs: StyledRun[];
-    style: TextStyle;
-    /**
-     * False when the node flag could not be lowered without changing what is
-     * drawn, and nothing was written. The only case is a `fontWeight` the run
-     * boolean cannot express: `run.bold` resolves to exactly 700 everywhere, so
-     * a node at 900 cannot have its weight pushed onto its runs. Callers should
-     * disable the control rather than apply a silent downgrade.
-     */
-    applied: boolean;
-}
-/** Does the node style carry this flag? */
-declare function nodeHasFlag(style: TextStyle, key: FlagKey): boolean;
-/**
- * Set `key` to `value` over `[start, end)`.
- *
- * Turning a flag **on**, or off in a node that doesn't set it, is the ordinary
- * additive write and leaves `style` alone. Turning it off in a node that *does*
- * set it takes the rewrite: the node flag is cleared and the flag is written
- * onto the complement of the range.
- *
- * `runs` is normalized on every path, so the complement collapses back to one
- * run when the range is empty and the whole array coalesces as usual.
- */
-declare function setFlagOverRange(runs: readonly StyledRun[], style: TextStyle, start: number, end: number, key: FlagKey, value: boolean): SetFlagResult;
-
 /**
  * Build a `TextDrawCommand`. `textCommand` takes a plain string and wraps it
  * in one run; `textCommandFromRuns` takes the styled runs directly. Both
@@ -7101,12 +7274,16 @@ declare function setFlagOverRange(runs: readonly StyledRun[], style: TextStyle,
  * text command derives `align` and per-run resolution the same way — a
  * caller that assembles the command by hand is one field away from a
  * silently different result.
+ *
+ * `paint` is the node's `data.fill` / `data.stroke`. A caller with no node —
+ * a HUD widget, a debug overlay — states its color on the run instead.
  */
 
+declare function textCommandFromRuns(x: number, y: number, runs: readonly StyledRun[], style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint): DrawCommand;
 /** Build a draw command for a single unstyled string. Text is laid out with
  *  the registered font's metrics, wrapped at `maxWidth` and aligned within
  *  `height` when both are given. */
-declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign): DrawCommand;
+declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint): DrawCommand;
 
 /**
  * Pure DOM ↔ `StyledRun[]` serializers for the contenteditable overlay
@@ -7148,7 +7325,7 @@ declare function domPositionToCharOffset(parent: HTMLElement, node: Node, offset
 /**
  * Tile-pattern primitive — a small helper for building repeating texture
  * tiles from a draw callback. The result plugs into a `FillStyle` of
- * `{ fill: 'pattern', pattern }` (see `../../core/paint-types.ts`).
+ * `{ fill: 'pattern', pattern }` (see `@weasel-js/paint`).
  *
  * GL-backed: the tile is rendered to an `OffscreenCanvas` (with a 2D fallback
  * to a regular `<canvas>` for environments without `OffscreenCanvas`),
@@ -7210,13 +7387,16 @@ declare function resolveFillPattern(fill: FillStyle): FillStyle | null;
  * `withGradientKind` exists to translate.
  */
 
+/** Narrow a paint to the gradient members of `FillStyle`. The three
+ *  discriminants are the union's own definition of `GradientFill`, so every
+ *  consumer that reaches for gradient geometry starts here. */
+declare function isGradientFill(fill: FillStyle | null | undefined): fill is GradientFill;
 /**
- * Color at position `t` (0..1) along a stop list, matching how the GL ramp
- * texture is built: stops sorted by offset, flat extension past either end,
- * linear RGB interpolation between neighbors.
+ * Color at position `t` (0..1) along a stop list, as a hex string — the same
+ * sampling the GL ramp texture bakes, so an editor track and the painted
+ * gradient cannot disagree.
  *
- * Returns transparent black for an empty list. Alpha is interpolated too, so
- * a stop list fading to `transparent` samples correctly.
+ * Returns transparent black for an empty list.
  */
 declare function sampleGradientStops(stops: readonly GradStop[], t: number): string;
 /**
@@ -7253,9 +7433,10 @@ declare function gradientGeometry(fill: GradientFill): {
     angle: number;
 };
 /**
- * A gradient spanning a box corner-to-corner (linear) or filling it
- * (radial / conic) — the sensible starting geometry when a consumer turns a
- * solid fill into a gradient and has only the shape's bounds to go on.
+ * A gradient spanning a box left edge to right edge through its vertical
+ * center (linear) or filling it (radial / conic) — the sensible starting
+ * geometry when a consumer turns a solid fill into a gradient and has only
+ * the shape's bounds to go on.
  */
 declare function gradientForBounds(kind: GradientKind, bounds: {
     x: number;
@@ -7341,16 +7522,40 @@ interface TransformArgs<TPose> {
  *  coalesce window. Pass an explicit key (or a unique one) to opt out. */
 declare function createTransformOp<TPose>(args: TransformArgs<TPose>): Op;
 
+interface Slot {
+    /** Ordinal among the siblings. `-1` means "nowhere in particular". */
+    index: number;
+    /** Id of the sibling that followed at capture time; `null` when the node
+     *  was last. Absent when nothing observed it — `null` survives JSON and
+     *  `undefined` does not, so the two stay distinguishable across a
+     *  serialize/restore round trip. */
+    before?: string | null;
+}
+
 /** @internal */
 interface ReparentArgs {
     id: string;
     fromParentId: string | null;
     toParentId: string | null;
+    /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,
+     *  and only a seed: `apply` re-observes the node's full slot through the
+     *  adapter and that observation supersedes this. */
+    fromIndex?: number;
+    /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.
+     *  Omit to append. */
+    toIndex?: number;
+    /** Slot under the old parent, anchor included. `invert()` forwards it as
+     *  the destination slot; without it undo re-parents with no position and
+     *  the node lands last, quietly changing paint order. */
+    fromSlot?: Slot;
+    /** Slot under the new parent, anchor included. Omit to append. */
+    toSlot?: Slot;
     label?: string;
     coalesceKey?: string;
 }
 /**
- * Op: change `id`'s parent, inverting back to the prior parent.
+ * Op: change `id`'s parent and sibling slot, inverting back to the prior
+ * parent and slot.
  *
  * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the
  * same id batch-merge cleanly.
@@ -7366,32 +7571,46 @@ interface InsertArgs<TNode extends {
 }> {
     node: TNode;
     label?: string;
-    /** Original z-index in the host array. Forwarded to
-     *  `adapter.insertNode(node, index)` when present so undo of a multi-delete
-     *  batch restores paint order instead of reversing it. Optional — adapters
-     *  that don't honor it still work. */
+    /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker
+     *  of the two forms, and all a fresh-insert callsite can know. */
     index?: number;
+    /** Full slot, anchor included. Produced only by `captureSlot` (via a
+     *  delete op's `invert`), and supersedes `index` when present. */
+    slot?: Slot;
 }
 /** Op: insert `node` into the scene; inverts to a delete of the same id. */
 declare function createInsertOp<TNode extends {
     id: string;
 }>(args: InsertArgs<TNode>): InsertOp;
 
+/** A captured node plus its slot in its own parent's child list. */
+interface Placed<TNode> {
+    node: TNode;
+    index: number;
+}
 /** @internal */
 interface DeleteArgs<TNode extends {
     id: string;
 }> {
     node: TNode;
     label?: string;
-    /** Z-index the node occupies in its host array at the moment of delete.
-     *  Forwarded through `invert()` to the re-insert so undo restores paint
-     *  order — without this, undo of a multi-delete batch fully reverses
-     *  the stack. Required: every delete callsite knows where the node sits
-     *  (it has to, to remove it), so there's no good reason to drop the
-     *  data on the floor. */
-    index: number;
-}
-/** Op: remove `node` from the scene; inverts to a re-insert of the captured node. */
+    /** Sibling ordinal the node occupies at the moment of delete. Sugar for
+     *  `slot: { index }`, and only a seed: `apply` re-observes the node's full
+     *  slot through the adapter and that observation supersedes this. Kept
+     *  because it is the whole story for a flat adapter with no `getChildren`,
+     *  where nothing can be observed. */
+    index?: number;
+    /** Full slot, anchor included. Written by `apply`; supersedes `index`. */
+    slot?: Slot;
+    /** Descendants of `node`, preorder (parents before children). `removeNode`
+     *  cascades the whole subtree, so an inverse that re-inserts `node` alone
+     *  brings the container back empty and drops every child on the floor.
+     *  Captured on apply; mirrored into the serialized args so a rebuilt op
+     *  can invert without having run. */
+    descendants?: Placed<TNode>[];
+}
+/** Op: remove `node` and its subtree from the scene; inverts to a re-insert
+ *  of the whole subtree at its captured slots. */
 declare function createDeleteOp<TNode extends {
     id: string;
 }>(args: DeleteArgs<TNode>): Op;
@@ -7534,6 +7753,10 @@ declare function registerOpFactory<A>(name: string, build: (args: A) => Op): voi
  *  `name` isn't registered — callers handle this (typically by substituting
  *  a no-op placeholder so stack ordering survives across kit version skew). */
 declare function rebuildOp(name: string, args: unknown): Op | null;
+/** Every op name currently registered, in registration order. The kit's
+ *  built-ins self-register at module init, so importing the barrel is enough
+ *  to see all of them; consumer factories appear once their module has run. */
+declare function registeredOpNames(): readonly string[];
 
 /** @internal */
 interface HitAdapter<TNode extends {
@@ -7752,6 +7975,20 @@ interface PointInPathOptions {
 /** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
 declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
 
+/**
+ * Polygon-vs-axis-aligned-rect tests. Pure functions; no React/kit deps.
+ *
+ * `polygon` is a closed polyline given as an ordered vertex array; the
+ * closing edge from `polygon[N-1]` to `polygon[0]` is implicit. Even-odd
+ * fill rule (matches `pointInPath`).
+ */
+
+/** A 2D point or vector. */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+
 /**
  * Path-vs-geometry hit-test helpers. Five pure functions covering all
  * combinations of path-vs-point, path-vs-rect, and path-vs-polygon.
@@ -7903,22 +8140,6 @@ declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPat
     path: PolygonPath;
 };
 
-/**
- * The kit's single encoding of the pose-rotation convention: "rotate about the
- * pose's unrotated AABB center by `pose.rotation` (radians)."
- *
- * Every consumer that needs to apply rotation — the render-tree wrap
- * (`canvas/poseRotation.ts`), the world coordinate bake (`pathInWorld`), the
- * silhouette/clip bake (`findShapeSilhouette`), the hit-test inverse
- * (`poseContainsRotated`), and selection chrome — derives its pivot + angle
- * from `poseRotationOf` rather than re-inlining the `if (rotation && x != null
- * …)` gate. If the convention ever changes (different pivot, a transform
- * field, etc.), it changes here.
- *
- * Lives in `features/paths` (the low layer) so both `features` and `canvas`
- * can share it without `features` importing `canvas`.
- */
-
 /** Pivot (`cx`, `cy`) and angle resolved from a pose's rotation convention. */
 interface PoseRotation {
     cx: number;
@@ -8199,8 +8420,9 @@ declare function createPenPreviewLayer(opts: CreatePenPreviewLayerOptions): Rend
  * but a human user needs to see what's hittable.
  *
  * The layer reads the live edit target each frame via the supplied
- * `getEditingId()` + `getPose(id)` thunks. Returns `[]` when no editing
- * target is set or the target isn't a polygon — the layer never throws.
+ * `getEditingId()` + `getPose(...)` thunks, resolving the path against the
+ * drawing view's own previews. Returns `[]` when no editing target is set or
+ * the target isn't a polygon — the layer never throws.
  *
  * Anchors render as small white-filled stroked squares — filled solid
  * when selected; control points as small filled circles connected to
@@ -8220,9 +8442,15 @@ interface CreatePathEditingOverlayLayerOptions {
      *  when no node is being edited. Read each frame so live selection /
      *  edit-target changes show up without re-creating the layer. */
     getEditingId(): string | null;
-    /** Returns the pose for an id, or null if the node has been deleted.
-     *  Non-polygon poses are tolerated (the layer no-ops on them). */
-    getPose(id: string): Path | null;
+    /**
+     * Returns the pose for an id, or null if the node has been deleted.
+     * Non-polygon poses are tolerated (the layer no-ops on them).
+     *
+     * `previews` are the drawing view's in-flight preview surfaces, so an
+     * anchor dragged in one panel does not move in the others. Resolve against
+     * them before falling back to the committed pose.
+     */
+    getPose(id: string, previews: readonly GesturePreviewSource[]): Path | null;
     /** Flat indices of the selected anchors. Selected anchors render
      *  filled; unselected ones hollow — the standard vector-editor cue for
      *  "these are what the arrow keys and Delete will act on". Omit when
@@ -8236,12 +8464,6 @@ interface CreatePathEditingOverlayLayerOptions {
         width: number;
         height: number;
     } | null;
-    /** Chrome-caps predicate. The layer asks `'path-edit.anchors'` before
-     *  drawing anything, so paint and the anchor hit-test in
-     *  `affordanceAt` consult the same rule — otherwise a consumer that
-     *  hides the chrome still gets grabbable invisible anchors, or vice
-     *  versa. Omit to always draw when an edit target is set. */
-    isVisible?(chromeId: string): boolean;
     /** Optional styling overrides. */
     style?: PathEditingOverlayStyle;
 }
@@ -8422,6 +8644,301 @@ declare function withAlpha01(color: string, alpha01: number): string;
  *  strips the alpha channel and returns a bare 6-char hex. */
 declare function mergeAlphaFromPrev(picked: string, prev: string): string;
 
+/**
+ * The paint-kind registry — what makes `FillStyle` open.
+ *
+ * A consumer registers a sixth kind and it renders, converts between the
+ * bounds and pose frames, and serializes, with no kit edits. The five built-in
+ * kinds are registered here at module load so an editor's kind bar can
+ * enumerate every kind through one list.
+ *
+ * Each kit layer consults this registry for a kind it does not recognize and
+ * otherwise runs its own built-in branch. That split is not laziness: a built-in
+ * kind's render slot lives in the GL renderer, its serialize slot lives in
+ * `@weasel-js/svg`, and neither can be imported from here without inverting a
+ * package dependency.
+ */
+
+/** A compiled GL program. A paint kind gets one from
+ *  {@link PaintBindContext.program} and hands it back from `bind`. */
+type PaintProgram = ShaderProgram;
+/**
+ * `FillStyle`'s discriminant, open on the string the way `ChromeId` is: the
+ * five kinds the kit ships, plus whatever a consumer registers.
+ */
+type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | 'pattern' | (string & {});
+/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`
+ *  is the control that mounts it. */
+interface PaintKindEditorProps {
+    value: FillStyle;
+    onInput?(next: FillStyle): void;
+    onChange(next: FillStyle): void;
+}
+/**
+ * The renderer surface a paint kind binds against, narrowed to what a paint
+ * needs. The full `DrawContext` is not consumer surface.
+ */
+interface PaintBindContext {
+    readonly gl: WebGL2RenderingContext;
+    /** The group alpha this draw inherits — multiply it into the paint's own. */
+    readonly alpha: number;
+    /**
+     * The compiled program for a `registerProgram` id, compiled against this
+     * renderer on first use. `null` when no source is registered under `id` or
+     * compilation failed.
+     */
+    program(id: string): PaintProgram | null;
+    /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */
+    setProjAndModel(program: PaintProgram): void;
+    /**
+     * `u_worldInv` for a paint declaring `units` — the inverse of the transform
+     * from the paint's space to the frame the geometry arrives in. Paired with
+     * the vertex shader's `v_world` varying this is *the* paint-space
+     * convention; it is not gradient-specific.
+     */
+    spaceInverse(units: GradientUnits | undefined): Mat3$1;
+    /** Upload a stop ramp and bind it to a texture unit. */
+    bindRamp(stops: GradStop[], unit: number): void;
+}
+/**
+ * One paint kind.
+ *
+ * `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 — but
+ * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that
+ * converts one direction and not the other paints correctly once and then
+ * drifts on the next resize.
+ */
+interface PaintKindEntry {
+    id: string;
+    label: string;
+    /** Glyph naming this kind in an editor's kind bar, as an icon name the UI
+     *  layer resolves — the same indirection `ToolPrefBase.icon` uses. A kind
+     *  without one is named by its `label`. */
+    icon?: string;
+    /** 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): FillStyle;
+    /** The single color this paint shows, or `undefined` when it has none. */
+    colorOf(paint: FillStyle): string | undefined;
+    /** Editor slot. */
+    Editor?: ComponentType<PaintKindEditorProps>;
+    /**
+     * Render slot: bind program, uniforms and textures for `fill` and return the
+     * bound program; `null` declines the paint.
+     *
+     * Binding is split from drawing on purpose — a caller owning its own stencil
+     * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own
+     * draw call, and the kit's draw wrapper would clobber that state. Shader
+     * output must be premultiplied: `outColor = vec4(rgb * a, a)`.
+     */
+    bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;
+    /** Bounds frame → the frame the node is painted in. */
+    inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /** The inverse. Required whenever `inPoseFrame` is supplied. */
+    toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /** The `<defs>` entry backing a `url(#id)` reference. */
+    toSvg?(id: string, fill: FillStyle): string;
+}
+/**
+ * A consumer's own paint, typed as a `FillStyle`.
+ *
+ * `FillStyle` 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 `fill` and hands the whole object back to that
+ * kind's slots.
+ */
+declare function asPaint<T extends {
+    fill: string;
+}>(paint: T): FillStyle;
+/** Register a paint kind. Returns a disposer that removes it. */
+declare function registerPaintKind(entry: PaintKindEntry): () => void;
+/** The entry for `kind`, or `undefined`. */
+declare function getPaintKind(kind: string | undefined): PaintKindEntry | undefined;
+/** Every registered kind, built-ins first, in registration order. */
+declare function listPaintKinds(): readonly PaintKindEntry[];
+/** The registry entry for a paint, or `undefined` when its kind is unknown. */
+declare function paintKindOf(fill: FillStyle): PaintKindEntry | undefined;
+/** @internal Test helper — do not call from product code. */
+declare function _resetPaintKindsForTests(): void;
+
+/**
+ * The stroke-marker registry — arrowheads and other line terminators.
+ *
+ * Keyed by string, because a key is what sits in `stroke.markerEnd`. That is
+ * the difference from `registerNodeShape`, which resolves by first-matching
+ * predicate and whose `id` is only a label.
+ *
+ * A built-in's SVG slot lives in `@weasel-js/svg` and cannot be imported here
+ * without inverting a package dependency, so an entry carries `toSvg` for that
+ * package to consume — the same split `PaintKindEntry` uses.
+ */
+
+/** What an entry's `path` is given. Entries that ignore it may return a
+ *  constant path. */
+interface MarkerCtx {
+    /** One geometry unit, in the same world units the ribbon is tessellated in.
+     *  Defaults to the resolved stroke width. */
+    readonly size: number;
+    /** The stroke this marker belongs to, already width-resolved. */
+    readonly stroke: Stroke;
+}
+/** `'line'` means the stroke's own paint — SVG 2's `context-stroke`, as the
+ *  default rather than an opt-in. */
+type MarkerPaint = FillStyle | 'line' | 'none';
+interface MarkerEntry {
+    /** `'kit:'`-free for built-ins so the key matches the SVG attribute value;
+     *  consumers should prefix (`'app-my-head'`). A key becomes the `id` of the
+     *  emitted `<marker>` def, so it must be a valid XML name — no colons. */
+    id: MarkerKey;
+    /** Geometry with its anchor at the origin, pointing +X, in units of
+     *  `ctx.size`. An arbitrary anchor is expressed by where the geometry is
+     *  drawn, which is why there is no `refX`/`refY`. */
+    path(ctx: MarkerCtx): Path;
+    /** Default `'line'`. */
+    fill?: MarkerPaint;
+    /** Outline width is in the same units as `path`. `false` (the default)
+     *  means no outline. */
+    outline?: {
+        width: number;
+        paint?: MarkerPaint;
+    } | false;
+    /** How far back along the line the stroke stops, in units of `ctx.size`.
+     *  Default 0. A property of the shape, not a setting on the stroke: an open
+     *  V needs 0 or its arms stop meeting the line. */
+    inset?: number;
+    /** `'auto'` (default) follows the line; a number is a fixed angle in
+     *  radians, ignoring the line — SVG's `orient="<angle>"`. */
+    orient?: 'auto' | number;
+    /** Emits the `<marker>` def. Consumed by `@weasel-js/svg`. */
+    toSvg?(id: string, entry: MarkerEntry): string;
+}
+/** Register a marker. Returns a disposer. Re-registering a built-in id is an
+ *  override; disposing it restores the built-in rather than deleting the key. */
+declare function registerMarker(entry: MarkerEntry): () => void;
+/** The entry for `key`, or `undefined`. */
+declare function getMarker(key: string | undefined): MarkerEntry | undefined;
+/** Every registered marker, built-ins first, in registration order. */
+declare function listMarkers(): readonly MarkerEntry[];
+/** Test helper. Do not call from product code. */
+declare function _resetMarkersForTests(): void;
+
+/**
+ * Resolving a `MarkerRef` to the distance the ribbon must stop short.
+ *
+ * The tessellation layer takes these as plain numbers and knows nothing about
+ * the registry — keeping that layer free of upward dependencies is deliberate.
+ * The ribbon cache, the SVG serializer and `inkReach` all resolve through here,
+ * so the ribbon, the export and the hit region cannot disagree about where the
+ * line ends.
+ */
+
+/** The size of one marker unit, in the same world units as `strokeWidth`. */
+declare function resolveMarkerSize(ref: MarkerRef, strokeWidth: number): number;
+declare function markerKeyOf(ref: MarkerRef): string;
+/**
+ * How far back the ribbon stops for `ref`, in world units. Zero for an absent
+ * marker, an unregistered key, or an open head — never throws, because an
+ * unknown key is a data problem and dropping the head is the graceful answer.
+ */
+declare function markerInset(ref: MarkerRef | undefined, strokeWidth: number): number;
+/** The start and end insets a stroke asks for. `markerMid` never insets —
+ *  trimming at an interior vertex would cut the line in two. */
+declare function strokeInsets(stroke: Stroke, strokeWidth: number): {
+    start: number;
+    end: number;
+};
+
+interface Polyline {
+    /** Interleaved x,y vertices (length = 2 × point count). */
+    points: number[];
+    /** Whether the contour was closed (ends with Z, or is a RectPath). */
+    closed: boolean;
+    /** For each point, the previous anchor index. Anchor-aligned points set A === B. */
+    anchorA?: Uint32Array;
+    /** For each point, the next anchor index. */
+    anchorB?: Uint32Array;
+    /** For each point, the arc-length fraction along (A, B). 0 at anchor A; for anchor-aligned, set to 0. */
+    anchorT?: Float32Array;
+    /** Per-point stroke width, populated by the tessellator when the Stroke
+     *  carries `vertexWidths`. Undefined means uniform `Stroke.width`. */
+    widths?: Float32Array;
+}
+
+/**
+ * Where a stroke's markers sit and which way they point.
+ *
+ * Computed from the *untrimmed* polyline: trimming moves the endpoint, and a
+ * marker anchors to where the line was authored to end, not to where the
+ * ribbon was cut.
+ */
+
+interface MarkerSite {
+    x: number;
+    y: number;
+    /** Radians. The direction the marker's +X axis should point — outward at a
+     *  start or end, along the bisector at an interior vertex. */
+    angle: number;
+    role: 'start' | 'mid' | 'end';
+}
+interface MarkerSiteRequest {
+    start: boolean;
+    mid: boolean;
+    end: boolean;
+}
+declare function markerSites(pl: Polyline, want: MarkerSiteRequest): MarkerSite[];
+
+/**
+ * Turning a stroke's markers into draw commands.
+ *
+ * Separate `PathDrawCommand`s rather than triangles appended to the stroke
+ * ribbon: an entry may carry a fill and an outline at once, or a paint that
+ * differs from the line's, neither of which one mesh can express — and folding
+ * them in would drag the whole marker vocabulary into the ribbon cache key.
+ */
+
+/**
+ * Every marker command for `path` under `stroke`. `strokeWidth` is the already
+ * width-resolved stroke width; `flattenTolerance` matches what the ribbon used,
+ * so markers land on the same flattened vertices the stroke did.
+ */
+declare function markerDrawCommands(path: Path, stroke: Stroke, strokeWidth: number, flattenTolerance: number | undefined): PathDrawCommand[];
+
+/**
+ * The kit's built-in stroke-marker vocabulary.
+ *
+ * Every entry is authored with its anchor at the origin and pointing +X, so
+ * the line arrives from -X and no geometry sits at positive X. Coordinates are
+ * in units of `MarkerCtx.size`, which defaults to the resolved stroke width —
+ * one definition is therefore correct at any line weight.
+ *
+ * Not to be confused with `features/paths/markers.ts`, which builds
+ * decorative chrome shapes and is unrelated.
+ */
+
+declare const BUILTIN_MARKERS: readonly MarkerEntry[];
+
+/**
+ * Shortening a flattened subpath so a filled marker is not speared by its own
+ * line. SVG has no equivalent — it paints the marker over a full-length
+ * stroke — so this is the one place our rendering deliberately differs.
+ *
+ * Runs before dash splitting, so a dash pattern fits the visible line rather
+ * than running off under the head. The anchor-param interpolation matches
+ * `splitForDash`'s rule for a boundary landing mid-segment.
+ */
+
+/**
+ * Shorten `pl` by `startInset` from its first point and `endInset` from its
+ * last, both in the same world units as the points.
+ *
+ * Returns `pl` itself when there is nothing to do (both insets zero, or the
+ * subpath is closed and so has no free ends), and `null` when the insets
+ * consume the whole run — a caller should then draw no ribbon at all.
+ */
+declare function trimPolyline(pl: Polyline, startInset: number, endInset: number): Polyline | null;
+
 /** Kit-shipped default paint constants.
  *
  *  Single source of truth for the colors the built-in tools and the default
@@ -8432,6 +8949,7 @@ declare function mergeAlphaFromPrev(picked: string, prev: string): string;
  *  All values are `#rrggbbaa` so they round-trip through the kit's hex8 alpha
  *  helpers (`util/color`) without ambiguity.
  */
+
 /** Default fill paint for shapes and the fill action — opaque white. */
 declare const DEFAULT_FILL_COLOR = "#ffffffff";
 /** Default stroke paint for shapes and the stroke action — opaque black. */
@@ -8443,6 +8961,41 @@ declare const DEFAULT_PALETTE: readonly string[];
  *  selected-anchor highlight. Derived from the first palette entry so the
  *  preview chrome matches the default insert color. */
 declare const GHOST_STROKE: string;
+/**
+ * A solid paint from a color string — the authoring shorthand for the one
+ * shape a node's `data.fill` (and a `Stroke.paint`) may take.
+ *
+ * An alpha channel in `color` moves to `opacity`, because that is where every
+ * paint kind carries its alpha; leaving it in the hex too would multiply the
+ * two in the renderer.
+ */
+declare function solid(color: string): FillStyle;
+/** A solid stroke of `color` at `width` world units. Authoring shorthand for
+ *  `{ paint: solid(color), width }`. */
+declare function strokeOf(color: string, width?: number): Stroke;
+/** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling
+ *  for a gradient or pattern, which has no color to pass. */
+declare function strokeWith(paint: FillStyle, width?: number): Stroke;
+/** The kit's default node paint — what a shape with no declared fill paints. */
+declare const DEFAULT_SHAPE_FILL: FillStyle;
+/**
+ * The 0..1 alpha a paint paints at.
+ *
+ * Every paint kind carries its alpha in `opacity` — that is the one slot a
+ * gradient or a pattern has, so it is the slot all of them use.
+ */
+declare function paintAlpha(paint: FillStyle | undefined): number;
+/** `paint` painting at `alpha01` (clamped to 0..1). */
+declare function paintWithAlpha(paint: FillStyle, alpha01: number): FillStyle;
+/**
+ * `paint` recolored to `color`, keeping everything else about it.
+ *
+ * A solid paint takes the new color; a gradient or a pattern has no single
+ * color to replace, so it is superseded by a solid one — picking a color off
+ * a swatch means "paint this color". An alpha channel in `color` wins;
+ * without one, the paint's existing opacity carries over.
+ */
+declare function paintWithColor(paint: FillStyle | undefined, color: string): FillStyle;
 
 /**
  * Build an op-batched undo/redo `History`, defaulting restore-time op
@@ -8476,7 +9029,9 @@ interface ArrayAdapterConfig<TNode extends {
     getParent?: (id: string) => string | null;
     /** Optional reparent mutator. Default is a noop. */
     setParent?: (id: string, parentId: string | null) => void;
-    /** Optional children lookup. Default omits the method. */
+    /** Optional children lookup for a node id. The adapter answers the root
+     *  itself, from `ref` and `getParent` in array order, so this is never
+     *  called with `null`. Default omits the method entirely. */
     getChildren?: (id: string) => string[] | undefined;
     /** Live ref to the current selection. Default: empty array. */
     selectionRef?: MutableRefObject<string[]>;
@@ -8672,7 +9227,8 @@ interface GuidesLayerOpts {
  *  screen space, projected from world offsets via the active view. */
 declare function createGuidesLayer(opts: GuidesLayerOpts): RenderLayer<unknown>;
 
-/** Axis-aligned bounding box. Rotation is ignored in v1 (alignment uses AABBs). */
+/** Axis-aligned bounding box. Alignment matches AABBs throughout; a rotated
+ *  pose enters as the AABB of its ink (see `AlignBoundsProjection.boundsOf`). */
 interface AlignBounds {
     x: number;
     y: number;
@@ -8695,18 +9251,27 @@ interface AlignMatchResult {
  *  and translates a pose. The rect default handles `{x,y,width,height}` poses;
  *  non-rect poses (Path, polygon) supply their own. */
 interface AlignBoundsProjection<TPose> {
+    /** The pose's *visual* AABB — a rotated pose reports the extent of its ink,
+     *  not the box it was posed in. Guides and matching both read this, so an
+     *  implementation that returns the stored box makes a rotated shape snap to
+     *  lines nothing is drawn at. */
     boundsOf(pose: TPose): AlignBounds;
+    /** Move the pose, preserving every other field it carries — nothing
+     *  downstream re-derives rotation or style from anywhere else. */
     translate(pose: TPose, dx: number, dy: number): TPose;
 }
-/** Which candidate lines to derive from a set of bounds — edges, centers, or
+/** Which candidate lines to derive from a set of poses — edges, centers, or
  *  both, and whether the page box contributes its own. */
-interface DeriveAlignmentGuidesOptions {
+interface DeriveAlignmentGuidesOptions<TPose = AlignBounds> {
     /** Include the document/page box's edges + center as candidates. */
     page?: AlignBounds;
     /** Emit left/right (x) and top/bottom (y) edge guides. Default true. */
     edges?: boolean;
     /** Emit centerX (x) and centerY (y) guides. Default true. */
     centers?: boolean;
+    /** Reads each target's AABB. Defaults to `RECT_ALIGN_PROJECTION`. Pass the
+     *  same projection `alignMoveBehavior` gets, or the two sides disagree. */
+    projection?: AlignBoundsProjection<TPose>;
 }
 /** Common options shared by the three alignment behavior factories. */
 interface AlignmentBehaviorBase {
@@ -8723,18 +9288,23 @@ interface AlignmentBehaviorBase {
     bypassKey?: keyof ModifierState;
 }
 
-/** Derive candidate alignment lines from a set of AABBs (siblings) plus an
+/** Derive candidate alignment lines from a set of sibling poses plus an
  *  optional page box. Each box contributes up to 3 guides per axis: the two
- *  edges and the center. Overlapping offsets collapse to one candidate. */
-declare function deriveAlignmentGuides(targets: readonly AlignBounds[], opts?: DeriveAlignmentGuidesOptions): Guide[];
+ *  edges and the center. Overlapping offsets collapse to one candidate.
+ *  Poses go through the same projection `alignMoveBehavior` matches with, so
+ *  a rotated sibling advertises its ink edges rather than its stored box. */
+declare function deriveAlignmentGuides<TPose = AlignBounds>(targets: readonly TPose[], opts?: DeriveAlignmentGuidesOptions<TPose>): Guide[];
 
 /** Move/insert test all three features per axis. */
 declare const MOVE_ANCHORS: {
     x: readonly AlignAnchor[];
     y: readonly AlignAnchor[];
 };
-/** Default projection for rect-shaped poses (`{x,y,width,height}`). */
-declare const RECT_ALIGN_PROJECTION: AlignBoundsProjection<AlignBounds>;
+/** Default projection for rect-shaped poses (`{x,y,width,height,rotation?}`).
+ *  A rotated pose reports the AABB of its ink, so guides derived from a
+ *  stationary sibling and the box a dragged selection matches with are the
+ *  same measurement. */
+declare const RECT_ALIGN_PROJECTION: AlignBoundsProjection<RectPose>;
 /**
  * Match a moving box's selected edge/center features against candidate guide
  * lines. Returns the per-axis snap delta and the matched candidate line(s).
@@ -8801,7 +9371,7 @@ declare function pointInRotatedRect(pose: RotatedPose, worldX: number, worldY: n
  *  handle's center. Matches the demo's visual default; consumers can
  *  override per-call. Unscaled — kit-internal use sites multiply by
  *  `DeviceProfile.targetScale`. */
-declare const DEFAULT_ROTATION_HANDLE_DISTANCE = 24;
+declare const DEFAULT_ROTATION_HANDLE_DISTANCE: 24;
 /** Rotation handle position in world coords. */
 interface RotationHandle {
     /** Handle center in world coords. */
@@ -9137,7 +9707,8 @@ interface SelectFromLassoOptions {
  *  preserve, with shift). */
 declare function selectFromLasso(opts?: SelectFromLassoOptions): LassoSelectBehavior;
 
-/** Edge or center the selection should align to within the selection's union AABB. */
+/** Edge or center the selection should align to within the selection's visual
+ *  union AABB (rotated members contribute their ink extent). */
 type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';
 /** Adapter for `useAlign`. */
 interface AlignAdapter<TPose> {
@@ -9159,6 +9730,17 @@ interface UseAlignReturn {
     /** Imperative trigger. No-op when fewer than 2 items selected. */
     align(edge: AlignEdge): void;
 }
+/**
+ * The pose's *visual* bounds: its descriptor bounds expanded to cover the
+ * rotated rectangle, so a turned shape reports the extent of its ink rather
+ * than the box it was posed in. Align, distribute and flip all fold these.
+ *
+ * Both ends of an align must use it — a visual union measured against
+ * unrotated member boxes misplaces every rotated member. The expanded box
+ * shares its centre with the stored one, so the delta stays a translation of
+ * the stored pose and no re-posing is needed.
+ */
+declare function visualBoundsViaDescriptor<TPose>(pose: TPose, geometry: PoseProjection<TPose>): ResizePose;
 /** Compute the (dx, dy) translation that moves AABB `b` so that the requested
  *  `edge`/center matches the corresponding feature of the union AABB `u`. */
 declare function alignDeltaFor(b: ResizePose, u: ResizePose, edge: AlignEdge): {
@@ -9175,8 +9757,9 @@ declare function useAlign<TPose>(adapter: AlignAdapter<TPose>, options?: UseAlig
 
 /** Axis along which selection is distributed. `'x'` spreads horizontally. */
 type DistributeAxis = 'x' | 'y';
-/** `'centers'` spaces AABB centers equally; `'gaps'` makes the gap between
- *  consecutive AABBs equal. Endpoints stay put in both modes. */
+/** `'centers'` spaces centers equally; `'gaps'` makes the gap between
+ *  consecutive items equal. Both measure a rotated item by its ink extent.
+ *  Endpoints stay put in both modes. */
 type DistributeMode = 'centers' | 'gaps';
 /** Adapter for `useDistribute`. */
 interface DistributeAdapter<TPose> {
@@ -9976,6 +10559,10 @@ declare function RectIcon({ className, size }: IconProps): react_jsx_runtime.JSX
 /** Outlined ellipse. Used for the ellipse insertion tool. */
 declare function EllipseIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
 
+/** Framed picture with a sun and mountain — the conventional "image" glyph.
+ *  Used for the image insertion tool (`useImageTool`). */
+declare function ImageIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+
 /** Eyedropper — diagonal stem running from upper-right (bulb) to
  *  lower-left (tip), with a small squared bulb cap at the top. Used
  *  for the eyedropper / color-picker tool. */
@@ -10069,4 +10656,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ANCHOR_HIT_BASE_PX, Action, ActionsProp, ActionsProviderIfRoot, ActionsRegistry, Affordance, AffordanceBinding, AffordanceHit, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignBounds, type AlignBoundsProjection, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimateToBoundsOptions, type AnimationHandle, type Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COARSE_TARGET_SCALE, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, type ColorOverride, type ColorOverrideFn, ColorOverrideRegistry, type ColorSpace, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, Condition, ContentHandlerEntry, Contribution, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DecayLoopConfig, type DecayOptions, type DefaultTextData, DepRegistryProviderIfRoot, DepSchema, type DeriveAlignmentGuidesOptions, DetectedDeviceFacts, DeviceProfile, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type Discriminator, Dispatcher, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EASINGS, type EasingFn, type EasingName, Eligibility, type EligibilityState, EllipseIcon, type EventTrack, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, FillStyle, type FitTextPoseOptions, FitViewToBoundsOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GestureSource, GradStop, GradientFill, GradientKind, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragPoint, type HeadlessCanvasLike, HotkeyTrigger, IDENTITY_JOINT, type IconProps, type ImageNodeData, type ImageStatus, type IndicatorStyle, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type Interpolate, type InterpolatorFactory, IntersectIcon, type Joint, type JointTransform, KIT_SHAPE_KINDS, type Keyframe, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerHit, type LayerSlotValue, type LayersMap, type LayoutLine, type LayoutResult, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, type LoopFactory, type LoopOptions, MIXED, MOVE_ANCHORS, type MarkdownFontOptions, Mat3$1 as Mat3, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredText, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NestedTimeline, type NodeClientRect, type NodeFill, NodeId, type NodeInk, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, OverlayPosition, PATH_ANCHOR_CHROME_ID, type PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, type PhysicsHandle, type PhysicsOptions, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomToolOpts, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseProjection, type PoseRotation, type PositionedRun, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type Rect, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, ResolvedTextStyle, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SPRING_PRESETS, type SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasProps, Node$1 as SceneNode, type SceneNodeClientRectOpts, SceneRegistry, type SceneSlotConfig, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewDrawOne, ScopedBinding, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationForce, type SimulationNode, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringOptions, type SpringPoseOptions, type SpringPreset, type SpringPresetName, type SpringVertexColorsOptions, type StaggerBuilder, type StaggerDelay, type StaggerFactory, type StaggerOptions, type StaggerPerItem, type StaggerSpringPoseOptions, type StaggerTweenOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, Stroke, type StyleKey, StyledRun, type StylusData, SubtractIcon, SvgIngestOptions, type TextEditScreenPose, type TextEditSelection, TextIcon, type TextLineBoxesOpts, type TextPose, type TextRenderer, TextStyle, TextVerticalAlign, TextureHandle, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, TilePatternSpec, type TimelineHandle, type TimelineOptions, type TimelineTrack, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type Track, type TweenLoopOptions, type TweenOptions, type TweenPoseOptions, type TweenVertexColorsOptions, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGestureDispatcherOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, type UseZoomOptions, type UseZoomReturn, VERSION, type Vec2, type VertexColorChannel, View, ViewTransform, type ViewportConfig, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomOptions, VisibilityRules, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, bezierCubic, bezierQuadratic, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isDebugEnabled, isEditableTarget, isPatternSpec, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, liveScope, makeViewportZoomAction, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerNodeShape, registerOpFactory, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolvePatternSpec, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scopeBindings, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, setScratch, shapeCoversPoint, snap, snapPoint, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, styleAtRange, subscribeImageReady, textCommand, textLineBoxes, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, viewportDragPanAction, viewportZoomAction, viewportsAt, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };
+export { ANCHOR_HIT_BASE_PX, Action, type ActionShortcut, ActionsProp, ActionsProviderIfRoot, ActionsRegistry, Affordance, AffordanceBinding, AffordanceHit, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignBounds, type AlignBoundsProjection, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, BUILTIN_MARKERS, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COARSE_TARGET_SCALE, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHelpers, type CanvasViewProps, type CaretIndexAtOpts, type CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type ColorSpace, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, Condition, ContentHandlerEntry, Contribution, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DecayLoopConfig, type DefaultTextData, DepRegistryProviderIfRoot, DepSchema, type DeriveAlignmentGuidesOptions, DetectedDeviceFacts, DeviceProfile, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type Discriminator, Dispatcher, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EASINGS, EasingFn, type EasingName, Eligibility, type EligibilityState, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, type FitTextPoseOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragPoint, type HeadlessCanvasLike, HotkeyTrigger, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, IntersectIcon, type Joint, type JointTransform, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerHit, type LayerSlotValue, type LayersMap, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, Mat3$1 as Mat3, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, NodeId, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OngoingOverlay, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, OverlayPosition, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, type PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PinchZoomToolOpts, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseProjection, type PoseRotation, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, type ResolvableView, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SPRING_PRESETS, SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasProps, Node$1 as SceneNode, type SceneNodeClientRectOpts, SceneRegistry, type SceneSlotConfig, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewDrawOne, ScopedBinding, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationForce, type SimulationNode, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPreset, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGestureDispatcherOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, type UseZoomOptions, type UseZoomReturn, VERSION, type Vec2, VertexColorChannel, View, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, ViewTransform, type ViewportConfig, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isDebugEnabled, isEditableTarget, isGradientFill, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolveMarkerSize, resolvePatternSpec, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, setScratch, shapeCoversPoint, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromRuns, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, useZoom, viewportDragPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };