@weasel-js/core 1.4.3 → 1.5.0

package/dist/index.d.ts

@@ -1,48 +1,40 @@
 import * as React$1 from 'react';
 import React__default, { RefObject, ReactNode, Ref, MouseEvent, 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-Bw8cSde-.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-Bw8cSde-.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, I as InertiaConfig, 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, s as LayerGroup, U as UseSelectionOptions, t as InsertExtras, B as BuiltinShapeToolId, G as GeometryProjection, u as ContentHandlerEntry, v as SvgIngestOptions, P as PanBounds, w as ActionsProp, x as Animator, y as Affordance, z as AffordanceRegion, E as AffordanceBinding, F as CommonAffordanceScratch, J as ColorOverrideRegistry, K as BooleansAdapter, M as UseAnimatorOptions, N as SpringPresetName, Q as EasingSpec, W as AnimationHandle, X as VertexColorChannel, Y as SampledTrack, Z as Eligibility, _ as BindingScope, $ as Contribution, a0 as ScopedBinding } from './registry-DnoTWGED.js';
-export { a1 as ALWAYS, a2 as ActionDeps, a3 as ActionDisabledReason, a4 as ActionEnabledResult, a5 as ActionEntry, a6 as ActionsProvider, a7 as ActionsScope, a8 as ActiveToolContextProvider, a9 as ActiveToolContextProviderIfRoot, aa as ActiveToolContextProviderProps, ab as ActiveToolContextValue, ac as AnimateToBoundsOptions, ad as AreaSelectDep, ae as BezierEasing, af as BindingOpts, ag as BooleanOp, ah as BooleanOpResult, ai as BoundGesture, aj as BuildRuleCtxArgs, ak as ClaimableGesture, al as ClipboardDep, am as ClipboardIngestCtx, an as ColorOverride, ao as ColorOverrideFn, ap as CustomPaintContext, aq as DecayLoopConfig, ar as DecayOptions, as as DepName, at as DepRegistry, au as DepRegistryProvider, av as DispatcherContext, aw as DragSample, ax as EASINGS, ay as EasingFn, az as EasingName, aA as EditAnchorsDep, aB as EventTrack, aC as GestureBinding, aD as IDENTITY_POSE_COMPOSITION, aE as ImmediateInvoker, aF as IngestCtx, aG as IngestionDep, aH as InsertDep, aI as Interpolate, aJ as InterpolatorFactory, aK as InvocationCtx, aL as Invoker, aM as KIT_SHAPE_KINDS, aN as Keyframe, aO as LassoSelectDep, aP as LayerCommandCache, aQ as LayerDrawFailure, aR as LayoutDep, aS as LoopFactory, aT as LoopOptions, aU as MatchResult, aV as NEVER, aW as NestedTimeline, aX as NodeAtPointDep, aY as OngoingHandle, aZ as OngoingInvoker, a_ as PhysicsHandle, a$ as PhysicsOptions, b0 as Point2, b1 as PointerContextProvider, b2 as PointerContextValue, b3 as PointerWorldPos, b4 as PoseAdapter, b5 as PoseComposition, b6 as ResizePolicy, b7 as ResolveAllOptions, b8 as ResolveOnlyResult, b9 as ResolvedCandidate, ba as SPRING_PRESETS, bb as SelectionExtendKey, bc as SelectionMode, bd as Selector, be as SnapDep, bf as SpringOptions, bg as SpringPreset, bh as StaggerBuilder, bi as StaggerDelay, bj as StaggerFactory, bk as StaggerOptions, bl as StaggerPerItem, bm as StaggerSpringPoseOptions, bn as StaggerTweenOptions, bo as SvgUnpacker, bp as TextEditDep, bq as TimelineHandle, br as TimelineOptions, bs as TimelineTrack, bt as ToolCtx, bu as ToolModifiers, bv as ToolPresentation, bw as ToolSlot, bx as Track, by as TweenLoopOptions, bz as TweenOptions, bA as UiOngoingControl, bB as VIEW_ANIMATION_KEY, bC as ViewAnimationApi, bD as ViewApi, bE as ViewChannel, bF as actionBindings, bG as applyBooleanOp, bH as buildRuleCtx, bI as clipboardCopyAction, bJ as clipboardCutAction, bK as composeRectPose, bL as composeWorldPose, bM as createDispatcher, bN as cubicBezierEasing, bO as decomposeRectPose, bP as describeRule, bQ as drawLayers, bR as drawOneLayer, bS as easeIn, bT as easeInBack, bU as easeInBounce, bV as easeInCirc, bW as easeInCubic, bX as easeInElastic, bY as easeInExpo, bZ as easeInOut, b_ as easeInOutBack, b$ as easeInOutBounce, c0 as easeInOutCirc, c1 as easeInOutCubic, c2 as easeInOutElastic, c3 as easeInOutExpo, c4 as easeInOutQuad, c5 as easeInOutQuart, c6 as easeInOutQuint, c7 as easeInOutSine, c8 as easeInQuad, c9 as easeInQuart, ca as easeInQuint, cb as easeInSine, cc as easeOut, cd as easeOutBack, ce as easeOutBounce, cf as easeOutCirc, cg as easeOutCubic, ch as easeOutElastic, ci as easeOutExpo, cj as easeOutQuad, ck as easeOutQuart, cl as easeOutQuint, cm as easeOutSine, cn as enterTextEditAction, co as evaluate, cp as evaluateEnabled, cq as isLayerPainted, cr as isLayerVisible, cs as linear, ct as rebaseLocalPose, cu as registerContentHandler, cv as resolveEasing, cw as resolveParams, cx as sliceAction, cy as specificity, cz as translateRectPose, cA as useAction, cB as useActionsRegistry, cC as useActiveToolContext, cD as useDecayLoop, cE as useDepRegistry, cF as useDepSource, cG as useOptionalActiveToolContext, cH as useOptionalDepRegistry, cI as usePointerContext, cJ as useSelection, cK as useViewAnimation, cL as worldPoseLookup } from './registry-DnoTWGED.js';
-import { Stroke, FillStyle, TextureHandle, TilePatternSpec, GradientKind, GradStop, GradientFill, GradientUnits, MarkerKey, MarkerRef } from '@weasel-js/paint';
+import { a as UnitValue, b as UnitSystem, c as Unit, U as UseMoveOptions, O as OriginProjection } from './grid-BrIa38gG.js';
+export { A as ANGLE_RADIANS, I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-BrIa38gG.js';
+import { View, NodeId, Bounds, ModifierState, PointerSessionCancelReason, DeviceProfile, Action, SelectionMode, SelectionExtendKey, SelectionApi, DepSchema, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1, ViewportToolDef as ViewportToolDef$1, HitShape, HandleKind, DebugSink, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, IngestItem, OngoingOverlay, ActionsProp, OverlayRole, ResizeAnchor } from '@weasel-js/routing';
+export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionPresentation, ActionsProp, ActionsRegistry, AffordanceHit, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DebugSink, DepName, DepSchema, DetectedDeviceFacts, DeviceProfile, Dispatcher, DispatcherContext, DragSample, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, MatchResult, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OverlayPosition, OverlayRole, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, ToolCtx, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, UiOngoingControl, View, actionBindings, buildRuleCtx, clientToCanvas, createDispatcher, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, mergeContributions, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
+import { FillStyle, Stroke, 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-H7o6MaPo.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-H7o6MaPo.js';
-import { B as Bounds, P as PoseProjection, V as ViewportDims } from './geometry-CHR36Ub_.js';
-export { F as FitViewToBoundsOptions, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-CHR36Ub_.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 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-BJqsTlXl.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-BJqsTlXl.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-D1bRdq-j.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-D1bRdq-j.js';
-import { ResolvedCursor, CursorSpec } from '@weasel-js/cursor';
-export { BakeOptions, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSpec, ResolvedCursor, bakeCursor, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
-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-CoVTbo_y.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-CoVTbo_y.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-JEV2c5If.js';
+import { D as DrawCommand, E as Effect, u as Scene, w as RectPose, x as InertiaConfig, y as ViewAnimationOptions, N as Node$1, z as PoseComposition, A as SliceDep, B as VertexColorChannel, f as ShaderProgramHandle, C as InsertExtras, F as SerializedScene, H as GeometryProjection, J as ContentHandlerEntry, K as SvgIngestOptions, L as PanBounds, O as Animator, Q as ColorOverrideRegistry, U as UseSceneOptions, X as SceneRegistry, Y as RegisteredOp, Z as PoseOverrides, _ as DerivedDep, $ as ViewportDims, P as PathDrawCommand, T as TextDrawCommand, a0 as ShaderProgram, c as Mat3$1, a1 as BooleansAdapter, a2 as UseAnimatorOptions, a3 as SpringPresetName, a4 as EasingSpec, a5 as AnimationHandle, a6 as SampledTrack } from './depSchema-nMqj_qTM.js';
+export { a7 as AddLayerSpec, a8 as AddNodeSpec, a9 as AnimateToBoundsOptions, aa as AreaSelectDep, ab as BezierEasing, ac as BooleanOp, ad as BooleanOpResult, ae as ClipboardDep, af as ClipboardIngestCtx, ag as ColorOverride, ah as ColorOverrideFn, ai as ContainerNode, aj as DecayLoopConfig, ak as DecayOptions, al as EASINGS, am as EasingFn, an as EasingName, ao as EditAnchorsDep, ap as EventBooking, aq as EventBookingHandle, ar as EventTrack, as as FitViewToBoundsOptions, G as GroupDrawCommand, at as IDENTITY_POSE_COMPOSITION, a as ImageDrawCommand, b as ImageMinification, au as IngestCtx, av as IngestionDep, aw as InsertDep, ax as Interpolate, ay as InterpolatorFactory, az as Keyframe, aA as LassoSelectDep, aB as LayerRecord, aC as LayoutDep, aD as LeafNode, aE as LoopFactory, aF as LoopOptions, aG as NestedTimeline, aH as NodeAtPointDep, aI as PhysicsHandle, aJ as PhysicsOptions, aK as PointerContextProvider, aL as PointerContextValue, aM as PointerWorldPos, aN as PoseAdapter, aO as PoseClosure, aP as PoseOverride, aQ as RECT_POSE_COMPOSITION, aR as RIGID_POSE_COMPOSITION, R as RenderTarget, aS as ResizePolicy, aT as SPRING_PRESETS, S as SPRITE_STRIDE, aU as SerializedNode, e as ShaderDrawCommand, g as ShaderUniform, aV as SnapDep, aW as SpringOptions, aX as SpringPreset, i as SpriteSheet, j as SpritesDrawCommand, aY as StaggerBuilder, aZ as StaggerDelay, a_ as StaggerFactory, a$ as StaggerOptions, b0 as StaggerPerItem, b1 as StaggerSpringPoseOptions, b2 as StaggerTweenOptions, b3 as SvgUnpacker, b4 as SystemLayerRecord, b5 as SystemLayerSpec, b6 as TextEditDep, b7 as TimelineClock, b8 as TimelineEvent, b9 as TimelineHandle, ba as TimelineOptions, bb as TimelineTrack, bc as Track, bd as TweenLoopOptions, be as TweenOptions, bf as UserLayerRecord, bg as VIEW_ANIMATION_KEY, bh as ViewAnimationApi, bi as ViewApi, bj as ViewChannel, bk as applyBooleanOp, bl as asNodeId, m as blur, bm as composeRectPose, bn as composeRigidPose, bo as composeWorldPose, bp as cubicBezierEasing, bq as decomposeRectPose, br as decomposeRigidPose, bs as easeIn, bt as easeInBack, bu as easeInBounce, bv as easeInCirc, bw as easeInCubic, bx as easeInElastic, by as easeInExpo, bz as easeInOut, bA as easeInOutBack, bB as easeInOutBounce, bC as easeInOutCirc, bD as easeInOutCubic, bE as easeInOutElastic, bF as easeInOutExpo, bG as easeInOutQuad, bH as easeInOutQuart, bI as easeInOutQuint, bJ as easeInOutSine, bK as easeInQuad, bL as easeInQuart, bM as easeInQuint, bN as easeInSine, bO as easeOut, bP as easeOutBack, bQ as easeOutBounce, bR as easeOutCirc, bS as easeOutCubic, bT as easeOutElastic, bU as easeOutExpo, bV as easeOutQuad, bW as easeOutQuart, bX as easeOutQuint, bY as easeOutSine, bZ as fitViewToBounds, o as frameRect, b_ as linear, p as mat3, b$ as rebaseLocalPose, c0 as registerContentHandler, r as registerEffect, c1 as resolveEasing, c2 as resolveStrokeWidth, c3 as translateRectPose, c4 as useDecayLoop, c5 as usePointerContext, c6 as useViewAnimation, v as viewToMat3, s as vignette, c7 as worldPoseLookup } from './depSchema-nMqj_qTM.js';
+import { CursorSpec, PaintedCursorState } from '@weasel-js/cursor';
+export { BakeOptions, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSpec, PaintedCursor, PaintedCursorFrame, PaintedCursorState, ResolvedCursor, bakeCursor, createPaintedCursorState, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
+import { ClaimableGesture, GestureSpec } from '@weasel-js/gestures';
+export { ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, TargetSpec, WheelSpec } from '@weasel-js/gestures';
+import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1 } from '@weasel-js/routing/react';
+export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, DepRegistry, DepRegistryProvider, UseGestureDispatcherOptions, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry } from '@weasel-js/routing/react';
+import { B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, R as RotateBehavior, S as SnapStrategy, M as MoveBehavior, I as InsertBehavior } from './types-DMyo7dnM.js';
+export { A as ActionBehavior, b as AreaSelectOverlay, c as BehaviorMoveResult, d as BehaviorResult, C as CloneBehavior, e as CloneLayer, f as ClonePose, G as GestureContext, g as GroupTransform, h as InsertMoveResult, i as InsertOverlay, j as InsertPoint, k as InsertProposed, l as LassoSelectMoveResult, m as LassoSelectOverlay, n as LassoSelectPose, o as LassoSelectProposed, p as PointSnapContext, a as PointSnapFrame, q as PointSnapResult, r as PointerState, s as ResizeMoveResult, t as ResizeOverlay, u as ResizeProposed, v as RotateMoveResult, w as RotateOverlay, x as RotateProposed } from './types-DMyo7dnM.js';
+import { P as PoseDescriptor, c as PolygonPath, a as Path, d as RotatedPose, e as PathFillRule, f as RectPath } from './poseDescriptor-CGOgIgf8.js';
+export { R as RECT_POSE_DESCRIPTOR, b as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-CGOgIgf8.js';
+import { U as UseResizeOptions } from './autoPoseDescriptor-CvjflWJK.js';
+export { A as AUTO_POSE_DESCRIPTOR, C as CORNER_ANCHORS, a as CornerAnchor, g as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, i as isPathLike, e as isRectPose, p as pointSnapToGrid } from './autoPoseDescriptor-CvjflWJK.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-DtjCJA5r.js';
+export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DtjCJA5r.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { D as DrawCommand, b as ShaderProgramHandle, P as PathDrawCommand, M as Mat3$1 } from './DrawCommand-CD-ug3d9.js';
-export { E as Effect, G as GroupDrawCommand, I as ImageDrawCommand, S as SPRITE_STRIDE, a as ShaderDrawCommand, c as ShaderUniform, e as SpritesDrawCommand, T as TextDrawCommand, m as mat3, r as registerEffect } from './DrawCommand-CD-ug3d9.js';
 import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
 import { PlacementAlign, 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';
+export { DEFAULT_FLATTEN_TOLERANCE, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Rect, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pathCommandCoordCount } 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 { i as ShaderProgram } from './builtins-CtGORLCG.js';
-export { a as ImageMinification, R as RenderTarget, b as SpriteSheet, e as blur, g as frameRect, r as resolveStrokeWidth, v as viewToMat3, h as vignette } from './builtins-CtGORLCG.js';
+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, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextVerticalAlign, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, layoutTextPose, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, textPoseLayoutInput, toRuns, verticalAlignOffset } from '@weasel-js/text';
 import { G as Guide } from './types-D2tTKEU0.js';
-export { U as UseInsertOptions } from './options-DYfUlZxk.js';
+export { U as UseInsertOptions } from './options-BDyCnrp8.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 { 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';
 
 /**
  * The kit version a build was compiled from, so an app can report what it is
@@ -67,6 +59,20 @@ declare const VERSION: string;
 /** Round `value` to the nearest multiple of `cellSize`. Returns 0 when the result would be -0. */
 declare function roundToCell(value: number, cellSize: number): number;
 
+/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
+interface ViewTransform {
+    panX: number;
+    panY: number;
+    zoom: {
+        x: number;
+        y: number;
+    };
+}
+/** Project a world-space point to screen-space pixels through a `ViewTransform`. */
+declare function worldToScreen(worldX: number, worldY: number, view: ViewTransform): [number, number];
+/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */
+declare function screenToWorld(screenX: number, screenY: number, view: ViewTransform): [number, number];
+
 /**
  * Pointer-tracking glue that turns hover position into a grid cell, suitable
  * for dropping straight into `createCellHighlightLayer({ getCell })`. Pairs
@@ -125,6 +131,524 @@ interface UseGridCellHoverReturn {
 /** Track which grid cell the pointer is over; pairs with `createCellHighlightLayer`. */
 declare function useGridCellHover(opts: UseGridCellHoverOptions): UseGridCellHoverReturn;
 
+/**
+ * Input convenience for zoom primitives. A `number` is treated as a
+ * uniform factor applied to both axes; a `{x, y}` vector applies
+ * per-axis factors.
+ */
+type ZoomFactor = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Input convenience for zoom-clamp ranges. A `number` is applied as the
+ * same bound on both axes; a `{x, y}` vector applies per-axis bounds.
+ */
+type ZoomBound = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep
+ * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`
+ * use opposite sign conventions for the translation half (`view.x` is
+ * camera position; `panX` is canvas translation), so the adapter flips
+ * the sign and multiplies by per-axis scale.
+ */
+declare function viewToTransform(view: View): ViewTransform;
+/**
+ * How far `view` is zoomed in, as one number — the geometric mean of its two
+ * axes, so a uniform view reports its own scale and a stretched one reports
+ * the scale that covers the same area.
+ *
+ * What a `RuleCtx` carries, because the only rule that asks about the
+ * viewport asks for a threshold rather than a camera.
+ */
+declare function viewZoom(view: View): number;
+/**
+ * `view` inside the invariant {@link View} documents: a zero or non-finite
+ * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a
+ * non-finite translation becomes 0. Returns `view` itself when it already
+ * holds, so a valid view keeps its identity.
+ */
+declare function normalizeView(view: View): View;
+
+interface ChromeState {
+    /** Currently selected ids. Live; reflects useSelection's React state. */
+    readonly selection: readonly NodeId[];
+    /** True when the canvas is in multi-mode AND >= 2 ids are selected. */
+    readonly multiActive: boolean;
+    /** Bounds for any selection member id. Honors active-tool overlay state
+     *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed
+     *  pose bounds). Returns null for unknown ids or ids whose bounds aren't
+     *  computable. */
+    boundsOf(id: string): Bounds | null;
+    /** Multi-union AABB when `multiActive`. Computed lazily from `boundsOf`
+     *  over every selected id, expanding rotated members to the extent of
+     *  their ink; null otherwise. */
+    readonly unionBounds: Bounds | null;
+    /** Active modifier state at the moment of the call. */
+    readonly modifiers: ModifierState;
+    /** True iff the node's pose-descriptor declares it can carry a rotation.
+     *  Affordances consult this to decide whether to expose rotate cursors /
+     *  drag-bands. Defaults to `true` when the descriptor doesn't declare
+     *  (back-compat) or when the id is unknown — the rotation gesture will
+     *  no-op visually for poses without AABB fields, but the affordance
+     *  doesn't lie about the cursor. Optional on the interface so unit-test
+     *  call sites that construct `ChromeState` by hand keep compiling;
+     *  affordances should treat an absent predicate as "true". */
+    canRotate?(id: string): boolean;
+}
+
+/**
+ * @experimental
+ * A single interactive piece of chrome. Pure functions; the kit composes
+ * multiple affordances into a single RenderLayer per tool via
+ * `composeAffordanceLayer`.
+ *
+ * Affordances declare interactive regions in a target's *local* frame.
+ * The framework (`composeAffordanceLayer`) composes the target's bounds
+ * transform (rotation around the AABB center, when present) for both paint
+ * and hit-test, so the affordance never touches rotation, view.scale, or
+ * world↔screen math.
+ */
+interface Affordance {
+    /** Stable id for debug overlays + visibility maps. */
+    id: string;
+    /** Enumerate this affordance's interactive regions. Each region lives in
+     *  some target id's local frame (or in the world frame when `targetId`
+     *  is `null`). Returning `[]` means "no chrome for this state" (no
+     *  selection, multi-mode disabled, etc.). */
+    regions(state: ChromeState): readonly AffordanceRegion[];
+    /** Optional non-interactive decoration (e.g., a leader line drawn from
+     *  a bounds edge to a handle — visual only, not draggable). Receives
+     *  raw state + view because the decoration may live outside any single
+     *  target's local frame. Most affordances leave this undefined. */
+    decorate?(state: ChromeState, view: View): DrawCommand[];
+}
+/**
+ * @experimental
+ * One interactive region produced by an affordance. The framework owns
+ * the local↔world transform for `targetId` (when non-null), so `shape`,
+ * `paint.sizePx`, and `hitRadiusPx` are always specified in coordinates
+ * the affordance can reason about directly.
+ */
+interface AffordanceRegion<TScratch = unknown> {
+    /** Stable id, e.g. `corner-min-min`. Used for debug overlays + a11y. */
+    id: string;
+    /** Target id whose `state.boundsOf(targetId)` defines this region's
+     *  local frame. `bounds.rotation` (if present) is the only transform
+     *  applied — translation is the AABB origin; scale is identity. Pass
+     *  `null` for affordances anchored to the viewport / world frame
+     *  (identity transform). */
+    targetId: string | null;
+    /** Region geometry, expressed in the target's local frame.
+     *
+     *  - `point` — circular hit (`hitRadiusPx` is screen-space).
+     *  - `rect`  — axis-aligned rect (target rotation applies).
+     *  - `annulus` — outer ellipse minus inner rect cutout. Used for
+     *    invisible zones that sit *around* the AABB (e.g. rotate-on-
+     *    hover band). The outer ellipse is defined by world-space
+     *    semi-axes `rx` / `ry` around `(cx, cy)`; the inner rect is the
+     *    same target-local rect that defines the AABB. Hit-test:
+     *    inside outer ellipse AND outside inner rect. */
+    shape: {
+        kind: 'point';
+        x: number;
+        y: number;
+        hitRadiusPx: number;
+    } | {
+        kind: 'rect';
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | {
+        kind: 'annulus';
+        /** Outer-ellipse center (target-local). */
+        cx: number;
+        cy: number;
+        /** Outer-ellipse semi-axes (target-local). */
+        rx: number;
+        ry: number;
+        /** Inner rect (target-local) — the cutout. Typically the
+         *  selection's AABB. */
+        innerX: number;
+        innerY: number;
+        innerWidth: number;
+        innerHeight: number;
+        /** Minimum band thickness outside the inner rect, in **screen**
+         *  pixels. The framework widens `rx`/`ry` to at least
+         *  `innerHalfExtent + minBandPx / meanScale(view.scale)` for both
+         *  paint and hit-test.
+         *
+         *  This exists because the clamp has to know the view and the
+         *  affordance doesn't: `ChromeState` carries no scale. Expressing the
+         *  floor in world units instead (which is what the rotate ring used
+         *  to do) makes the band shrink on screen as you zoom in, until the
+         *  ring around a small shape is too thin to hover. */
+        minBandPx?: number;
+    };
+    /** Optional paint. World position is derived from `shape` + target
+     *  transform; visual size stays in screen pixels (so handles don't
+     *  warp under zoom or non-uniform scale). Omit for hit-only regions.
+     *
+     *  - `square` — small fixed-size square (only valid over `point` shapes).
+     *  - `annulus` — fill + stroke the annulus ring (only valid over
+     *    `annulus` shapes). Uses even-odd fill rule to punch the inner-rect
+     *    cutout.
+     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
+    paint?: {
+        kind: 'square';
+        sizePx: number;
+        fill?: FillStyle;
+        stroke?: Stroke;
+    } | {
+        kind: 'annulus';
+        fill?: FillStyle;
+        stroke?: Stroke;
+        insetPx?: number;
+    } | {
+        kind: 'custom';
+        draw: (ctx: CustomPaintContext) => DrawCommand[];
+    };
+    /** Discriminator a press on this region reports as `AffordanceHit.kind` —
+     *  the string routing specs match on (`'handle:top-left'`,
+     *  `'rotate-handle'`, `'anchor:3'`). Omit for regions that only exist
+     *  inside a consumer-registered layer, where the layer id is the
+     *  discriminator; `buildAffordanceAt` falls back to
+     *  `<affordanceId>:<regionId>`. */
+    hitKind?: string;
+    /** Cursor to show while hovering this region. Read by the hover-cursor
+     *  pump in `useGestureDispatcher` via `AffordanceHit.cursor`, which
+     *  `buildAffordanceAt` fills in from the region the walk landed on. */
+    cursor?: CursorSpec;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Read only when the affordance is composed into a
+     *  consumer-registered layer; kit chrome routes through
+     *  `buildAffordanceAt`, which reports `'shared'`. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+    /** Drag binding produced when this region is hit. Lazily called so
+     *  affordances don't pay binding-construction cost on every paint frame —
+     *  state snapshots (e.g., capturing per-leaf poses at click time) belong
+     *  inside `bind()`, not inside `regions()`. */
+    bind(): AffordanceBinding<TScratch>;
+}
+/** Context passed to a region's `paint.kind === 'custom'` draw callback.
+ *  Provides both the world-space anchor (already transformed) and the
+ *  original local shape, for affordances that want to do additional
+ *  geometry themselves. */
+interface CustomPaintContext {
+    /** World-space mapping of `shape`. For `point`, only `x`/`y` are set.
+     *  For `rect`, all four fields are set. */
+    world: {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    /** The original local shape (same object identity as `region.shape`). */
+    local: AffordanceRegion['shape'];
+    view: View;
+    state: ChromeState;
+}
+/**
+ * @experimental
+ * Result of an affordance hit — what the region computed about itself.
+ *
+ * `initialScratch` is the payload: what the region already knows (which
+ * corner, which target id) so the action that picks up the drag doesn't
+ * re-derive it. `<SceneCanvas>` reads it out of the layer hit-test and packs
+ * it into `AffordanceHit`, which flows to the matching action through
+ * `InvocationCtx.drag.affordance`.
+ *
+ * This used to also carry a `drag: DragChannel` naming the handlers the
+ * tool-routing dispatcher should wire up. Every implementation supplied a
+ * no-op stub that claimed, because the real routing had already moved to
+ * bindings; the field went with that dispatcher.
+ */
+interface AffordanceBinding<TScratch = unknown> {
+    initialScratch?: TScratch;
+}
+/**
+ * The fields `buildAffordanceAt` lifts out of a region's `initialScratch`
+ * when it turns a region hit into an `AffordanceHit`.
+ *
+ * Scratch is otherwise opaque — whatever the affordance wants to hand the
+ * action that picks up the drag. These few names are the exception: they mean
+ * the same thing to every affordance, and the actions that consume them
+ * (`resizeAction`, `rotateAction`) read them off `AffordanceHit` rather than
+ * out of scratch. An affordance that doesn't set them simply produces a hit
+ * without those fields.
+ */
+interface CommonAffordanceScratch {
+    /** The node (or `MULTI_RESIZE_TARGET_ID`) this chrome acts on. Becomes
+     *  `AffordanceHit.targetIds`. */
+    targetId?: string;
+    /** For resize chrome: which corner stays pinned. Mirrors the kit's
+     *  `ResizeAnchor`, spelled inline so `affordances/` doesn't take a type
+     *  dependency on the gesture layer for one field. */
+    anchor?: {
+        x: 'min' | 'max' | 'free';
+        y: 'min' | 'max' | 'free';
+    };
+    /** World-space invariant point of the transform — the fixed corner for a
+     *  resize, the pivot for a rotation. */
+    fixedPoint?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
+ * so existing implementations keep typechecking; the added fields are how a
+ * consumer's own chrome says the things kit chrome says through
+ * `AffordanceRegion` — which cursor to show, and whether it owns the point
+ * outright.
+ */
+interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
+    /** Cursor while the pointer is over this hit. Reaches the hover-cursor
+     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
+    cursor?: CursorSpec;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
+     *  meaning as `AffordanceHit.strength`, which it becomes. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+}
+
+/**
+ * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
+ * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
+ * supplies it explicitly so layers don't have to know about DPR.
+ */
+interface Dims {
+    width: number;
+    height: number;
+}
+/**
+ * What a layer's `draw` threw, and which layer threw it.
+ *
+ * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an
+ * uncaught `requestAnimationFrame` error on the window and takes the whole
+ * frame with it — every other layer included. One broken layer painting
+ * nothing, named in the console, is the lesser wrong.
+ */
+interface LayerDrawFailure {
+    layerId: string;
+    error: unknown;
+}
+/**
+ * Several consecutive layers composited as one.
+ *
+ * A layer's own `effects` run over that layer alone, which is the wrong
+ * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not
+ * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A
+ * group draws its members into one buffer, runs one chain over it, and
+ * composites the result back once.
+ *
+ * Membership is by `RenderLayer.id` — the same names `layerOrder` and
+ * `layerVisibility` use, not the `layers` map's slot keys.
+ *
+ * Only *consecutive* members share a buffer, because anything drawn between
+ * two members has to land between them. A group whose members are separated in
+ * the render order is drawn as one bracket per run, with a warning: the
+ * picture is right, the declaration almost certainly is not.
+ *
+ * This is a render-stack bracket, not a scene `ContainerNode` — it holds no
+ * ids, survives no reload, and nothing in the scene knows about it.
+ */
+interface LayerGroup {
+    /** Names the group in warnings; not a layer id and never drawn. */
+    id: string;
+    /** Member layer ids. Order here is ignored — the render order decides. */
+    layers: readonly string[];
+    /**
+     * Passes over the group's combined pixels, in order. A thunk is re-read on
+     * every frame, so an animating radius costs no React render; an array is
+     * read once per frame either way.
+     */
+    effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);
+    /** Opacity applied to the group's composited result, not to each member. */
+    alpha?: number;
+    /** 4×5 color matrix (row-major, 20 numbers) applied to the composited
+     *  result. See `GroupDrawCommand.colorMatrix`. */
+    colorMatrix?: number[];
+}
+/** One layer's memoized output, keyed by layer id. Owned by the canvas that
+ *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */
+type LayerCommandCache = Map<string, {
+    deps: readonly unknown[];
+    cmds: DrawCommand[];
+}>;
+/**
+ * A single named render sub-layer within a canvas renderer.
+ *
+ * @template TData - The data object passed to each draw call.
+ */
+interface RenderLayer<TData> {
+    /** Unique identifier used in visibility maps and ordering arrays. When a
+     *  cache is in use, an id must identify the same logical layer across
+     *  frames — reusing it for a different layer can serve cross-layer commands. */
+    id: string;
+    /** Human-readable name for UI toggles. */
+    label: string;
+    /**
+     * Emit a DrawCommand tree for the GL backend to dispatch.
+     *
+     * For world-space layers (the default), emit commands in WORLD COORDS —
+     * `drawLayers` automatically wraps them in `{ kind: 'group', transform:
+     * viewToMat3(view), ... }` before handing them to the renderer. Do NOT
+     * apply the view transform yourself.
+     *
+     * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel
+     * coords directly; `drawLayers` passes them through unchanged. If part
+     * of a screen-space layer's output needs to track the view, wrap that
+     * subset manually with `viewToMat3(view)`.
+     */
+    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
+    /**
+     * Optional cache key. When present and a `LayerCommandCache` is supplied to
+     * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as
+     * every entry is `Object.is`-equal to the previous call's. A layer with no
+     * `deps` rebuilds on every frame.
+     *
+     * **The returned commands must be treated as immutable.** A cached tree is
+     * handed to the renderer again on later frames, so mutating a tree you
+     * previously returned corrupts the cache silently rather than erroring.
+     *
+     * **Screen-space layers are not protected against a stale `view`/`dims`
+     * the way world-space layers are** (see `space` below) — include them in
+     * `deps` if `draw` reads them.
+     */
+    deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];
+    /**
+     * Whether the layer is shown when no explicit visibility entry exists.
+     * Defaults to `true` when absent.
+     */
+    defaultVisible?: boolean;
+    /**
+     * When true, the layer is always drawn regardless of the visibility map.
+     * Useful for layers that must never be hidden (e.g. base grid).
+     */
+    alwaysOn?: boolean;
+    /**
+     * Coordinate space the layer draws in.
+     *
+     * - `'world'` (default): the layer's `draw` returns world-space commands;
+     *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`
+     *   automatically.
+     * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)
+     *   commands; `drawLayers` passes them through unchanged. World-anchored
+     *   chrome inside a screen-space layer must call `worldToScreen` or wrap
+     *   the relevant subset with `viewToMat3(view)` manually.
+     */
+    space?: 'world' | 'screen';
+    /**
+     * Full-screen passes run over this layer's own pixels before it joins the
+     * frame — a blur here blurs the world and leaves the HUD drawn above it
+     * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.
+     *
+     * Costs nothing while empty: the renderer allocates no offscreen buffer
+     * until a layer actually declares one. See `GroupDrawCommand.effects` for
+     * what a pass may read, and {@link LayerGroup} to run one chain over
+     * several layers at once instead of one chain each.
+     */
+    effects?: readonly Effect[];
+    /**
+     * Optional hit-test for **consumer-attached** layers.
+     *
+     * Only layers registered through `CanvasExtensionApi.registerLayer` are
+     * hit-tested: `hitTestExtras` walks them last-registered-first on
+     * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`
+     * thunk ahead of the kit's own selection chrome. First non-null result
+     * wins; null means "I don't claim this hit, try the next layer."
+     *
+     * Layers that reach the draw stack some other way — a `Tool.overlay`, an
+     * entry in the `layers` map — are painted but never hit-tested, so defining
+     * `hitTest` on one has no effect. (The kit's own chrome doesn't need it: it
+     * goes through `buildAffordanceAt`.)
+     *
+     * Coordinates are world-space. The `data` arg is the layer's
+     * configured data slot (same as `draw`); `view` and `dims` mirror
+     * `draw`'s arguments.
+     */
+    hitTest?: (worldX: number, worldY: number, data: TData, view: View, dims: Dims, 
+    /** Chrome-caps visibility predicate. When supplied, the layer must
+     *  not return a hit from any chrome element whose id reports
+     *  `false`. Absent → every element is hittable. */
+    isVisible?: (id: string) => boolean) => LayerHit | null;
+    /**
+     * Called on every pointermove when no gesture is currently captured.
+     * Lets layers (e.g. HUD widgets) track hover state without participating
+     * in the drag pipeline. Coords are world-space; the layer is responsible
+     * for any further conversion (e.g. world→screen for screen-space layers)
+     * and for its own throttling.
+     */
+    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
+    /**
+     * Called when the cursor leaves the canvas element. Lets layers clear
+     * any hover state they're holding.
+     */
+    onUncapturedLeave?: () => void;
+}
+/**
+ * Walk visible layers and concatenate their emitted DrawCommand arrays into
+ * one flat list, ready to feed to `WeaselRenderer.render(commands)`.
+ *
+ * Visibility resolution order:
+ *   1. `alwaysOn` — always drawn, ignores visibility map.
+ *   2. Explicit entry in `visibility` map — overrides default.
+ *   3. `layer.defaultVisible` — falls back to `true` when absent.
+ *
+ * Transform composition: world-space layers (the default; `space` unset or
+ * `'world'`) have their commands wrapped in a `kind: 'group'` with
+ * `viewToMat3(view)` before they reach the renderer. Screen-space layers
+ * (`space: 'screen'`) pass through unchanged.
+ *
+ * A layer whose `draw` throws is dropped for the frame and reported through
+ * `onLayerError` — the rest of the frame still paints.
+ *
+ * `groups` brackets runs of consecutive layers so they composite as one — see
+ * `LayerGroup`. A layer named by no group is emitted exactly as it was before
+ * groups existed, and a frame that declares none allocates nothing.
+ */
+declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[]): DrawCommand[];
+/**
+ * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
+ * `visibility`, then `defaultVisible`, defaulting to shown.
+ */
+declare function isLayerVisible<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>): boolean;
+/**
+ * Does this layer reach the screen at all — both gates, in the order
+ * `drawLayers` applies them.
+ *
+ * **A listed `order` is the whole list**, so omission from it drops a layer
+ * that `visibility` would have shown, and `alwaysOn` does not rescue it.
+ * Hit-testing asks this, not `isLayerVisible`: a layer that is not painted
+ * but still claims pointer events is a pointer landing on nothing the user
+ * can see.
+ */
+declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: string[] | undefined): boolean;
+/**
+ * Draw one layer and put its commands in the space its `space` declares:
+ * world-space output wrapped in a `viewToMat3(view)` group, screen-space
+ * output passed through.
+ *
+ * Anything rendering layers through a view — the canvas itself, a viewport
+ * node's inner pass — goes through here. A second copy of this rule that
+ * forgets the wrap draws world content at raw world coords, which looks
+ * plausible at the identity view and wrong everywhere else.
+ *
+ * A `draw` that throws yields no commands, and `onLayerError` is told which
+ * layer it was. The layer's cache entry goes with it, so the next frame is a
+ * real re-attempt rather than a stale tree served under fresh deps.
+ */
+declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
+
 /**
  * Grid overlay — a reusable render layer that draws a world-space grid with
  * optional finer subdivisions and accent lines every N cells.
@@ -264,6 +788,12 @@ interface CreateViewResolverOpts {
         left: number;
         top: number;
     };
+    /**
+     * Whether something painted over every view claims a canvas-local point —
+     * chrome on the surface's own frame. Such a point resolves to the root even
+     * inside a view's rect. Asked only where a view would otherwise win.
+     */
+    occluded?: (x: number, y: number) => boolean;
 }
 declare function createViewResolver(opts: CreateViewResolverOpts): ViewResolver;
 
@@ -484,23 +1014,9 @@ interface SimulationForce<TNode extends SimulationNode = SimulationNode> {
     (alpha: number): void;
     initialize?(nodes: TNode[], random?: () => number): void;
 }
-/** Options for `useSimulation`: the nodes to move, the forces acting on them,
- *  and the cooling schedule that decides when the simulation settles. */
-interface UseSimulationOptions<TNode extends SimulationNode> {
-    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
-    nodes: TNode[];
-    /** Forces applied per tick. Each may implement `initialize` for setup. */
-    forces?: SimulationForce<TNode>[];
-    /** Initial alpha. Default 1. */
-    alpha?: number;
-    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
-    alphaMin?: number;
-    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
-    alphaDecay?: number;
-    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
-    alphaTarget?: number;
-    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
-    velocityDecay?: number;
+/** Options for `useSimulation`: everything {@link SimulationOptions} carries,
+ *  plus the loop's own callbacks and clock. */
+interface UseSimulationOptions<TNode extends SimulationNode> extends SimulationOptions<TNode> {
     /** Fired after each integration step. */
     onTick?: (nodes: TNode[]) => void;
     /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */
@@ -510,7 +1026,7 @@ interface UseSimulationOptions<TNode extends SimulationNode> {
     cancelFrame?: (handle: number) => void;
 }
 /**
- * A running force simulation over a set of nodes.
+ * A force simulation over a set of nodes, with no clock of its own.
  *
  * Each tick applies every force and then integrates velocities, scaled by
  * `alpha` — a temperature that decays toward `alphaTarget` so the layout
@@ -518,8 +1034,12 @@ interface UseSimulationOptions<TNode extends SimulationNode> {
  * which is what a drag does.
  *
  * Nodes are mutated in place; the simulation holds the array, not a copy.
+ *
+ * Nothing here advances time. {@link Simulation} adds the frame loop; a caller
+ * that wants the whole relaxation at once — a layout pass, a pre-warm, a test
+ * — drives {@link SimulationCore.tick} itself.
  */
-interface Simulation<TNode extends SimulationNode> {
+interface SimulationCore<TNode extends SimulationNode> {
     readonly nodes: TNode[];
     setNodes(nodes: TNode[]): this;
     setForces(forces: SimulationForce<TNode>[]): this;
@@ -533,10 +1053,6 @@ interface Simulation<TNode extends SimulationNode> {
     alphaMin(value: number): this;
     velocityDecay(): number;
     velocityDecay(value: number): this;
-    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
-    restart(): this;
-    /** Cancel the RAF loop. Does not change alpha. */
-    stop(): this;
     /**
      * Run the tick body synchronously `iterations` times. Does NOT fire
      * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.
@@ -544,6 +1060,34 @@ interface Simulation<TNode extends SimulationNode> {
     tick(iterations?: number): this;
     isSettled(): boolean;
 }
+/** A {@link SimulationCore} running on a frame loop. */
+interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {
+    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
+    restart(): this;
+    /** Cancel the RAF loop. Does not change alpha. */
+    stop(): this;
+}
+/** What {@link SimulationCore} needs: the nodes, the forces acting on them,
+ *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */
+interface SimulationOptions<TNode extends SimulationNode> {
+    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
+    nodes: TNode[];
+    /** Forces applied per tick. Each may implement `initialize` for setup. */
+    forces?: SimulationForce<TNode>[];
+    /** Initial alpha. Default 1. */
+    alpha?: number;
+    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
+    alphaMin?: number;
+    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
+    alphaDecay?: number;
+    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
+    alphaTarget?: number;
+    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
+    velocityDecay?: number;
+    /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded
+     *  source to make a run reproducible. */
+    random?: () => number;
+}
 /** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */
 declare const DEFAULT_ALPHA_DECAY: number;
 /** Alpha below which a cooling simulation is considered settled. */
@@ -553,9 +1097,24 @@ declare const DEFAULT_ALPHA_MIN = 0.001;
 declare const DEFAULT_VELOCITY_DECAY = 0.4;
 
 /**
- * Continuous N-body simulation primitive. Owns a RAF loop and a velocity-Verlet
- * integrator; forces are pluggable functions matching d3-force's protocol so
- * d3-force's bundled forces work without translation.
+ * The integrator, with no clock attached.
+ *
+ * Velocity-Verlet over a pluggable force list, contract-compatible with
+ * d3-force so d3's own bundled forces drop in untranslated. Nothing here
+ * advances time: `tick()` is the only thing that moves a node, and the caller
+ * decides how often to call it. `useSimulation` calls it once a frame; a
+ * layout pass calls it a few hundred times in one go and reads the result.
+ *
+ * Splitting it out is what lets a *pure* function run a relaxation — a React
+ * hook cannot, and the alternative was a second integrator drifting away from
+ * this one.
+ */
+
+declare function createSimulation<TNode extends SimulationNode>(opts: SimulationOptions<TNode>): SimulationCore<TNode>;
+
+/**
+ * Continuous N-body simulation primitive: `createSimulation`'s integrator on a
+ * frame loop.
  *
  * The kit is adapter-agnostic — `onTick(nodes)` fires after each integration
  * step and the consumer decides how (and whether) to write through to scene
@@ -564,6 +1123,47 @@ declare const DEFAULT_VELOCITY_DECAY = 0.4;
  */
 declare function useSimulation<TNode extends SimulationNode>(opts: UseSimulationOptions<TNode>): Simulation<TNode>;
 
+/** What a producer is told before it is asked for a frame. */
+interface PoseRunCtx<TPose> {
+    /** Nodes another gesture is moving, and the pose each is drawn at. The run
+     *  will not write these, so a producer holds them fixed. */
+    pinned: ReadonlyMap<NodeId, TPose>;
+    /** Frames this run has produced, starting at 0. */
+    frame: number;
+}
+/** One frame of a run. */
+interface PoseRunStep<TPose> {
+    /** Where the nodes it drives are this frame — the whole picture, not a
+     *  delta. An id the frame omits stops being published, which is how a node
+     *  leaves the run's hands: a producer that drops a grabbed box and its rows
+     *  from one frame has released them by the next. */
+    poses: Iterable<readonly [NodeId, TPose]>;
+    /** Whether the run is finished. The frame is published either way, and a
+     *  finished run commits. */
+    done: boolean;
+}
+interface UsePoseRunOptions<TPose> {
+    scene: Scene<unknown, string, TPose>;
+    step: (ctx: PoseRunCtx<TPose>) => PoseRunStep<TPose>;
+    /** The undo entry's name. Default `'Layout'`. */
+    label?: string;
+    /** How many nodes the commit wrote. Fires after the ops land. */
+    onCommit?: (moved: number) => void;
+    /** Clock injection, for tests. Defaults to `requestAnimationFrame`. */
+    requestFrame?: (cb: (t: number) => void) => number;
+    cancelFrame?: (handle: number) => void;
+}
+interface PoseRun {
+    /** Begin, or continue where a `stop` left off. Idempotent while running. */
+    start(): void;
+    /** Finish now: commit what is published, then drop the overrides. */
+    stop(): void;
+    /** Abandon: drop the overrides and write nothing, like a canceled drag. */
+    cancel(): void;
+    isRunning(): boolean;
+}
+declare function usePoseRun<TPose>(opts: UsePoseRunOptions<TPose>): PoseRun;
+
 /**
  * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one
  * scene node needs: the node's world box, the projection from that box's
@@ -600,7 +1200,8 @@ interface NodeOverlayFrame {
     };
     /** Node box frame → overlay pixels, rotation and view included. */
     toScreen: (p: OverlayPoint) => OverlayPoint;
-    /** Overlay pixels → node box frame. Inverts `toScreen`. */
+    /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view
+     *  flattens an axis, it keeps the last mapping that had an inverse. */
     toLocal: (p: OverlayPoint) => OverlayPoint;
     /** The container's size in CSS pixels — the overlay's own box. */
     width: number;
@@ -820,7 +1421,8 @@ interface Scale2 {
     x: number;
     y: number;
 }
-/** One screen-pixel length as world-space extents, per axis. */
+/** One screen-pixel length as world-space extents, per axis. `scale` is a
+ *  view's, so neither axis is zero (see `View`). */
 declare function pxExtent(px: number, scale: Scale2): {
     x: number;
     y: number;
@@ -843,59 +1445,6 @@ declare function withinPxBox(dx: number, dy: number, px: number, scale: Scale2):
 /** Is a world-space delta inside a screen-space circle of radius `px`? */
 declare function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean;
 
-/**
- * The DOM half of a drag: one pointer, held down, from press to release.
- *
- * Every pointerdown-to-pointerup lifecycle in the kit used to answer capture,
- * pointer identity, teardown and lost-pointer recovery for itself, and each
- * answered them differently. This is the one place those are decided; anything
- * above it — thresholds, coordinate spaces, what the drag *means* — belongs to
- * its caller.
- */
-/** Why a session ended without the pointer being released. */
-type PointerSessionCancelReason = 
-/** The browser cancelled the pointer (touch interrupted, palm rejection). */
-'pointercancel'
-/** The origin left the document mid-gesture, taking capture with it. */
- | 'lostcapture'
-/** `cancel()` — an unmount, a window blur, Escape, a consumer's own rule. */
- | 'aborted'
-/** A new press arrived on this pointer, so the tracked one had ended. */
- | 'superseded';
-interface PointerSessionCallbacks {
-    /** Every move belonging to this pointer, while it is still held. */
-    onMove?: (e: PointerEvent) => void;
-    /** The pointer was released. Fires once, before teardown completes. */
-    onEnd?: (e: PointerEvent) => void;
-    /** The session ended without a release. Fires once. */
-    onCancel?: (reason: PointerSessionCancelReason) => void;
-}
-interface PointerSessionOptions {
-    /** Ask the origin element to capture the pointer. Default `true`. Capture
-     *  keeps hover and click off everything the drag passes over; the session
-     *  does not depend on it to keep receiving events. */
-    capture?: boolean;
-}
-interface PointerSession {
-    readonly pointerId: number;
-    /** False once the session has ended, by any route. */
-    readonly active: boolean;
-    /** End the session now, reporting `'aborted'`. Idempotent. */
-    cancel: () => void;
-}
-/**
- * Open a session for the pointer that `down` belongs to.
- *
- * Listens on the origin's document rather than on the element: a captured
- * element that is removed mid-drag stops receiving events, and every listener
- * hung on it goes with it. Three recovery rules close the gaps a plain
- * pointerup/pointercancel pair leaves — losing capture cancels only once the
- * origin has left the document, a move reporting no held button is read as
- * the release that never arrived, and a fresh press on the same pointer says
- * the tracked one had already ended.
- */
-declare function openPointerSession(origin: Element, down: PointerEvent | React.PointerEvent, cb: PointerSessionCallbacks, opts?: PointerSessionOptions): PointerSession;
-
 /** A 2D point in the rect element's local coordinate space. */
 interface HandleDragPoint {
     x: number;
@@ -1049,33 +1598,6 @@ interface CanvasSizeSnapshot extends CanvasSize {
  *  query instead. */
 declare function useCanvasSize(containerRef: RefObject<HTMLElement | null>): CanvasSizeSnapshot;
 
-/**
- * Handle/hit multiplier applied on a coarse pointer.
- *
- * 8px handle → 14px; 24px rotation distance → 42px. Counting the
- * surrounding grab zone, that lands in the Apple HIG 44pt / Material 48dp
- * minimum-touch-target band. One constant so it is tunable in one place.
- */
-declare const COARSE_TARGET_SCALE = 1.75;
-/**
- * Fold consumer overrides over detected facts and derive `targetScale`.
- *
- * `targetScale` is re-derived AFTER the merge, so an override of
- * `coarsePointer` alone scales the chrome as expected. An explicit
- * `targetScale` override wins over the derivation.
- */
-declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?: Partial<DeviceProfile>): DeviceProfile;
-/**
- * Assumed when `matchMedia` is unavailable (SSR, jsdom) and used as the
- * absent-means value for `RuleCtx.device`.
- *
- * Derived from `resolveDeviceProfile` rather than hand-written, so it can
- * never drift from what the function would compute for the same facts. A
- * mouse-like device is the safe default: it is what the kit has always
- * assumed, so an absent profile changes nothing for existing consumers.
- */
-declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
-
 /**
  * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`, and the
  * one accessor that resolves them for a live pointer type.
@@ -1149,7 +1671,7 @@ interface ZoomClampOpts {
     min?: ZoomBound;
     max?: ZoomBound;
 }
-declare function zoomAt(view: View, anchor: {
+declare function zoomAt(input: View, anchor: {
     x: number;
     y: number;
 }, factor: ZoomFactor, opts?: ZoomClampOpts): View;
@@ -1165,6 +1687,23 @@ declare function zoomAt(view: View, anchor: {
  */
 declare const DEFAULT_MIN_ZOOM = 0.1;
 declare const DEFAULT_MAX_ZOOM = 8;
+/**
+ * The smallest zoom magnitude a view can hold, in `View.scale` units.
+ *
+ * A view's zoom is always finite and at least this far from 0. Nothing can be
+ * drawn or picked through a zoom of 0, and every screen↔world conversion
+ * divides by it, so it is ruled out where views are made rather than handled
+ * by each conversion. This is validity, not an interaction limit: that is
+ * {@link DEFAULT_MIN_ZOOM}, which a consumer may set far below.
+ */
+declare const ZOOM_FLOOR = 1e-9;
+/**
+ * The one rule for a zoom magnitude: a finite number no smaller than
+ * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the
+ * floor. Dev builds warn once when a zoom that was never valid arrives; a
+ * positive zoom that merely undershoots the floor clamps silently.
+ */
+declare function normalizeZoom(zoom: number): number;
 
 /** Options for {@link sceneNodeClientRect}. */
 interface SceneNodeClientRectOpts {
@@ -1215,258 +1754,24 @@ declare function computeFitViewport(viewportW: number, viewportH: number, conten
 declare function useAutoCenter(width: number, height: number, contentW: number, contentH: number, setZoom: (z: number) => void, setPan: (x: number, y: number) => void): void;
 
 /**
- * Pure keyboard-binding helpers shared between the tool dispatcher
- * (`useKeybindings`), the gesture dispatcher (`useGestureDispatcher`), and
- * individual Tool declarations.
- *
- * Extracted from the deleted singular `useKeybinding` hook so the remaining
- * consumers don't depend on its disappearance.
- */
-/**
- * @internal — runtime shape consumed by `matchesKeyBinding`. Public tool authors
- * should use `ToolKeybinding` from `@weasel-js/core` for declaring
- * configurable activation keys.
- */
-interface KeyBinding {
-    /**
-     * Key or list of keys to match. Compared case-insensitively against
-     * `event.key`, so `'a'` matches both `'a'` and `'A'`.
-     */
-    key: string | readonly string[];
-    /**
-     * Require Cmd (mac) or Ctrl (others). When `true`, exactly one of
-     * `metaKey`/`ctrlKey` must be held. Default `false` (both forbidden).
-     */
-    mod?: boolean;
-    /** Require Alt. Default `false` (forbidden). */
-    alt?: boolean;
-    /**
-     * Shift policy. `undefined`/`false` forbids shift, `true` requires
-     * shift, `'optional'` allows either. Default `undefined`.
-     */
-    shift?: boolean | 'optional';
-    /** Skip when focus is in an editable element. Default `true`. */
-    skipInEditable?: boolean;
-    /** When `false`, the listener is not attached. Default `true`. */
-    enabled?: boolean;
-    /** Call `preventDefault` before the handler. Default `true`. */
-    preventDefault?: boolean;
-}
-/** Returns true when the target is an input, textarea, or contenteditable element. */
-declare function isEditableTarget(target: EventTarget | null): boolean;
-/**
- * Pure matcher for `KeyBinding` against a `KeyboardEvent`. Only checks key +
- * modifier policy — does NOT apply the editable-target skip or
- * `preventDefault`. Shared by the tool dispatcher (`useKeybindings`) and the
- * gesture dispatcher so the rules can't drift.
+ * 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.
  */
-declare function matchesKeyBinding(e: KeyboardEvent, b: KeyBinding): boolean;
 
+/** 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;
+}
 /**
- * Promote a Rule tree to a fluent Condition. The function form evaluates
- * the tree against a RuleCtx; combinator methods produce new Conditions
- * wrapping `all`/`any`/`not` nodes.
- *
- * **Chain semantics: strict left-to-right.** No boolean precedence.
- * `focused.or(hovering).and(selectionIs(1))` evaluates
- * `((focused || hovering) && selectionIs(1))` — NOT
- * `(focused || (hovering && selectionIs(1)))` as standard precedence
- * would give. For grouped disjunction, use the top-level `or` / `and` /
- * `not` helpers or name intermediates.
- *
- * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
- * produces `{ all: [a, b, c] }` rather than `{ all: [{ all: [a, b] }, c] }`.
- * Canonical form simplifies downstream introspection.
- *
- * Use {@link when} for the inline-lambda escape hatch.
- */
-declare function cond(rule: Rule): Condition;
-/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
-declare function when(fn: (ctx: RuleCtx) => boolean): Condition;
-/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
- *  semantics ambiguous. */
-declare function and(...cs: (Condition | Rule)[]): Condition;
-/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
- *  `.and` to make grouping explicit. */
-declare function or(...cs: (Condition | Rule)[]): Condition;
-/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
- *  instead; this is for the lead-with-negation case. */
-declare function not(c: Condition | Rule): Condition;
-/** Always true. The fallback for any chrome id without a registered rule. */
-declare const always: Condition;
-/** Always false. Useful for "turn this chrome off entirely":
- *  `chromeVisibility={{ 'snap.guides': never }}`. */
-declare const never: Condition;
-/** Canvas surface currently focused. */
-declare const focused: Condition;
-/** Any action currently in flight (read: user is gesturing). */
-declare const gesturing: Condition;
-/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
-declare const actionIs: (kind: string) => Condition;
-/** Nothing selected. */
-declare const selectionEmpty: Condition;
-/** Exactly `n` items selected. */
-declare const selectionIs: (n: number) => Condition;
-/** At least `n` items selected. `selectionAtLeast(1)` is the common
- *  "something is selected" check. */
-declare const selectionAtLeast: (n: number) => Condition;
-/** Multi-mode handle behavior active (single shared union-bounds
- *  handle vs per-item handles). Implemented as a `when` because
- *  `multiActive` is a derived single-call read on RuleCtx, not a
- *  selector-table key. Stable; safe to introspect. */
-declare const multiActive: Condition;
-/** Pointer is hovering some node. */
-declare const hovering: Condition;
-/** Pointer is hovering a node that is currently selected. */
-declare const hoveringSelected: Condition;
-/** Named modifier key currently held. */
-declare const modifierHeld: (m: keyof ModifierState) => Condition;
-/** View scale (uniform or geometric mean for non-uniform) is at least
- *  `z`. Useful for "hide hairline chrome at low zoom" rules. */
-declare const zoomAtLeast: (z: number) => Condition;
-/** Active mode equals `m`. */
-declare const modeIs: (m: string) => Condition;
-/** Active mode is one of `modes`. */
-declare const modeIn: (modes: readonly string[]) => Condition;
-/** Active mode is NOT `m`. */
-declare const modeNot: (m: string) => Condition;
-/** Active mode's `allows` includes capability `cap`. */
-declare const capabilityIs: (cap: string) => Condition;
-/** Active mode's `allows` includes ANY of `caps` (OR). */
-declare const capabilityIn: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` includes ALL of `caps` (AND). */
-declare const capabilityAll: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` does NOT include capability `cap`. */
-declare const capabilityNot: (cap: string) => Condition;
-/** Primary pointer is imprecise (touch, most styluses). Absent device
- *  profile → false, so a rule written with this atom is inert on the
- *  mouse-shaped default rather than silently flipping. */
-declare const coarsePointer: Condition;
-/** Primary pointer can hover. Absent device profile → true. Pair with
- *  `not(...)` to gate chrome that only makes sense with a hovering
- *  pointer: `not(canHover)` is "this device cannot hover". */
-declare const canHover: Condition;
-
-/**
- * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
- * at resolve time; consumer entries take precedence per id.
- *
- * Written as literal Rule trees rather than fluent chains so the inputs
- * each rule depends on are immediately visible. The fluent atoms compile
- * to the same trees; either form is valid in a VisibilityRules entry.
- *
- * Gating is written in terms of **capabilities, not mode ids**. A
- * capability rule keeps holding when a new mode is added that permits the
- * same thing; a mode rule has to be found and edited every time. There is
- * no `mode:` rule left in this table — the `path-edit.*` chrome used to be
- * the exception, on the theory that it's the visual signature of one mode;
- * see the comment on those rules below for why that was wrong in both
- * directions and what replaced it.
- *
- * Chrome that gates on the *absence* of a capability (the selection
- * outline, suppressed while an anchor-editing overlay owns the visuals)
- * uses `capability: { not: … }` for the same reason.
- */
-declare const defaultVisibilityRules: VisibilityRules;
-
-/**
- * Build the per-frame visibility check. Merges consumer rules on top
- * of the kit defaults, then closes over `ctx` so each chrome-id
- * lookup runs its rule against the current state.
- *
- * `VisibilityRules` entries may be either fluent `Condition` values
- * (callable) or raw `Rule` trees — we normalize at lookup time.
- *
- * Predicates are O(1) and run once per chrome id per frame; no
- * memoization in v1 — profile before adding any.
- *
- * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
- * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
- * opted into modality behaves exactly like one sitting in normal mode.
- */
-declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
-
-/**
- * Pure assembler for {@link ChromeCtx}.
- *
- * Called once per frame on the rendering side from whichever surface
- * needs to evaluate visibility rules — `composeAffordanceLayer`,
- * `createSelectionOverlayLayer`, the dispatcher overlay layer, etc.
- *
- * Sources are passed as plain getters / values rather than the live
- * objects they come from. This keeps `chrome-caps` from depending on
- * React, the dispatcher's concrete type, or `ChromeState`'s bounds
- * machinery — the same builder works from a test harness, a Storybook
- * fixture, or `<SceneCanvas>`.
- */
-
-/** The pieces of live canvas state a `ChromeCtx` is assembled from. */
-interface BuildChromeCtxArgs {
-    focused: boolean;
-    selection: readonly NodeId[];
-    multiActive: boolean;
-    modifiers: ModifierState;
-    action: {
-        kind: string | null;
-        id: string | null;
-    };
-    hover: NodeId | null;
-    view: View;
-}
-/** Gather the current canvas state into the context that chrome-visibility
- *  rules are evaluated against. Rebuilt per frame. */
-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 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`.
- *
- * No re-render: the ref updates silently, and the next render that
- * reads it picks up the fresh value. Chrome-caps rules are evaluated
- * during paint, so the hover state is always read fresh.
- */
-
-/** Options for `useHoverTracking`. */
-interface UseHoverTrackingArgs {
-    canvasRef: RefObject<HTMLElement | null>;
-    /** 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;
-}
-/** Track which node the pointer is over. Returns a getter rather than state,
- *  so per-frame code can read the current value without the hover re-rendering
- *  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.
+ * 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:
@@ -1513,7 +1818,7 @@ declare function actionShortcuts(action: Action): readonly ActionShortcut[];
  *
  * 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`
+ * deriving its geometry from a dragged one follow the drag — `sceneDepLookup`
  * 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.
@@ -1527,11 +1832,8 @@ declare function actionShortcuts(action: Action): readonly ActionShortcut[];
  *
  * ## Pose generics
  *
- * `scene` dep is typed `Scene<unknown, string, unknown>` (the erased DepSchema
- * entry). Poses are read and written as `unknown`; `translatePoseGeneric`
- * delegates to `RECT_POSE_DESCRIPTOR.translate` which treats any pose as
- * `{x, y, ...}`. Consumers with non-rect poses should register a custom
- * action with a typed translatePose.
+ * Poses are `unknown`; every read and write goes through the `poseDescriptor`
+ * dep (`AUTO_POSE_DESCRIPTOR` when unsourced).
  */
 
 /**
@@ -1559,17 +1861,14 @@ declare const moveAction: Action & {
  * start poses, applies per-frame bounds remapping, and commits a single
  * `scene.batch` entry on end.
  *
- * ## Behaviors / point-snap / expandIds / geometry — via `resizePolicy` dep
+ * ## Behaviors / point-snap / expandIds — via the `resizePolicy` dep
  *
- * The resize-behaviors-api wired the four behavior options the
- * legacy `useResize` hook exposed (`behaviors`, `pointSnapBehaviors`,
- * `expandIds`, `geometry`) through the `resizePolicy` dep entry. When
- * the dep is registered, this invoker:
+ * The `resizePolicy` dep carries the behavior options the legacy `useResize`
+ * hook exposed (`behaviors`, `pointSnapBehaviors`, `expandIds`). When the dep
+ * is registered, this invoker:
  *
  *  - Calls `expandIds([id])` at start. When the result expands beyond the
  *    starting id, takes the group path (union-AABB origin, per-leaf remap).
- *  - Projects poses through the supplied `geometry: PoseProjection<TPose>`
- *    instead of the rect-shaped `RECT_POSE_DESCRIPTOR` default.
  *  - Runs `behaviors[]` after the raw anchor-math bounds are computed.
  *    Behaviors return `{ pose? }` and rewrite the proposed bounds before
  *    they're projected back into pose space.
@@ -1578,12 +1877,17 @@ declare const moveAction: Action & {
  *    frame's world point lands on the snap target.
  *
  * When the dep is absent the invoker falls back to identity defaults
- * (no behaviors, no snap, `ids => ids` expansion, `RECT_POSE_DESCRIPTOR`),
- * which matches the unrotated rect-pose path the invoker already
- * implemented.
+ * (no behaviors, no snap, `ids => ids` expansion).
+ *
+ * ## Pose geometry — via the `poseDescriptor` dep
+ *
+ * Every pose read and rewrite goes through the `poseDescriptor` dep, which
+ * `<SceneCanvas>` sources from its `poseDescriptor` prop. Unsourced it is
+ * `AUTO_POSE_DESCRIPTOR`, which dispatches per call to `pathPoseDescriptor`
+ * for Path-shaped poses and to `RECT_POSE_DESCRIPTOR` for everything else.
  *
  * @see useResize — the React hook this descriptor mirrors.
- * @see src/interactions/actions/resize/geometry.ts — `PoseProjection`.
+ * @see src/interactions/actions/resize/geometry.ts — `PoseDescriptor`.
  */
 
 /**
@@ -1603,7 +1907,7 @@ declare const resizeAction: Action & {
  *
  * ## Status: REAL (unrotated-pivot path)
  *
- * Implements the core rotation math from `useRotate` for rect-shaped poses:
+ * Implements the core rotation math from `useRotate`:
  *   - `start`: captures origin poses + AABB centers; computes start pointer
  *     angle around the union center of selected nodes.
  *   - `onMove`: derives pointer angle delta from start, applies to each node's
@@ -1618,8 +1922,9 @@ declare const resizeAction: Action & {
  *
  * ## Constraints vs `useRotate`
  *
- * - Assumes rect-shaped poses `{ x, y, width, height, rotation? }`. Non-rect
- *   TPose consumers need a custom action with a typed `RotateGeometry`.
+ * - Reads and writes poses through the `poseDescriptor` dep; a pose whose
+ *   descriptor has no `withRotation`, or reports `supportsRotation` false, is
+ *   left alone.
  * - No behavior pipeline (snap, etc.). Behaviors wait for a later phase.
  * - No overlay rendering — deferred to Phase 7 overlay surface.
  * - Shift-snap (15° quantum) is NOT wired in this phase — omitted deliberately
@@ -1633,9 +1938,7 @@ declare const resizeAction: Action & {
  *
  * Requires dep-schema entries: `selection`, `scene`.
  *
- * Implements the unrotated-pivot rotation path from `useRotate` for rect-
- * shaped poses. Non-rect or behavior-rich consumers should register a custom
- * `rotateAction` with a typed `RotateGeometry` dep.
+ * Implements the unrotated-pivot rotation path from `useRotate`.
  *
  * @see useRotate — the React hook this descriptor mirrors for the rect case.
  */
@@ -1850,9 +2153,7 @@ declare const clearSelectionAction: Action & {
  *
  * ## Pose generics
  *
- * Poses are translated using the same `{x, y, ...}` generic spread as
- * `moveAction`. Non-rect poses with custom layout (e.g. paths) should register
- * a custom clone action with a typed geometry dep.
+ * Poses are translated through the `poseDescriptor` dep, as `moveAction` does.
  */
 
 /**
@@ -2154,6 +2455,19 @@ declare const lassoSelectAction: Action & {
     requires: string[];
 };
 
+/**
+ * @experimental
+ * Static descriptor for the `slice` Action.
+ *
+ * Ongoing drag invoker: tracks a slice line from drag start to current
+ * pointer, publishes it as a `'cut'` overlay while the gesture is in flight,
+ * and on commit calls `SliceDep.commit(a, b)`. No-ops gracefully when
+ * the `slice` dep is absent.
+ */
+declare const sliceAction: Action & {
+    requires: string[];
+};
+
 /**
  * `pinchZoomAction` — ongoing Action descriptor for two-finger pinch zoom
  * and pan. The id and label stay `pinchZoom` / `Pinch Zoom`.
@@ -2217,6 +2531,143 @@ declare const pinchZoomAction: Action & {
     requires: string[];
 };
 
+/**
+ * @experimental
+ * Static descriptor for the `clipboard.copy` Action (Cmd/Ctrl+C).
+ */
+declare const clipboardCopyAction: Action & {
+    requires: string[];
+};
+/**
+ * @experimental
+ * Static descriptor for the `clipboard.cut` Action (Cmd/Ctrl+X) — copy, then
+ * the same batched delete `deleteAction` performs, as one undo entry.
+ */
+declare const clipboardCutAction: Action & {
+    requires: string[];
+};
+
+/**
+ * `enterTextEditAction` — immediate Action descriptor for entering in-place
+ * text editing on a selected text node.
+ *
+ * ## Status: REAL
+ *
+ * Fires via `useTextTool.bindings` when the user clicks on a
+ * selected text node. Calls `deps.textEdit.startEdit(id)` to activate the
+ * contenteditable overlay managed by `useTextEdit` / `useSceneTextEdit`.
+ *
+ * ## No defaultBinding / defaultBinding
+ *
+ * This action has no ambient key or gesture binding — it fires ONLY via
+ * `useTextTool`'s `Tool.bindings` entry:
+ *
+ * ```ts
+ * bindings: [
+ *   { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' },
+ * ]
+ * ```
+ *
+ * Keeping it binding-free avoids ambient double-fire and scopes the action to
+ * the text tool context where `classifyTarget` is already wired.
+ *
+ * ## Self-guard: only act on text nodes
+ *
+ * The `'selected-body'` target yields a match for any selected node kind. To
+ * avoid entering text-edit mode when the text tool happens to have a non-text
+ * node selected, the action self-guards via an optional `isTextNode` predicate
+ * on `TextEditDep`:
+ *
+ * - When `isTextNode` is absent: action fires unconditionally (the binding
+ *   spec is the real gate — consumers should only bind this action from the
+ *   text tool).
+ * - When `isTextNode(id)` returns `false`: action is a no-op for that node.
+ *
+ * ### Pre-filtering at dispatch time
+ *
+ * `classifyTarget` now surfaces node kind, so a binding can pre-filter instead
+ * of relying on the self-guard:
+ *
+ * ```ts
+ * { spec: { kind: 'click', target: 'kind:text:selected' }, actionId: 'enterTextEdit' }
+ * ```
+ *
+ * That reads the *routing trait's* kind, so it matches whatever names the
+ * consumer registered in `<SceneCanvas routing>` — `'text'` under the kit's
+ * inferred default. `isTextNode` stays on `TextEditDep` because it also covers
+ * consumers who bind the broader `'selected-body'` target, and because it is
+ * the only guard for a consumer who opted out of routing entirely.
+ *
+ * ## Migration plan for useTextTool
+ *
+ * When wiring `useTextTool` to `Tool.bindings`:
+ *
+ * 1. Add to `useTextTool`'s `bindings`:
+ *    ```ts
+ *    { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' }
+ *    ```
+ * 2. Register a `textEdit` dep sourced from the `useTextEdit` / `useSceneTextEdit`
+ *    return value, plus an `isTextNode` predicate that checks `data.kind === 'text'`
+ *    (or however the consumer identifies text nodes).
+ * 3. The existing `hitExisting` gate in `useTextTool`'s click route becomes
+ *    redundant — remove it in the same pass.
+ */
+
+/**
+ * @experimental
+ * Static descriptor for the `enterTextEdit` Action.
+ *
+ * Requires dep-schema entries: `textEdit`, `selection`.
+ *
+ * No `defaultBinding` / `defaultBinding` — fires only via `Tool.bindings`.
+ * Self-guards via `TextEditDep.isTextNode` when provided.
+ */
+declare const enterTextEditAction: Action & {
+    requires: string[];
+};
+
+/** Somewhere selection can live outside this hook. `Scene` satisfies it;
+ *  so does any store with the same three methods. */
+interface SelectionStore {
+    getSelection(): readonly NodeId[];
+    setSelection(ids: readonly NodeId[]): void;
+    subscribe(listener: () => void): () => void;
+}
+/** Options for {@link useSelection}. */
+interface UseSelectionOptions {
+    /** Default `'single'`. */
+    mode?: SelectionMode;
+    /** Default `'shift'`. Ignored in single-mode. */
+    extend?: SelectionExtendKey;
+    /** Default `[]`. */
+    initial?: readonly NodeId[];
+    /** Keep the selection on this store rather than in the hook, so every
+     *  consumer of the same scene shares one selection and undo / redo can
+     *  restore it. `initial` then only seeds a store that has none yet.
+     *  Omit it and the hook owns a selection nobody else sees. */
+    scene?: SelectionStore;
+    /** When `true`, every mutator (`set`/`add`/`remove`/`toggle`/`clear`/
+     *  `applyClick`) is a no-op — selection stays at whatever `initial`
+     *  pinned it to. Useful for demos that exist to showcase a single
+     *  pre-selected node and don't want a
+     *  stray click to deselect. */
+    lock?: boolean;
+}
+/**
+ * Default implementation of the `getSelection` / `setSelection` adapter
+ * contract every action hook (delete, duplicate, nudge, group, ...) requires.
+ *
+ * Owns selection state, exposes a click-policy helper (single vs multi with
+ * an extend key), and pre-builds the two adapter methods consumers otherwise
+ * hand-roll in every demo:
+ *
+ * ```tsx
+ * const selection = useSelection({ mode: 'multi' });
+ * const adapter = { ...arrayAdapter({...}), ...selection.adapterMethods };
+ * ```
+ */
+declare function useSelection(opts?: UseSelectionOptions): SelectionApi;
+
 /** @experimental */
 interface UseStandardActionsOptions {
     /** Kit selection state — ids of currently selected nodes. */
@@ -2257,25 +2708,6 @@ declare const KIT_STANDARD_ACTION_IDS: readonly string[];
  */
 declare function useStandardActions(opts: UseStandardActionsOptions): void;
 
-/**
- * Shared scene-backed commit adapter for default actions.
- *
- * Default actions route data/layer/pose/parent mutations through the
- * consumer's `applyOps` commit hook when one is present; when it isn't, they
- * fall back to applying the committed ops directly against the scene through
- * 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` / `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
- * `interactions → canvas → interactions` cycle. Mirrors `moveGestureAdapter`,
- * widened to all op-apply methods.
- */
-
 /** 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. Path and text ops are not covered; those surfaces belong to their
@@ -2301,289 +2733,26 @@ declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose
 /** Options for `useResizePolicy`. Each omitted field falls back to the kit
  *  default. */
 interface UseResizePolicyOptions<TPose> {
-    constraints?: TPose extends ResizePose ? BoundsConstraint<TPose>[] : never[];
-    pointSnap?: TPose extends ResizePose ? PointSnapBehavior<TPose>[] : never[];
+    constraints?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];
+    pointSnap?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never[];
     expandIds?: (ids: string[]) => string[];
-    projection?: PoseProjection<TPose>;
 }
 /** Publish how resizing should behave — constraints, point snapping, group
- *  expansion, pose projection — for the resize action to consult. */
+ *  expansion — for the resize action to consult. */
 declare function useResizePolicy<TPose>(options: UseResizePolicyOptions<TPose>): void;
 
+/** Publish the pose descriptor every built-in action reads. */
+declare function usePoseDescriptorDepSource(descriptor: PoseDescriptor<unknown> | undefined): void;
+
+/** Publish the scene's pose-composition strategy to the built-in actions.
+ *  Absent is the absolute-pose model: `scenePoseFrame` falls back to identity
+ *  and every world/local conversion in an action is a no-op. */
+declare function usePoseCompositionDepSource(composition: PoseComposition<unknown> | undefined): void;
+
 /** Publish how a slice (knife cut) is performed, so the `slice` action can
  *  run against the consumer's geometry. */
 declare function useSliceDep(dep: SliceDep): void;
 
-/**
- * The painted cursor a surface is currently showing, shared between whoever
- * decides it and the layer that draws it.
- *
- * Two slots rather than one, mirroring the precedence the cursor pipeline
- * already has: `<Canvas>` writes the active tool's cursor to `base` from
- * render, and the hover pump writes an affordance's or an action's cursor to
- * `override` imperatively. The override wins while it is set, and clearing it
- * restores the base without a React commit — the same reason the pump uses an
- * inline style for the CSS tier.
- */
-
-/** The painted arm of `ResolvedCursor` — what this module stores. */
-type PaintedCursor = Extract<ResolvedCursor, {
-    kind: 'painted';
-}>;
-interface PaintedCursorFrame {
-    readonly cursor: PaintedCursor;
-    /** Pointer position in the layer's own space: canvas-local CSS px. */
-    readonly at: {
-        readonly x: number;
-        readonly y: number;
-    };
-}
-interface PaintedCursorState {
-    setBase(cursor: PaintedCursor | null): void;
-    setOverride(cursor: PaintedCursor | null): void;
-    /** Canvas-local CSS px. */
-    setPointer(x: number, y: number): void;
-    /** Pointer left the surface: nothing to draw until it returns. */
-    clearPointer(): void;
-    /**
-     * Whether a painted cursor is set at all, regardless of where the pointer is.
-     *
-     * Lets the pointer path skip measuring the canvas rect on every move in the
-     * overwhelmingly common case where the compositor is drawing the cursor and
-     * nothing here needs its position.
-     */
-    active(): boolean;
-    /** What the layer should draw this frame, or null for none. */
-    current(): PaintedCursorFrame | null;
-    /** Run `fn` whenever the answer to `current()` may have changed. */
-    subscribe(fn: () => void): () => void;
-}
-declare function createPaintedCursorState(): PaintedCursorState;
-
-/**
- * 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. */
-interface UseGestureDispatcherOptions {
-    /** Ref to the canvas element. Pointer/wheel/multitouch listeners attach here. */
-    canvasRef: RefObject<HTMLElement | null>;
-    /** Action registry (ActionsRegistry from registry.tsx). */
-    actions: ActionsRegistry;
-    /** Tool definitions keyed by id. Typically passes an empty Map. */
-    toolsById: ReadonlyMap<string, Tool>;
-    /** Default true. Set false to opt out of dispatcher wiring (e.g. demos that disable it). */
-    enabled?: boolean;
-    /**
-     * Observer fired whenever the dispatcher synthesizes a double click, in
-     * world coordinates. Runs BEFORE the event is dispatched and independently
-     * of which binding (if any) handles it.
-     *
-     * This is deliberately not an Action. `<SceneCanvas onDoubleClick>` is a
-     * notification — "the user double-clicked, here's what they hit" — and a
-     * notification must not compete with behavior for the gesture. As a binding
-     * it would lose to `enterPathEdit` on any body hit and silently never fire.
-     * Routing it here keeps a single definition of "double click" (the point of
-     * consolidating the kit's three detectors) without giving it
-     * first-match-wins semantics it shouldn't have.
-     */
-    onDoubleClick?: (world: {
-        x: number;
-        y: number;
-    }) => void;
-    /**
-     * Default true. Set false to leave the window `keydown`/`keyup` listeners
-     * unattached so keyboard-bound actions never dispatch — pointer, wheel, and
-     * contextmenu channels stay live. `<SceneCanvas>` wires this to
-     * `enableKeybindings`, so opting out of keybindings disables the modern
-     * dispatcher key path as well as the legacy `useKeybindings` hook.
-     */
-    keyboard?: boolean;
-    /**
-     * Optional affordance classifier. Called on every pointerdown with the
-     * world-space coordinates of the pointer. Returns an `AffordanceHit` when
-     * the pointer lands on a known affordance (resize handle, rotate handle, etc.)
-     * or `null` when the pointer hit open canvas.
-     *
-     * The hit is packed into `InputEvent.pointerdown.affordance` and flows
-     * through into `InvocationCtx.drag.affordance`. Action invokers that require
-     * a specific affordance (e.g. `resizeAction` requires `handle:*`) use this
-     * field as a guard in their `start` body.
-     *
-     * When omitted, `affordance` is always `undefined` — meaning only consumers
-     * that explicitly wire a classifier get affordance-gated behavior.
-     * `<SceneCanvas>` wires the full chrome→dispatcher bridge.
-     */
-    affordanceAt?: (worldPoint: {
-        x: number;
-        y: number;
-    }) => AffordanceHit | null;
-    /**
-     * Optional body classifier. Called on every pointerdown with the world-space
-     * coordinates of the pointer. Its result is packed onto the event as
-     * `bodyTarget` + `bodyKind`, which `matchTarget` reads to resolve the
-     * string-form `TargetSpec` values in `Tool.bindings`.
-     *
-     * `body` is `'empty'` when nothing is under the pointer, `'selected-body'`
-     * when the topmost hit belongs to the current selection, or
-     * `'unselected-body'` when it belongs to a node that isn't selected. `kind`
-     * is the hit node's semantic kind, when the scene can name it.
-     *
-     * When omitted, every body-derived target form (`'empty'`,
-     * `'selected-body'`, `'unselected-body'`, `kind:<k>`, `kind:<k>:selected`)
-     * never matches — bindings using those specs are silently skipped.
-     * `<SceneCanvas>` wires this.
-     */
-    classifyTarget?: (worldPoint: {
-        x: number;
-        y: number;
-    }) => BodyClassification;
-    /**
-     * Optional pre-created `Dispatcher`. When provided, this hook pumps events
-     * into the supplied instance instead of creating its own. Lets a parent
-     * scope (e.g. `<SceneCanvas>`) share one dispatcher between the gesture
-     * mounter and other consumers (the preview-ghost layer).
-     */
-    dispatcher?: Dispatcher;
-    /**
-     * Converts a client-space pointer position (e.g. `e.clientX`, `e.clientY`)
-     * to world-space coordinates. When supplied, every pointer/wheel event's
-     * `x`/`y` is converted before the dispatcher builds `InvocationCtx.world`.
-     *
-     * Without this, `ctx.world` is populated with the raw client coords, which
-     * silently breaks any action whose overlay/output uses absolute world
-     * positions (marquee, lasso polyline, world-space affordances). Actions
-     * that only read `drag.delta` are unaffected because client→world deltas
-     * are equal at scale 1, but as soon as a consumer pans/zooms the view the
-     * deltas diverge too.
-     *
-     * `<SceneCanvas>` always wires this via its canvas rect + current view.
-     * Tests / harnesses without a view can omit it and continue passing raw
-     * coordinates as before.
-     */
-    clientToWorld?: (clientX: number, clientY: number) => {
-        x: number;
-        y: number;
-    };
-    /**
-     * Invoked once per pump event (`pointermove`, `pointerup`, `pointercancel`,
-     * `key-held` up-phase, `multitouch` move) when a dispatcher-side handle is
-     * in flight. Lets the host canvas schedule a redraw so dispatcher-only
-     * overlays (marquee, lasso, preview-ghost) repaint on each frame.
-     *
-     * Required because dispatcher actions don't go through the legacy
-     * `tools.dispatcher.onGestureChange` redraw bump that ambient tool drags
-     * relied on. Without it, the overlay layer's `draw` never runs between
-     * pointerdown and pointerup, and the chrome flashes once at gesture start
-     * and then sits frozen until the gesture ends.
-     *
-     * `<SceneCanvas>` wires this to the canvas's `requestRedraw`. Test
-     * harnesses can omit it; their dispatchers won't paint between events but
-     * that's already the test contract.
-     */
-    requestRedraw?: () => void;
-    /**
-     * The surface's painted-cursor channel, read live because the canvas handle
-     * it lives on arrives a render after this hook runs.
-     *
-     * Given one, a cursor the CSS tier cannot express — sized in world units, or
-     * past the size the browser drops the image at — is published here and drawn
-     * by the painted-cursor layer instead. Without one, such a cursor resolves to
-     * `none` and the pointer shows nothing.
-     */
-    paintedCursor?: () => PaintedCursorState | undefined;
-    /**
-     * Thunk returning the live `RuleCtx` for the current frame. When supplied,
-     * the dispatcher filters matched candidates by their declared
-     * `Action.eligible` rule (omitted => always eligible). `<SceneCanvas>`
-     * wires this; tests / harnesses without chrome-caps state can omit it.
-     */
-    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
- * multitouch listeners in, normalized input events out, routed through the
- * dispatcher to whichever action a binding names.
- *
- * Everything it needs beyond its options — the active tool, the dep registry —
- * comes from context, so it must be mounted inside `<SceneCanvas>`'s
- * providers.
- */
-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
@@ -2687,14 +2856,6 @@ declare function wheelPan(view: View, delta: {
 /** Pure reducer: the whole wheel convention in one call. */
 declare function computeWheelAction(view: View, input: WheelInput, clamp?: ZoomClampOpts, opts?: Pick<WheelPanOpts, 'axis'>): View;
 
-/**
- * Convert client coords to element CSS-pixel coords (relative to the element's
- * top-left). Apps drawing in CSS-pixel space feed the result directly into
- * world math when pan/zoom is identity. With pan/zoom, compose this with
- * your inverse-viewport transform.
- */
-declare function clientToCanvas(canvas: HTMLElement, clientX: number, clientY: number): [number, number];
-
 /** Records recent deltas and reports the current velocity, averaged over the
  *  last 100ms — the throw speed a momentum decay starts from. */
 interface VelocityTracker {
@@ -2734,93 +2895,28 @@ declare function usePinchGesture(canvasRef: React.RefObject<HTMLElement | null>,
 declare function interpolateView(from: View, to: View): (t: number) => View;
 
 /**
- * Build a `Tool<TScratch>` from a declarative `ToolDef<TScratch>`.
+ * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
  *
- * This used to be a translator: `ToolDef` carried `initial` / `engaged` phase
- * tables of hit-keyed route handlers, and `defineTool` compiled them into the
- * imperative `pointer` / `drag` / `keyboard` / `wheel` handlers the
- * tool-routing dispatcher called. Both ends of that are gone — tools declare
- * `bindings` and the gesture dispatcher routes them — so what remains is
- * identity plumbing plus the id check and the cursor resolver.
- *
- * It stays a function rather than becoming a spread because the id validation
- * and the `initScratch` / `cursor` defaults are worth applying uniformly, and
- * because `Tool.def` gives reflection a handle on the authored form.
+ * `@weasel-js/routing` never reads an overlay — it collects the live ones and
+ * hands them back in scope order — so it leaves the element type open. What a
+ * weasel canvas draws is a `RenderLayer`, and every kit call site should see
+ * that rather than `unknown`, so core binds the parameter once, here, and
+ * re-exports these names under the ones they have always had.
  */
-declare function defineTool<TScratch = void>(def: ToolDef<TScratch>): Tool<TScratch>;
 
-/**
- * Define a tool that acts on the viewport rather than the scene.
- *
- * This used to do real work: `ViewportPhaseDef` was a narrowed `PhaseDef`
- * (no click routes, drag restricted to the function form), and the factory
- * lifted it back to the permissive shape before handing it to `defineTool`.
- * With phase tables gone there is no shape left to narrow — a viewport tool
- * declares `bindings` like any other, pointing at `viewport.*` actions.
- *
- * It survives as an authoring signal. `defineViewportTool` at the top of a
- * hook says "this tool moves the camera, not the drawing", which is worth
- * more than the type gymnastics it replaced.
- */
+/** What a canvas overlay is, at this layer. */
+type Overlay = RenderLayer<unknown>;
+type Contribution = Contribution$1<Overlay>;
+type ContributionChrome = ContributionChrome$1<Overlay>;
+type Tool<TScratch = unknown> = Tool$1<TScratch, Overlay>;
+type AnyTool = AnyToolOf<Overlay>;
+type ToolDef<TScratch = void> = ToolDef$1<TScratch, Overlay>;
+type ViewportToolDef<TScratch = void> = ViewportToolDef$1<TScratch, Overlay>;
+type ToolsApi = ToolsApi$1<Overlay>;
+type UseToolsOptions = UseToolsOptions$1<Overlay>;
+declare function defineTool<TScratch = void>(def: ToolDef<TScratch>): Tool<TScratch>;
 declare function defineViewportTool<TScratch = void>(def: ViewportToolDef<TScratch>): Tool<TScratch>;
-
-/** Options for `useTools`: which tools exist, which one starts active, and
- *  which run continuously regardless of the active one. */
-interface UseToolsOptions {
-    /** Initial active-slot tool id. Must exist in `registry`. */
-    active: string;
-    /** Tools eligible for the active slot or hotkey slot. The keys are the
-     *  tool ids; the values are the tool records. A tool with `hotkey` set
-     *  is wired into the hotkey slot whenever the engagement state matches. */
-    registry: Record<string, AnyTool>;
-    /** Always-on tools — listen continuously regardless of active slot. */
-    ambient?: AnyTool[];
-}
-/** The tool registry's runtime surface: which tool is active, which is
- *  temporarily held by a hotkey, and how to change either. */
-interface ToolsApi {
-    /** Current active-slot tool id. */
-    active: string;
-    /** Set the active-slot tool. The gesture dispatcher watches the active
-     *  tool and cancels any in-flight handle itself. */
-    setActive: (id: string) => void;
-    /** Currently hotkey-engaged tool id (or `null`). Derived as the top of
-     *  the hotkey stack for backwards compat with the pre-stack API. */
-    hotkeyEngaged: string | null;
-    /** Engage a hotkey-slot tool by id. */
-    engageHotkey: (id: string) => void;
-    /** Disengage the hotkey-slot tool, if any. */
-    disengageHotkey: () => void;
-    /** All always-on tools, in registration order. */
-    ambient: readonly AnyTool[];
-    /** Full registry — for userland UI (palette buttons, etc.). */
-    registry: Readonly<Record<string, AnyTool>>;
-    /** Returns true if a tool with the given id is in the registry or ambient list. */
-    has(id: string): boolean;
-    /** All overlay layers from currently-engaged tools (active slot, hotkey
-     *  slot if engaged, all ambient slot tools) that declare `position`.
-     *  Filters out tools with no `overlay` field. Order: active, then hotkey
-     *  (if engaged), then ambient (registration order). */
-    getActiveOverlays(position?: OverlayPosition): RenderLayer<unknown>[];
-}
-/**
- * Manages the active tool and hotkey slot.
- *
- * A thin shim over {@link useContributions}: the `registry` / `ambient`
- * arguments are restated as declared eligibility (`focus` / `always`), and
- * assembly happens in one place for tools and non-tool contributions alike.
- *
- * Requires `<ActiveToolContextProvider>` (or `<WeaselProvider>` /
- * `<SceneCanvas>`, which mount one internally) in scope: active/hotkey state
- * lives in the context so the gesture dispatcher and any sibling
- * `useTools` calls all read the same source of truth.
- *
- * **First-mount-wins semantics**: if `opts.active` differs from the context
- * default (`'select'`) on first mount, `useTools` pushes `opts.active` to
- * the context. Subsequent mounts respect whatever the context currently
- * holds (the first caller wins).
- */
-declare function useTools(opts: UseToolsOptions): ToolsApi;
+declare const useTools: (opts: UseToolsOptions) => ToolsApi;
 
 /** Options for `useKeybindings`. */
 interface UseKeybindingsOptions {
@@ -2876,6 +2972,9 @@ interface ToolPrefBase<K extends string, Value> {
 }
 /** How a schema-driven UI should present a number pref. */
 type ToolPrefNumberControl = 'input' | 'slider';
+/** How a schema-driven UI should show a number pref's value. `compact`
+ *  abbreviates from a thousand up, as in `2.0M`. */
+type ToolPrefNumberFormat = 'plain' | 'compact';
 /** How a schema-driven UI should present a boolean pref. */
 type ToolPrefBooleanControl = 'checkbox' | 'switch' | 'toggle';
 /** How a schema-driven UI should present a string pref. */
@@ -2890,7 +2989,21 @@ interface ToolPrefNumberUnit {
     fromDisplay: (display: number) => number;
     /** Shown after the input, e.g. `'°'`. */
     suffix?: string;
+    /** Suffixes a person may type, each mapped to the factor that turns a
+     *  number in that unit into a display number: `{ mm: 0.1, cm: 1 }` for a
+     *  field showing centimeters. */
+    accepts?: Readonly<Record<string, number>>;
 }
+/**
+ * A display unit built from a {@link UnitSystem}: values are stored in the
+ * system's base and shown in `display`, rounded to `precision` places when
+ * given, and every unit in the system is accepted as typed text. `suffix`
+ * defaults to the unit's name and is accepted too.
+ */
+declare function prefUnit(system: UnitSystem, display: Unit, opts?: {
+    precision?: number;
+    suffix?: string;
+}): ToolPrefNumberUnit;
 /** A numeric pref, optionally bounded and stepped, and optionally stored in a
  *  different unit from the one shown. */
 interface ToolPrefNumber extends ToolPrefBase<'number', number> {
@@ -2898,6 +3011,7 @@ interface ToolPrefNumber extends ToolPrefBase<'number', number> {
     max?: number;
     step?: number;
     control?: ToolPrefNumberControl;
+    format?: ToolPrefNumberFormat;
     unit?: ToolPrefNumberUnit;
 }
 /** An on/off pref. */
@@ -3045,21 +3159,144 @@ interface ToolPrefGroup {
     children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
 }
 
+/**
+ * `DebugSink`, `HitShape` and `HandleKind` are declared in
+ * `@weasel-js/routing` — `ToolCtx.debug` carries a sink, so routing has to
+ * name the type. Re-exported here, beside the overlay that reads one.
+ */
+
+/** One bit per debug feature; absent keys are off. */
+interface DebugConfig {
+    hitboxes?: boolean;
+    handles?: boolean;
+    bounds?: boolean;
+    origins?: boolean;
+    snap?: boolean;
+    layers?: boolean;
+    /** Render each tracked node's id as a label at the top-left of its
+     *  bounds. Pulls from the same `recordBounds` stream `bounds` uses, so
+     *  no extra sink calls are required to enable. */
+    ids?: boolean;
+    /** Rolling FPS counter rendered in the top-left corner of the canvas.
+     *  Tracks the rate at which the debug overlay's draw callback runs;
+     *  this matches the canvas's effective repaint rate. */
+    fps?: boolean;
+    /** Optional per-feature color overrides; falls back to the default theme. */
+    theme?: Partial<DebugTheme>;
+    /** Optional per-feature line-width / dash overrides; falls back to
+     *  {@link DEFAULT_DEBUG_STROKES}. */
+    strokes?: Partial<DebugStrokes>;
+}
+/** The name of one debug-overlay feature — the keys of {@link DebugConfig}
+ *  that toggle a visualization. */
+type DebugFeature = 'hitboxes' | 'handles' | 'bounds' | 'origins' | 'snap' | 'layers' | 'ids' | 'fps';
+/** Colors the debug overlay draws with, one entry per feature. */
+interface DebugTheme {
+    hitboxFill: string;
+    hitboxStroke: string;
+    handle: string;
+    bounds: string;
+    origin: string;
+    snap: string;
+    layerText: string;
+    layerTextBg: string;
+    /** Color for the per-node id label rendered when `config.ids` is on. */
+    idText: string;
+    /** Foreground / background for the FPS panel. */
+    fpsText: string;
+    fpsTextBg: string;
+}
+/** Line width and dash pattern for one stroked debug feature. An empty (or
+ *  omitted) `dash` is a solid line. */
+interface DebugStroke {
+    width: number;
+    dash?: readonly number[];
+}
+/** The stroked half of the debug overlay's appearance, split from
+ *  {@link DebugTheme} because only some features draw a line at all — text
+ *  panels and filled origin dots take color and nothing else. */
+interface DebugStrokes {
+    hitbox: DebugStroke;
+    bounds: DebugStroke;
+    handle: DebugStroke;
+    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
+    snap: DebugStroke;
+}
+/** A hit region tested during the current frame. */
+interface RecordedHitbox {
+    id: string;
+    kind: 'body' | 'handle' | 'rotation' | 'anchor';
+    shape: HitShape;
+}
+/** A handle drawn during the current frame, and where. */
+interface RecordedHandle {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    kind: HandleKind;
+}
+/** A node's bounds as computed during the current frame. */
+interface RecordedBounds {
+    id: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** A node's transform origin as used during the current frame. */
+interface RecordedOrigin {
+    id: string;
+    point: {
+        x: number;
+        y: number;
+    };
+}
+/** A snap candidate considered during the current gesture, and whether it
+ *  won. Unlike the other records these survive across frames, until the
+ *  gesture ends. */
+interface RecordedSnap {
+    point: {
+        x: number;
+        y: number;
+    };
+    accepted: boolean;
+}
+/** A render layer that drew during the current frame. */
+interface RecordedLayer {
+    id: string;
+    label: string;
+    space: 'world' | 'screen';
+    index: number;
+}
+/** Everything the sink collected, ready for the overlay to draw. */
+interface DebugSnapshot {
+    hitboxes: RecordedHitbox[];
+    handles: RecordedHandle[];
+    bounds: RecordedBounds[];
+    origins: RecordedOrigin[];
+    snap: RecordedSnap[];
+    layers: RecordedLayer[];
+}
+
 /** Options for `useSelectTool`: how a point resolves to nodes, how a click
  *  chooses among them, and the appearance of the marquee. */
 interface UseSelectToolOptions<TPose> {
     /** Return ids of all objects whose painted body covers (worldX, worldY).
      *  Order doesn't matter — the tool collapses parent/child overlap via
-     *  `pickTopMostHit`. When omitted, defaults to a rect AABB-vs-point scan
-     *  over `adapter.getNodes()` using `poseBounds` (identity by default,
-     *  works for `{x,y,width,height}` poses). Override for tighter shapes
-     *  (path / polygon hit-tests). */
+     *  `pickTopMostHit`. When omitted, defaults to an AABB-vs-point scan over
+     *  `adapter.getNodes()` using the pose descriptor. Override for tighter
+     *  shapes (path / polygon hit-tests). */
     pickEvery?: (worldX: number, worldY: number) => string[];
     /** Optional alt-aware selection-update hit returning the single id the
      *  click should act on. */
     pickBest?: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
-    /** Project a pose to its AABB. Default: identity. */
-    poseBounds?: (pose: TPose) => Bounds;
+    /** How to read poses for the default `pickEvery`. Default
+     *  `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /**
      * How the default `pickEvery` decides a **leaf** node covers the pointer.
      * Ignored when `pickEvery` is supplied.
@@ -3090,6 +3327,13 @@ interface UseSelectToolOptions<TPose> {
      * Without some slop a hairline outline is an unhittable target.
      */
     pickTolerance?: number;
+    /** Painted alpha per node in the view this tool picks for. A node painted
+     *  at alpha 0 is not under the pointer. Ignored when `pickEvery` is
+     *  supplied. */
+    alphaOf?: (id: string) => number;
+    /** Whether a node's `layer` reaches the screen in the view this tool picks
+     *  for. Ignored when `pickEvery` is supplied. */
+    layerIsPainted?: (layer: string) => boolean;
     /** Move-action options. The move gesture is dispatcher-routed,
      *  so only `behaviors` is consumed here — threaded into the move binding's
      *  `opts.behaviors`. Other `UseMoveOptions` fields are accepted for API shape
@@ -3650,6 +3894,266 @@ interface PencilPoint {
  */
 declare function usePencilTool(): Tool<null>;
 
+/**
+ * Live state read by chrome-visibility {@link Condition}s. Backward-compat
+ * alias for the legacy ChromeCtx shape — kept for consumers that still
+ * import `ChromeCtx`. Subset of `RuleCtx`: legacy ChromeCtx didn't carry
+ * mode/capability info. The resolver builds a `RuleCtx` for evaluation;
+ * surfaces that still operate in `ChromeCtx` shape supply defaults
+ * (mode='normal', empty allowedCapabilities) at the construction site.
+ */
+interface ChromeCtx {
+    readonly focused: boolean;
+    readonly selection: readonly NodeId[];
+    readonly multiActive: boolean;
+    readonly modifiers: ModifierState;
+    readonly action: {
+        readonly kind: string | null;
+        readonly id: string | null;
+    };
+    readonly hover: NodeId | null;
+    readonly view: View;
+}
+/**
+ * Composable visibility predicate with fluent surface. Carries its underlying
+ * `Rule` tree at `.rule` so the resolver can introspect / share trees with
+ * the affordance pipeline and the dispatcher's eligibility filter.
+ *
+ * Callable form `cond(ctx)` evaluates the tree against ctx. The fluent
+ * methods return new Conditions wrapping new trees.
+ *
+ * **Chain semantics: strict left-to-right, no precedence.**
+ * `a.and(b).or(c)` is `(a && b) || c`; `a.or(b).and(c)` is
+ * `(a || b) && c`. Mix `.and` and `.or` only when you mean
+ * left-to-right evaluation. For grouped disjunction, name the
+ * subexpression or use the top-level `or(...)`.
+ */
+interface Condition {
+    (ctx: RuleCtx): boolean;
+    readonly rule: Rule;
+    /** `this && other` */
+    and(other: Condition | Rule): Condition;
+    /** `this || other` */
+    or(other: Condition | Rule): Condition;
+    /** `this && !other` */
+    andNot(other: Condition | Rule): Condition;
+    /** `this || !other` */
+    orNot(other: Condition | Rule): Condition;
+}
+/**
+ * Stable identifier for one user-visible chrome element. The same id
+ * gates both paint and hit-test — there is no separate
+ * `affordance.X` / `selection.X` split — so toggling a rule cannot
+ * leave a visually-present but un-hittable handle (or vice versa).
+ *
+ * Naming convention by lifecycle:
+ *
+ *   - `selection.*` — chrome reflecting committed selection state
+ *     (persists between actions).
+ *   - `action.*` — chrome that only exists during an in-flight
+ *     action (vanishes on commit / cancel).
+ *   - `snap.*` — snapping system chrome (guides, target highlights).
+ *   - `grid`, `debug.*` — environment chrome.
+ *
+ * The intersection `(string & {})` keeps the union open so consumers
+ * can register their own ids; the kit's built-ins are listed
+ * explicitly for autocomplete.
+ */
+type ChromeId = 'selection.outline' | 'selection.resize-handles' | 'selection.rotation-handle' | 'action.marquee' | 'action.lasso' | 'action.move-ghosts' | 'action.insert-preview' | 'action.polyline' | 'snap.guides' | 'snap.targets' | 'grid' | (string & {});
+/**
+ * Consumer override map. Merged on top of the kit's
+ * `defaultVisibilityRules`; absent keys fall through to defaults,
+ * absent ids fall through to `always`. Entries may be either fluent
+ * `Condition` instances OR raw `Rule` trees — the resolver normalizes.
+ */
+type VisibilityRules = Partial<Record<ChromeId, Condition | Rule>>;
+
+/**
+ * Promote a Rule tree to a fluent Condition. The function form evaluates
+ * the tree against a RuleCtx; combinator methods produce new Conditions
+ * wrapping `all`/`any`/`not` nodes.
+ *
+ * **Chain semantics: strict left-to-right.** No boolean precedence.
+ * `focused.or(hovering).and(selectionIs(1))` evaluates
+ * `((focused || hovering) && selectionIs(1))` — NOT
+ * `(focused || (hovering && selectionIs(1)))` as standard precedence
+ * would give. For grouped disjunction, use the top-level `or` / `and` /
+ * `not` helpers or name intermediates.
+ *
+ * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
+ * produces `{ all: [a, b, c] }` rather than `{ all: [{ all: [a, b] }, c] }`.
+ * Canonical form simplifies downstream introspection.
+ *
+ * Use {@link when} for the inline-lambda escape hatch.
+ */
+declare function cond(rule: Rule): Condition;
+/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
+declare function when(fn: (ctx: RuleCtx) => boolean): Condition;
+/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
+ *  semantics ambiguous. */
+declare function and(...cs: (Condition | Rule)[]): Condition;
+/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
+ *  `.and` to make grouping explicit. */
+declare function or(...cs: (Condition | Rule)[]): Condition;
+/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
+ *  instead; this is for the lead-with-negation case. */
+declare function not(c: Condition | Rule): Condition;
+/** Always true. The fallback for any chrome id without a registered rule. */
+declare const always: Condition;
+/** Always false. Useful for "turn this chrome off entirely":
+ *  `chromeVisibility={{ 'snap.guides': never }}`. */
+declare const never: Condition;
+/** Canvas surface currently focused. */
+declare const focused: Condition;
+/** Any action currently in flight (read: user is gesturing). */
+declare const gesturing: Condition;
+/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
+declare const actionIs: (kind: string) => Condition;
+/** Nothing selected. */
+declare const selectionEmpty: Condition;
+/** Exactly `n` items selected. */
+declare const selectionIs: (n: number) => Condition;
+/** At least `n` items selected. `selectionAtLeast(1)` is the common
+ *  "something is selected" check. */
+declare const selectionAtLeast: (n: number) => Condition;
+/** Multi-mode handle behavior active (single shared union-bounds
+ *  handle vs per-item handles). Implemented as a `when` because
+ *  `multiActive` is a derived single-call read on RuleCtx, not a
+ *  selector-table key. Stable; safe to introspect. */
+declare const multiActive: Condition;
+/** Pointer is hovering some node. */
+declare const hovering: Condition;
+/** Pointer is hovering a node that is currently selected. */
+declare const hoveringSelected: Condition;
+/** Named modifier key currently held. */
+declare const modifierHeld: (m: keyof ModifierState) => Condition;
+/** View scale (uniform or geometric mean for non-uniform) is at least
+ *  `z`. Useful for "hide hairline chrome at low zoom" rules. */
+declare const zoomAtLeast: (z: number) => Condition;
+/** Active mode equals `m`. */
+declare const modeIs: (m: string) => Condition;
+/** Active mode is one of `modes`. */
+declare const modeIn: (modes: readonly string[]) => Condition;
+/** Active mode is NOT `m`. */
+declare const modeNot: (m: string) => Condition;
+/** Active mode's `allows` includes capability `cap`. */
+declare const capabilityIs: (cap: string) => Condition;
+/** Active mode's `allows` includes ANY of `caps` (OR). */
+declare const capabilityIn: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` includes ALL of `caps` (AND). */
+declare const capabilityAll: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` does NOT include capability `cap`. */
+declare const capabilityNot: (cap: string) => Condition;
+/** Primary pointer is imprecise (touch, most styluses). Absent device
+ *  profile → false, so a rule written with this atom is inert on the
+ *  mouse-shaped default rather than silently flipping. */
+declare const coarsePointer: Condition;
+/** Primary pointer can hover. Absent device profile → true. Pair with
+ *  `not(...)` to gate chrome that only makes sense with a hovering
+ *  pointer: `not(canHover)` is "this device cannot hover". */
+declare const canHover: Condition;
+
+/**
+ * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
+ * at resolve time; consumer entries take precedence per id.
+ *
+ * Written as literal Rule trees rather than fluent chains so the inputs
+ * each rule depends on are immediately visible. The fluent atoms compile
+ * to the same trees; either form is valid in a VisibilityRules entry.
+ *
+ * Gating is written in terms of **capabilities, not mode ids**. A
+ * capability rule keeps holding when a new mode is added that permits the
+ * same thing; a mode rule has to be found and edited every time. There is
+ * no `mode:` rule left in this table — the `path-edit.*` chrome used to be
+ * the exception, on the theory that it's the visual signature of one mode;
+ * see the comment on those rules below for why that was wrong in both
+ * directions and what replaced it.
+ *
+ * Chrome that gates on the *absence* of a capability (the selection
+ * outline, suppressed while an anchor-editing overlay owns the visuals)
+ * uses `capability: { not: … }` for the same reason.
+ */
+declare const defaultVisibilityRules: VisibilityRules;
+
+/**
+ * Build the per-frame visibility check. Merges consumer rules on top
+ * of the kit defaults, then closes over `ctx` so each chrome-id
+ * lookup runs its rule against the current state.
+ *
+ * `VisibilityRules` entries may be either fluent `Condition` values
+ * (callable) or raw `Rule` trees — we normalize at lookup time.
+ *
+ * Predicates are O(1) and run once per chrome id per frame; no
+ * memoization in v1 — profile before adding any.
+ *
+ * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
+ * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
+ * opted into modality behaves exactly like one sitting in normal mode.
+ */
+declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
+
+/**
+ * Pure assembler for {@link ChromeCtx}.
+ *
+ * Called once per frame on the rendering side from whichever surface
+ * needs to evaluate visibility rules — `composeAffordanceLayer`,
+ * `createSelectionOverlayLayer`, the dispatcher overlay layer, etc.
+ *
+ * Sources are passed as plain getters / values rather than the live
+ * objects they come from. This keeps `chrome-caps` from depending on
+ * React, the dispatcher's concrete type, or `ChromeState`'s bounds
+ * machinery — the same builder works from a test harness, a Storybook
+ * fixture, or `<SceneCanvas>`.
+ */
+
+/** The pieces of live canvas state a `ChromeCtx` is assembled from. */
+interface BuildChromeCtxArgs {
+    focused: boolean;
+    selection: readonly NodeId[];
+    multiActive: boolean;
+    modifiers: ModifierState;
+    action: {
+        kind: string | null;
+        id: string | null;
+    };
+    hover: NodeId | null;
+    view: View;
+}
+/** Gather the current canvas state into the context that chrome-visibility
+ *  rules are evaluated against. Rebuilt per frame. */
+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 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`.
+ *
+ * No re-render: the ref updates silently, and the next render that
+ * reads it picks up the fresh value. Chrome-caps rules are evaluated
+ * during paint, so the hover state is always read fresh.
+ */
+
+/** Options for `useHoverTracking`. */
+interface UseHoverTrackingArgs {
+    canvasRef: RefObject<HTMLElement | null>;
+    /** 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;
+}
+/** Track which node the pointer is over. Returns a getter rather than state,
+ *  so per-frame code can read the current value without the hover re-rendering
+ *  the component on every pointer move. */
+declare function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null;
+
 /** Standard slot names — render in this canonical order.
  *  `cellHighlight` is internal: emitted from the `grid` slot's nested
  *  `highlight` config, not a top-level layer key. */
@@ -3667,6 +4171,108 @@ interface CustomLayerEntry {
     before?: StandardSlotName | (string & {});
 }
 
+/** 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.
+     *
+     *  A thunk is a camera derived from the canvas's — a loupe following the
+     *  pointer — read fresh at every paint and every event, so the two cannot
+     *  disagree mid-gesture. It is controlled: a pan inside the view reaches
+     *  only `onViewChange`. */
+    view?: View | ((outer: View, dims: Dims) => 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>[];
+    /**
+     * Show or hide layers in this view only, by id — the map `<Canvas>` takes,
+     * applied after `layers` narrows the stack. A scene layer paints as
+     * `scene:<layerId>`; one hidden here neither paints nor picks in this view,
+     * and a marquee or Cmd+A routed here passes over it. The surface and every
+     * other view are unaffected.
+     */
+    layerVisibility?: Record<string, boolean>;
+    /** Draw order for this view, by layer id, bottom first. A listed order is
+     *  the whole list, so a layer left out of it is neither painted nor picked
+     *  here. */
+    layerOrder?: string[];
+    /** 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;
+    /**
+     * Whether input over the view resolves through its camera. Default `true`:
+     * a press selects what the view shows, and a drag moves it in the view's
+     * world units. `false` paints only, and input over it reaches the canvas
+     * beneath as though the view were not there.
+     *
+     * Views do not nest. A view paints and routes the surface's own stack,
+     * never another view; overlapping views are hit in paint order.
+     */
+    interactive?: boolean;
+    /**
+     * Whether the surface paints the view. Default `true`. `false` is for a
+     * host that draws the view inside chrome of its own — a HUD window's
+     * interior — through `SceneCanvasApi.addView`'s `draw`, so it lands in
+     * that chrome's z-order rather than the surface's.
+     */
+    paint?: boolean;
+    /** 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;
+}
+/**
+ * @experimental
+ *
+ * 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.
+ */
+declare function CanvasView(props: CanvasViewProps): null;
+
+/**
+ * A view added through {@link SceneCanvasApi.addView}.
+ * @experimental
+ */
+interface CanvasViewHandle {
+    readonly id: string;
+    /** Paint the view for one frame of the canvas: its layers through its own
+     *  camera, clipped to its rect. For a view added with `paint: false`, whose
+     *  host draws it; empty until the view has mounted. */
+    draw(data: unknown, outer: View, dims: Dims): DrawCommand[];
+    /** Stop painting and routing the view. */
+    remove(): void;
+}
 /**
  * The **base imperative ref handle** shared by the canvas components. For
  * `<SceneCanvas>` refs use {@link SceneCanvasApi} (this type plus the
@@ -3700,8 +4306,23 @@ interface CanvasExtensionApi {
      *
      *  Under `paintInto` this is the caller's shared canvas, which co-tenant
      *  panes also paint into: its rect is the whole surface, not this pane's, so
-     *  read geometry off {@link element} rather than off this. */
+     *  read geometry off {@link element} rather than off this, and find this
+     *  pane's pixels on it with {@link getSurfaceRect}. */
     readonly surface: HTMLCanvasElement | null;
+    /**
+     * The rect of {@link surface} this canvas paints into, in the surface's CSS
+     * px — the rect the renderer is confined to. Under `paintInto` that is the
+     * pane's `x`/`y` and this canvas's size; otherwise the whole canvas at the
+     * origin. A point measured against {@link element} sits at
+     * `(x + px, y + py)` on the surface, which is where a readback must look.
+     * Read live: the value is the one the next paint uses.
+     */
+    getSurfaceRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
     requestRedraw(): void;
     /**
      * Run `fn` after every paint, on the frame that painted — for chrome that
@@ -3786,6 +4407,10 @@ interface CanvasExtensionApi {
         x: number;
         y: number;
     }): void;
+    /** Add a view to the canvas from outside React. See
+     *  {@link SceneCanvasApi.addView}; absent on the bare-primitive handle,
+     *  which hosts no views. */
+    addView?(props: CanvasViewProps): CanvasViewHandle;
 }
 /**
  * The imperative ref handle for `<SceneCanvas>` — everything on
@@ -3809,6 +4434,16 @@ interface SceneCanvasApi extends CanvasExtensionApi {
     /** Cancel a camera animation. The view stays where it is. */
     stopViewAnimation(): void;
     isViewAnimating(): boolean;
+    /**
+     * Add a view — the same declaration as a `<CanvasView>` child, for code
+     * outside React: chrome that opens a lens, a panel a plugin owns. Input over
+     * it resolves through its camera unless `interactive` is `false`.
+     *
+     * Pass thunks for `bounds` and `view` rather than re-adding to move it.
+     * Adding an id already present replaces that view.
+     * @experimental
+     */
+    addView(props: CanvasViewProps): CanvasViewHandle;
 }
 
 /**
@@ -4016,7 +4651,10 @@ interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHe
  * 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.
+ * `matches` predicate returns true paints the node. Every built-in but
+ * `kit:derived` additionally requires a rect-shaped pose — a scene whose
+ * poses are some other shape matches none of them, and paints through a
+ * consumer painter or not at all.
  *
  * Two priority tiers:
  *   - `'high'` — checked before all `'normal'` entries. Use this to
@@ -4050,6 +4688,10 @@ interface NodePaintCtx {
      *  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;
+    /** A node's animated per-anchor colors: given the colors a painter would paint
+     *  on `channel`, the colors to paint instead. **Absent** when nothing animates
+     *  the node. The kit's path painters apply it; see `withColorOverrides`. */
+    vertexColors?: (channel: VertexColorChannel, base: readonly number[] | undefined) => readonly number[] | undefined;
 }
 /**
  * Per-node draw function — the scene-slot `drawOne` signature shared by
@@ -4069,7 +4711,9 @@ interface NodeShapeEntry<TData = unknown, TPose = unknown> {
      *  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. */
+     *  painter (`'high'` tier first, then `'normal'`) wins. The kit's own
+     *  painters also require a rect-shaped pose, since their geometry reads
+     *  `x`/`y`/`width`/`height` off it. */
     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
@@ -4227,11 +4871,9 @@ declare function getNodeShapes(): readonly NodeShapeEntry[];
  * `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.
+ * **Pose shape:** TPose is generic; callers pass `poseDescriptor` for poses
+ * `AUTO_POSE_DESCRIPTOR` can't read. Container ids reduce via `unionAABB`
+ * over the projected AABBs.
  */
 
 /** Options for `composeSelectionPose`. */
@@ -4253,19 +4895,8 @@ interface ComposeSelectionPoseOpts<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
-     * a container's leaves into a single union AABB. Defaults to the identity —
-     * for `Path` poses pass `(b) => ({ kind: 'rect', ...b })`.
-     */
-    fromBounds?: (bounds: Bounds) => TPose;
+    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Walk a container's direct children (e.g. `scene.childrenOf`). With
      *  `isContainer`, a selected container resolves to the union AABB of its
      *  transitive leaf poses instead of its own stored pose. */
@@ -4285,12 +4916,8 @@ declare function composeSelectionPose<TPose>(opts: ComposeSelectionPoseOpts<TPos
  *  declared on {@link SelectionOverlayLayerOpts}, which makes both optional —
  *  omitted, they come off the draw envelope. */
 interface SelectionLayerCommon<TPose> {
-    /**
-     * Project a pose into its AABB. Defaults to the identity — rect-shaped
-     * poses (`{x, y, width, height}`) need no override. For `Path` poses pass
-     * `boundsOfPath`.
-     */
-    getBounds?: (pose: TPose) => Bounds;
+    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Walk a container's direct children (e.g. `scene.childrenOf`). When
      *  supplied with `isContainer`, any id that resolves to a container is
      *  rendered using the union bounds of all its transitive leaves. */
@@ -4388,6 +5015,10 @@ interface HierarchicalAdapter<TNode, TPose> {
     getNode(id: string): TNode | undefined;
     getChildren(parentId: string | null): readonly string[];
     getPose(id: string): TPose;
+    /** Folds a child's local pose into its parent's frame. Absent means the
+     *  scene stores absolute poses and a parent contributes no transform —
+     *  see `PoseComposition`. */
+    composePose?(parent: TPose, child: TPose): TPose;
 }
 
 /**
@@ -4567,16 +5198,15 @@ interface CanvasProps<TNode extends {
      */
     selection?: SelectionApi;
     /**
-     * Pose↔bounds projection for non-rect `TPose` types. When supplied, drives
-     * the default `boundsOf` fallback and the selection-overlay bounds source so
-     * non-rect poses (e.g. `Path`) don't require per-prop overrides.
+     * How to read and rewrite a pose. Drives the default `boundsOf` fallback and
+     * the selection-overlay bounds.
      * Defaults to the rect identity (`AUTO_POSE_DESCRIPTOR`).
      *
      * This is a math helper, not a scene-shaped concern — it converts a pose
      * value to an AABB and extracts rotation for the selection chrome. Bare-
      * Canvas consumers that use a non-rect pose type should supply this.
      */
-    geometry?: PoseProjection<TPose>;
+    poseDescriptor?: PoseDescriptor<TPose>;
     /**
      * Used by `PickHud` to display the list of ids under the cursor.
      * NOT used for tool routing — see `getNodeAtPoint` for that.
@@ -4586,7 +5216,7 @@ interface CanvasProps<TNode extends {
     pickEvery?: (worldX: number, worldY: number) => string | string[] | null;
     /**
      * Override for committed bounds lookup. When supplied, takes precedence over
-     * the `geometry`-derived fallback. Used by the selection overlay, the
+     * the `poseDescriptor`-derived fallback. Used by the selection overlay, the
      * multi-select union AABB, and `helpersRef.getEffectiveBounds`. Optional —
      * bare-Canvas consumers that use a custom bounds shape should supply this;
      * `<SceneCanvas>` derives it from its scene adapter and passes it via the
@@ -4851,6 +5481,12 @@ interface ReorderAdapter {
  *  touch an adapter directly. */
 type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node$1<TData, TLayer, TPose>, TPose> & ResizeAdapter<Node$1<TData, TLayer, TPose>, TPose> & RotateAdapter<Node$1<TData, TLayer, TPose>, TPose> & AreaSelectAdapter & LassoSelectAdapter & LayerEnumerableAdapter<TLayer> & ReorderAdapter & Partial<InsertAdapter<Node$1<TData, TLayer, TPose>>> & {
     getParent(id: string): string | null;
+    /** The node's pose with every ancestor's frame folded in. Equal to
+     *  `getPose` unless a `poseComposition` is configured. */
+    getWorldPose(id: string): TPose;
+    /** Present only when a composing strategy is configured; the render
+     *  walk feature-detects it. */
+    composePose?(parent: TPose, child: TPose): TPose;
     getSelection(): string[];
     setSelection(ids: string[]): void;
     insertNode(node: Node$1<TData, TLayer, TPose>, index?: number): void;
@@ -4890,10 +5526,8 @@ interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
      *  fine for read-only or selection-less canvases, but the marquee gesture
      *  won't update any external selection state. */
     selection?: SceneAdapterSelection;
-    /** Project a pose to an AABB for `hitTestArea`. Default: identity (works
-     *  when TPose carries top-level x/y/width/height). Override for non-rect
-     *  poses. */
-    poseBounds?: (pose: TPose) => Bounds;
+    /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Layout strategies keyed by container node id. When a container is
      *  configured here, `move` runs its layout-aware pass on drag (reflow on
      *  enter, reflow leftovers on exit, reparent + write reflowed poses on
@@ -4901,14 +5535,16 @@ interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
      *  either a static map, or a `getLayout(id)` function for dynamic
      *  resolution. */
     layouts?: Record<string, LayoutStrategy<TPose>> | ((containerId: string) => LayoutStrategy<TPose> | null);
-    /** When set, `setPose(id, ...)` on a container node cascades the translation
-     *  to every descendant. Scene v1 stores absolute poses, so dragging a
-     *  container needs to translate its children to keep them visually attached
-     *  to their parent. Pass `'rect'` to use the built-in `translateRectPose`
-     *  (works for any `TPose extends { x: number; y: number }`); pass a custom
-     *  `(pose, dx, dy) => pose` for non-rect pose shapes. Omit to leave setPose
-     *  primitive — containers move but their descendants don't follow. */
-    cascadeContainerPose?: 'rect' | ((pose: TPose, dx: number, dy: number) => TPose);
+    /** When true, `setPose` on a container translates every descendant by the
+     *  same delta, through the pose descriptor. Scene v1 stores absolute poses,
+     *  so without it children stay behind. */
+    cascadeContainerPose?: boolean;
+    /** How a child's stored pose folds into its parent's frame. Omit for the
+     *  absolute-pose model, where a parent contributes no transform. Supplying a
+     *  composing strategy makes a container's pose a **frame**: rotating the
+     *  container rotates its contents, and `setPose` on it must not also
+     *  translate them, so it cannot be combined with `cascadeContainerPose`. */
+    poseComposition?: PoseComposition<TPose>;
 }
 /** Derive the adapter for a scene. Reads go straight to the scene; writes are
  *  ops applied through its history, so anything done through the adapter is
@@ -4933,27 +5569,17 @@ declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Sce
  *  Consumers should import from here directly; `rotate.ts` re-exports the
  *  same symbols for back-compat. */
 
-/** Projects a pose to and from a rotated bounding box, so the rotate action
- *  can work on pose shapes that carry rotation differently. */
-interface RotateGeometry<TPose> {
-    getRotatedBounds(pose: TPose): RotatedPose;
-    /** Write a new rotation back into the pose; bounds stay the same. */
-    withRotation(pose: TPose, rotation: number): TPose;
-}
 /** Options for the `rotate` action. */
 interface UseRotateOptions<TPose> {
     /** Behaviors are typed against the pose shape; the kit ships none yet
      *  (rotation snap behaviors are deferred). For non-rect TPose, behaviors
-     *  are typed `never` until you supply a `geometry`. */
+     *  are typed `never` for a pose without a numeric `rotation`. */
     behaviors?: TPose extends RotatedPose ? RotateBehavior<TPose>[] : never;
     rotateLabel?: string;
     /** Reserved; rotate is never transient in practice. Ignored. */
     transient?: boolean;
     onGestureStart?: (id: string) => void;
     onGestureEnd?: (committed: boolean) => void;
-    /** Project pose ↔ rotated bounds. Defaults to the identity for
-     *  `RotatedPose`. Required for non-rect TPose (e.g. a rotated path). */
-    geometry?: RotateGeometry<TPose>;
     /** Optional debug sink. When supplied, records the rotation-handle
      *  position + circular hitbox at gesture start. Tree-shakes via
      *  optional-chain when omitted. */
@@ -4974,60 +5600,95 @@ interface UseRotateOptions<TPose> {
     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;
-}
 /**
- * @experimental
+ * The kit's built-in shape kinds — one table, every other spelling derived.
  *
- * 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.
+ * Lives in `core/` rather than beside the shape tools because both layers ask
+ * questions of the same set: the interactions layer decides whether
+ * `insertAction` can paint a live preview for a kind, and the canvas layer
+ * decides which shape tools `useBuiltinShapeTools` mounts and what
+ * `BUNDLE_TOOLS` / `defaultNodeRouting` / `defaultNodeProperties` enumerate.
  *
- * Renders nothing itself — it is a declaration, and the surface does the
- * drawing. Outside a surface that mounts a view registry it is inert.
+ * This module imports nothing on purpose: `useBuiltinShapeTools` imports the
+ * package barrel, so anything barrel-reachable that needs these lists at
+ * module-evaluation time must not route through it.
  */
-declare function CanvasView(props: CanvasViewProps): null;
+/** What the kit knows about one built-in shape kind. */
+interface ShapeKindDescriptor {
+    /** Mounted as a built-in shape tool by `useBuiltinShapeTools`, and so a
+     *  member of `BuiltinShapeToolId` / `KIT_SHAPE_KINDS`. `image` is false:
+     *  `useImageTool` needs a `src` and can't be auto-mounted. */
+    readonly tool: boolean;
+    /** `insertAction` emits an `insertPreview` overlay for this kind, and the
+     *  dispatcher overlay layer knows how to draw it. Kinds without one still
+     *  commit; they just have no live drag preview (`pen` and `lasso` don't
+     *  route through `insertAction` at all). */
+    readonly insertPreview: boolean;
+}
+/**
+ * Declaration order is the enumeration order of every derived list —
+ * `KIT_SHAPE_KINDS`, and through it `defaultNodeRouting` /
+ * `defaultNodeProperties` / `BUNDLE_TOOLS.exhaustive`.
+ */
+declare const SHAPE_KINDS: {
+    readonly rect: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly ellipse: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly line: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly polygon: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly star: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly pen: {
+        readonly tool: true;
+        readonly insertPreview: false;
+    };
+    readonly pencil: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly lasso: {
+        readonly tool: true;
+        readonly insertPreview: false;
+    };
+    readonly text: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly image: {
+        readonly tool: false;
+        readonly insertPreview: true;
+    };
+};
+/** The keys of a shape-kind table whose descriptor sets `F` to `true`. */
+type ShapeKindsWhere<T, F extends keyof ShapeKindDescriptor> = {
+    [K in keyof T]: T[K] extends Record<F, true> ? K : never;
+}[keyof T];
+/**
+ * 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`.
+ */
+type BuiltinShapeToolId = ShapeKindsWhere<typeof SHAPE_KINDS, 'tool'>;
+/** The insert kinds the kit's dispatcher overlay layer knows how to render.
+ *  Consumer-defined kinds fall outside it: no live preview, commit unaffected. */
+type KitInsertShape = ShapeKindsWhere<typeof SHAPE_KINDS, 'insertPreview'>;
+/** 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 BuiltinShapeToolId[];
 
 /** Per-tool option overrides for the built-in shape/lasso tools.
  *  Each entry is a narrow subset of the underlying hook's options surface
@@ -5230,7 +5891,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' | 'contentVersion'> & {
+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' | 'layers' | 'onBackgroundClick' | 'getIsVisible' | 'contentVersion' | 'layerVisibility' | 'layerOrder'> & {
     /** 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
@@ -5258,6 +5919,12 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      *  to `sceneToAdapter` so `useMove`'s layout pass runs on configured
      *  containers (reflow on enter, reparent + reflow on commit). */
     layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];
+    /** How a child's stored pose folds into its parent's frame. Omit for the
+     *  absolute-pose model, where a container groups its children but imposes
+     *  no transform. Pass `RIGID_POSE_COMPOSITION` to make a container's pose
+     *  a frame, so rotating it rotates its contents and moving it carries them
+     *  without touching their poses. */
+    poseComposition?: SceneToAdapterOptions<TData, TLayer, TPose>['poseComposition'];
     /**
      * Optional consumer seam for eager geometry sync: lets pose-transform
      * actions (move, resize, nudge, flip — NOT rotate) also rewrite a node's
@@ -5294,6 +5961,10 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * it with extras is what needs the memo.)
      */
     routing?: readonly NodeRoutingEntry[];
+    /** How to read and rewrite this scene's poses. Every built-in action,
+     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`
+     *  (rect poses and `Path` poses). */
+    poseDescriptor?: PoseDescriptor<TPose>;
     geometry?: {
         /** Hit-test override. Return the topmost id, the full back-to-front hit
          *  stack (`string[]`), or `null` for empty space. The stack form lets a
@@ -5577,9 +6248,9 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
     /**
      * Optional animator to bind for per-frame redraws. When supplied,
      * SceneCanvas subscribes to `animator.onTick` and requests a redraw on
-     * every active animation frame. This is the supported way to drive
-     * repaints when an animation's effect is read from a non-scene channel
-     * (e.g. a custom `drawOne` consults `animator.colorOverrides`) — scene
+     * every active animation frame, and paints `animator.colorOverrides`
+     * onto the scene's nodes: the kit's path and shape painters apply them,
+     * and a custom `drawOne` receives them as `ctx.vertexColors`. Scene
      * mutations trigger repaints automatically, but `colorOverrides` writes
      * do not.
      *
@@ -5702,6 +6373,25 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * Defaults to `() => 1` (no effect).
      */
     alphaFor?: (id: string) => number;
+    /**
+     * Show or hide render layers in this canvas's own view, by id — the map
+     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed
+     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer
+     * here and nowhere else.
+     *
+     * A layer hidden this way is gone from this view: it does not paint, and a
+     * click, a marquee or Cmd+A here passes over it. Another view of the same
+     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and
+     * can still take it. It applies on top of the scene's own
+     * `LayerRecord.visible` and cannot show a layer the scene hides.
+     */
+    layerVisibility?: Record<string, boolean>;
+    /**
+     * Draw order for this view, by render-layer id, bottom first. A listed
+     * order is the whole list: a scene layer left out of it is neither painted
+     * nor picked here. See `CanvasProps.layerOrder`.
+     */
+    layerOrder?: string[];
     /**
      * Optional per-id pointer-interactivity predicate. When supplied, ids
      * for which the predicate returns `false` are excluded from hit-test
@@ -6008,6 +6698,194 @@ declare const defaultNodeProperties: readonly NodePropertiesEntry[];
  */
 declare const inferredNodeProperties: readonly NodePropertiesEntry[];
 
+/**
+ * What an in-flight gesture is proposing, resolved against the committed scene.
+ *
+ * An ongoing action publishes interim poses on its handle rather than writing
+ * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only
+ * thing that knew how to read them: which ids are in flight, which of those are
+ * roots, whose preview wins when two sources name the same id, and which are
+ * merely displaced rather than dragged. None of that is about drawing, and a
+ * consumer with its own renderer needs all of it.
+ */
+
+interface PreviewNode<TData, TLayer extends string, TPose> {
+    id: NodeId;
+    /** The node as committed — the gesture has not touched the scene. */
+    node: Node$1<TData, TLayer, TPose>;
+    /** The interim pose, or the committed one when only data is in flight. */
+    pose: TPose;
+    /** The interim data, or the committed one when only the pose is in flight. */
+    data: TData;
+    /**
+     * The gesture is not carrying this one under the pointer — a layout sibling
+     * reflowing into its destination slot. It reads better painted settled.
+     */
+    opaque: boolean;
+    /** Previewed descendants, so a container's ghost brings its children. */
+    children: PreviewNode<TData, TLayer, TPose>[];
+}
+/**
+ * The previewing subtrees, as roots. A previewed node whose parent is also
+ * previewing is a child of that parent's entry rather than a root of its own,
+ * which is what lets a caller draw a container and its contents as one thing.
+ *
+ * An id with no node is skipped: an insert previews before the node it will
+ * create exists. So is an id no source has a pose or data for.
+ */
+declare function resolvePreviews<TData, TLayer extends string, TPose>(sources: Iterable<GesturePreviewSource>, scene: Scene<TData, TLayer, TPose>): PreviewNode<TData, TLayer, TPose>[];
+/** Every entry in the forest, parents before their children. */
+declare function flattenPreviews<TData, TLayer extends string, TPose>(roots: readonly PreviewNode<TData, TLayer, TPose>[]): PreviewNode<TData, TLayer, TPose>[];
+
+/**
+ * The one answer to "how big is the thing this in-flight insert is making".
+ *
+ * A drag-to-insert has no scene node until commit, so three surfaces have to
+ * size the nascent shape themselves: `useDispatcherOverlayLayer` (paints the
+ * preview), `canvas/deps/insert` (poses the committed node) and
+ * `dispatcherGestureBounds` (reports the gesture's world AABB to `<Canvas>`).
+ * They all resolve it here.
+ *
+ * The drag AABB alone is NOT the answer. `insertAction` hands over an
+ * `extras` payload that can carry richer geometry than the drag rect —
+ * a polygon's center+radius, a pencil's sample trail, a line's endpoints —
+ * and where it does, that geometry is the shape. A centered Alt-drag
+ * produces a `d`-wide drag rect around a `d√2` circumradius; a pencil that
+ * loops back to its start produces a zero-area drag rect around a trail that
+ * swept the page.
+ */
+
+type Point$2 = {
+    x: number;
+    y: number;
+};
+/** The fields of an `insertPreview` overlay this needs. `canvas/deps/insert`
+ *  passes the equivalent from its own `(bounds, extras)` commit arguments. */
+interface InsertPreviewLike {
+    shape: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    extras: unknown;
+}
+/** Resolved preview geometry, in the terms the path builders take. */
+type InsertPreviewGeometry = {
+    kind: 'box';
+} | {
+    kind: 'line';
+    a: Point$2;
+    b: Point$2;
+} | {
+    kind: 'polygon';
+    center: Point$2;
+    radius: number;
+    sides: number;
+    rotation: number;
+} | {
+    kind: 'star';
+    center: Point$2;
+    outerRadius: number;
+    innerRadius: number;
+    points: number;
+    rotation: number;
+} | {
+    kind: 'pencil';
+    samples: ReadonlyArray<Point$2>;
+};
+interface InsertPreviewExtent {
+    /** The insert kind, verbatim from the caller. */
+    shape: string;
+    /** World-space AABB of `geometry` — the extent. */
+    bounds: Bounds;
+    geometry: InsertPreviewGeometry;
+}
+type InsertPreviewOverlay = Extract<OngoingOverlay, {
+    kind: 'insertPreview';
+}>;
+declare function insertPreviewExtent(ov: InsertPreviewLike): InsertPreviewExtent;
+
+/**
+ * What an in-flight gesture is proposing to paint *beside* the scene, resolved
+ * to geometry.
+ *
+ * The sibling of `resolvePreviews`: that one answers for the ghosts of scene
+ * nodes a gesture is displacing, this one for the chrome a gesture draws that
+ * is no node at all — a marquee rect, a lasso trail, the outline of a shape
+ * being dragged out. `<SceneCanvas>`'s `useDispatcherOverlayLayer` used to be
+ * the only thing that knew how to read an `OngoingOverlay`, and it read one
+ * straight into `DrawCommand`s, so a consumer with its own renderer got
+ * nothing. None of the normalizing is about drawing.
+ *
+ * What stays out, as in `resolvePreviews`: no view, no screen projection, no
+ * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.
+ */
+
+type Point$1 = {
+    x: number;
+    y: number;
+};
+/**
+ * The chrome-caps id a surface consults before painting each variant. The
+ * gating itself is the painter's — two views of one surface may disagree about
+ * whether to show an in-flight marquee — but the id is not something a caller
+ * should have to guess.
+ */
+type OverlayVisibilityId = 'action.marquee' | 'action.lasso' | 'action.insert-preview' | 'action.polyline';
+/**
+ * One in-flight overlay, in world coordinates.
+ *
+ * Every degenerate overlay is already gone: a marquee of zero size, a lasso
+ * under two vertices, a zero-area insert of anything but a pencil, a pencil
+ * under two samples, a run of fewer than two points. Whatever is in this list
+ * is worth painting.
+ */
+type ResolvedOverlay = {
+    kind: 'marquee';
+    visibilityId: 'action.marquee';
+    /** The drag normalized: `start`/`current` in either order, one AABB. */
+    bounds: Bounds;
+    /** Additive intent. Core's 2D layer paints the same rect either way. */
+    shiftHeld: boolean;
+} | {
+    kind: 'lasso';
+    visibilityId: 'action.lasso';
+    /** The trail so far, at least two long. The region it encloses is the
+     *  trail closed back to its first vertex. */
+    vertices: ReadonlyArray<Point$1>;
+    /** Live pointer position — the trail's last vertex until it advances. */
+    current: Point$1;
+    shiftHeld: boolean;
+} | {
+    kind: 'insertPreview';
+    visibilityId: 'action.insert-preview';
+    shape: KitInsertShape;
+    /** Extent of `geometry`, which for a radial or freehand shape is not the
+     *  drag rect. See `insertPreviewExtent`. */
+    bounds: Bounds;
+    geometry: InsertPreviewGeometry;
+    /** The drag's anchor — a growth axis to mark. Absent for a pencil, which
+     *  has none. */
+    anchorPoint?: Point$1;
+    /** The action's per-shape payload, verbatim. Carries what geometry
+     *  cannot: an image insert's `src`, say. */
+    extras: unknown;
+} | {
+    kind: 'polyline';
+    visibilityId: 'action.polyline';
+    /** The run, at least two long, open — the last point does not join the
+     *  first. A closed sweep is a `lasso`. */
+    points: ReadonlyArray<Point$1>;
+    /** What the run is, for a painter choosing a style. Never defaulted
+     *  away: `'chrome'` when the action named none. A role the painter has
+     *  no style for is drawn as plain chrome, not dropped. */
+    role: OverlayRole;
+};
+/** The overlays worth painting, in the order the handles published them. */
+declare function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[];
+
 /**
  * `renderSceneToCanvas` — substrate for detached, read-only scene views
  * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,
@@ -6027,6 +6905,18 @@ declare const inferredNodeProperties: readonly NodePropertiesEntry[];
  * in sync by hand where it matters (DPR handling, viewToMat3 wrap).
  */
 
+/**
+ * Which scene layers a detached view paints, on top of each layer's own
+ * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —
+ * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.
+ */
+interface SceneViewLayers {
+    /** `false` hides that layer in this view. It cannot show one the scene hides. */
+    layerVisibility?: Record<string, boolean>;
+    /** Paint order, bottom first. A listed order is the whole list: a scene
+     *  layer left out of it is not painted. */
+    layerOrder?: readonly string[];
+}
 /** 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> {
@@ -6056,6 +6946,13 @@ interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
      *  `alphaFor`. Pass the same function the main canvas uses to keep a
      *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
     alphaFor?: (id: string) => number;
+    /** Per-view layer visibility. See {@link SceneViewLayers}. */
+    layerVisibility?: SceneViewLayers['layerVisibility'];
+    /** Per-view layer order. See {@link SceneViewLayers}. */
+    layerOrder?: SceneViewLayers['layerOrder'];
+    /** Animated vertex colors to paint, typically an animator's
+     *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */
+    colorOverrides?: ColorOverrideRegistry;
     /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`
      *  when available, otherwise 1. Tests typically pin this to 1 or 2. */
     dpr?: number;
@@ -6077,13 +6974,21 @@ interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
  * emit unrotated geometry and let the pose drive it.
  *
  * Output shape follows `buildSceneTree`: one group per **visible** layer, in
- * scene-layer order, each holding one group per node on that layer.
+ * scene-layer order (or `layers.layerOrder`), each holding one group per node
+ * on that layer.
  *
  * Exported for tests and for callers that want to render into something
  * other than a real `<canvas>` (e.g. an offscreen renderer or a
  * snapshot fixture).
  */
-declare function buildSceneViewCommands<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, view: View, drawOne: SceneViewDrawOne<TData, TLayer, TPose>, extraCommands?: ReadonlyArray<DrawCommand>, alphaFor?: (id: string) => number): DrawCommand[];
+declare function buildSceneViewCommands<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, view: View, drawOne: SceneViewDrawOne<TData, TLayer, TPose>, extraCommands?: ReadonlyArray<DrawCommand>, alphaFor?: (id: string) => number, 
+/** How a child's stored pose folds into its parent's frame. Omit for the
+ *  absolute-pose model. */
+poseComposition?: PoseComposition<TPose>, 
+/** This view's own layer visibility and order. */
+layers?: SceneViewLayers, 
+/** Animated vertex colors to paint, typically an animator's `colorOverrides`. */
+colorOverrides?: ColorOverrideRegistry): DrawCommand[];
 /**
  * Render one frame of `scene` at `view` into `canvas`. See module docstring
  * for the design context.
@@ -6127,6 +7032,15 @@ interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {
      *  `alphaFor`. Pass the same function the main canvas uses to keep a
      *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
     alphaFor?: (id: string) => number;
+    /** Hide scene layers in this view only, keyed `scene:<layerId>` as on
+     *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */
+    layerVisibility?: SceneViewLayers['layerVisibility'];
+    /** Paint order for this view, keyed as `layerVisibility`. */
+    layerOrder?: SceneViewLayers['layerOrder'];
+    /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks
+     *  and paints its `colorOverrides`. Pass the main canvas's animator so both
+     *  show the same colors. */
+    animator?: Animator;
     /** Optional CSS class for sizing / positioning the `<canvas>`. The kit
      *  does not emit inline styles for layout — use a class. */
     className?: string;
@@ -6160,7 +7074,7 @@ declare function sceneSelectionStore(scene: {
  *  registry passed in `options`. Throws on unknown version, unknown registry
  *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).
  *  Loaded scenes start with empty history — undo/redo is NOT serialized. */
-declare function sceneFromJSON<TData, TLayer extends string, TPose>(json: SerializedScene<TData, TLayer, TPose>, options: {
+declare function sceneFromJSON<TData, TLayer extends string, TPose>(json: SerializedScene<TData, TLayer, TPose>, options?: {
     registry?: SceneRegistry<TPose>;
     historyLimit?: number;
     coalesceWindowMs?: number;
@@ -6206,18 +7120,116 @@ declare function useScene<TItem extends {
 declare function useScene<TData, TLayer extends string, TPose = RectPose>(options: UseSceneOptions<TData, TLayer, TPose>): Scene<TData, TLayer, TPose>;
 
 /**
- * Pure math helpers for `<MinimapCanvas>`.
+ * Build a {@link PoseOverrides} map.
+ *
+ * `getNode` resolves an id to the node object the painter memo is keyed on —
+ * the only thing this module needs from the scene, and the reason it doesn't
+ * import one. `onInvalidate` lets the scene invalidate derived nodes from the
+ * same chokepoint.
+ */
+declare function createPoseOverrides<TPose>(getNode: (id: NodeId) => {
+    data?: unknown;
+} | undefined, onInvalidate?: (id: NodeId) => void): PoseOverrides<TPose>;
+
+/** The subset of a node this module reads. Structural so a `Node` satisfies
+ *  it without importing the full generic shape. */
+interface PosedNode<TPose> {
+    id: NodeId;
+    kind?: 'leaf' | 'container';
+    pose: TPose;
+    /** Read only by the memo, which keys on its reference alongside the pose. */
+    data?: unknown;
+    dependsOn?: readonly NodeId[] | 'children';
+    derivePose?: (node: never, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
+    /** Read only when something asks a dependency for its `path`. */
+    derivePath?: (node: never, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null;
+}
+/** What resolving a pose needs: the overrides, and enough of the scene to
+ *  reach a node's dependencies. A `Scene` satisfies it. */
+interface PoseSource<TPose> {
+    readonly overrides: Pick<PoseOverrides<TPose>, 'get'>;
+    get(id: NodeId): PosedNode<TPose> | undefined;
+    childrenOf(id: NodeId): readonly NodeId[];
+}
+/**
+ * The pose `node` computes from its dependencies, or `null` when it derives
+ * nothing — it has no `derivePose`, nothing to derive from, or its
+ * `derivePose` returned `null`.
+ *
+ * A dependency is read through {@link effectivePose}, so a group of groups
+ * resolves bottom-up and a dragged dependency's override reaches the
+ * derivation the same frame it is published.
+ */
+declare function derivedPose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose | null;
+/**
+ * `id` as a derivation sees it: the node, the pose it is painted at, and the
+ * path it derives.
+ *
+ * The pose is resolved eagerly — every derivation reads it — and the path
+ * lazily, because most do not and resolving a route costs a router run. Both
+ * resolve *through* this function, so a dependency that is itself derived is
+ * resolved before it is read.
+ */
+declare function derivedDepOf<TPose>(source: PoseSource<TPose>, id: NodeId): DerivedDep<TPose> | undefined;
+/**
+ * The pose the *document* says `node` is at: derived when it derives, else
+ * authored. `effectivePose` minus the override step.
+ *
+ * For a reader that must not see an in-flight gesture — an action capturing
+ * the `from` of a transform op, a placement computed against a sibling. A
+ * derived pose belongs here and an override does not: derivation is what the
+ * document means, an override is what one gesture is currently showing.
+ */
+declare function documentPose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
+/**
+ * The pose to draw, pick and measure `node` at.
  *
- * `computeFitView` derives a `View` that fits a chosen world rect into a
- * minimap canvas of given pixel dims. `computeIndicatorCommand` builds the
- * dashed "visible window" rect — the main canvas's screen window projected
- * into the minimap's own screen coordinates.
+ * The one rule. Every pose a reader acts on comes from here: the three render
+ * walks, the pick walk, the adapters tools and actions commit through.
+ */
+declare function effectivePose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
+
+/** A node and the pose a renderer should draw it at. `node.pose` beside it is
+ *  still the committed pose, so a host has both without a second channel. */
+interface FeedNode<TData, TLayer extends string, TPose> {
+    node: Node$1<TData, TLayer, TPose>;
+    pose: TPose;
+}
+interface FeedDelta<TData, TLayer extends string, TPose> {
+    added: readonly FeedNode<TData, TLayer, TPose>[];
+    removed: readonly NodeId[];
+    changed: readonly FeedNode<TData, TLayer, TPose>[];
+    /** Discard the object map and rebuild. */
+    reset: boolean;
+}
+interface PoseFeed<TData, TLayer extends string, TPose> {
+    subscribe(fn: () => void): () => void;
+    read(): FeedDelta<TData, TLayer, TPose>;
+}
+declare function createPoseFeed<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>): PoseFeed<TData, TLayer, TPose>;
+
+/** Registry key for {@link unionOfChildren}. */
+declare const UNION_OF_CHILDREN = "kit:unionOfChildren";
+/**
+ * A container's pose as the envelope of what it holds — `unionAABB`, so a
+ * rotated member contributes the extent of its ink rather than its unrotated
+ * box. Paired with `dependsOn: 'children'`, this is what makes a group's
+ * bounds track its members instead of freezing at the moment it was made.
  *
- * Neither helper touches GL, the DOM, or the renderer; they're pure
- * functions, unit-testable with `expect`.
+ * Returns `null` for an emptied container, which falls back to its authored
+ * pose — the group stays where the last member left it rather than collapsing
+ * to a zero box at the origin.
  *
- * See `docs/superpowers/specs/2026-05-31-detached-minimap-design.md`.
+ * Reads members as rect poses, and only as rect poses: a scene whose poses are
+ * shaped otherwise gets `null` here and its container keeps its authored pose,
+ * because this entry is registered into every scene and the scene layer holds
+ * no descriptor to read another shape with. To make such a container track its
+ * members, register `unionOfChildrenVia(itsDescriptor)` under
+ * {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.
  */
+declare function unionOfChildren<TPose>(_node: unknown, deps: readonly ({
+    pose: TPose;
+} | undefined)[]): TPose | null;
 
 /**
  * Fallback view returned when there is nothing to fit (empty scene, etc.).
@@ -6227,7 +7239,7 @@ declare const FALLBACK_FIT_VIEW: View;
 /**
  * Fit policy for `<MinimapCanvas>` / `computeFitView`.
  *
- * - `"scene"` — union of leaf-node pose AABBs (via `poseBounds`).
+ * - `"scene"` — union of leaf-node pose AABBs (via the pose descriptor).
  * - `{ kind: "world", rect }` — caller-supplied world rect.
  * - `(scene, dims) => View` — caller derives the view directly.
  */
@@ -6255,7 +7267,7 @@ interface ComputeFitViewOptions {
  * is centered with `padding` (default 8) on each side. The smaller-axis
  * fit ratio wins, so the whole rect is visible.
  *
- * - `fit === "scene"`: union AABB of leaf-node poses via `poseBounds`.
+ * - `fit === "scene"`: union AABB of leaf-node poses via `descriptor`.
  *   Empty scene → {@link FALLBACK_FIT_VIEW}.
  * - `fit` is `{ kind: "world", rect }`: fit `rect`. A degenerate rect
  *   (zero or negative area) falls back to identity scale centered on the
@@ -6263,7 +7275,7 @@ interface ComputeFitViewOptions {
  * - `fit` is a function: called with `(scene, dims)`; its return is
  *   passed through unchanged.
  */
-declare function computeFitView<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, dims: ViewportDims, fit: MinimapFit<TData, TLayer, TPose>, poseBounds: (pose: TPose) => Bounds, opts?: ComputeFitViewOptions): View;
+declare function computeFitView<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, dims: ViewportDims, fit: MinimapFit<TData, TLayer, TPose>, descriptor: PoseDescriptor<TPose>, opts?: ComputeFitViewOptions): View;
 /**
  * Build the visible-window indicator `DrawCommand` for the minimap.
  *
@@ -6315,13 +7327,21 @@ interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
      *  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`. */
-    poseBounds?: (pose: TPose) => Bounds;
+    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
      *  `alphaFor`. Pass the same function the main canvas uses so a
      *  scoping-dim treatment shows up in the minimap too. */
     alphaFor?: (id: string) => number;
+    /** Hide scene layers in the minimap, keyed `scene:<layerId>` as on
+     *  `<SceneCanvas>` — pass the main canvas's map so both show the same set. */
+    layerVisibility?: SceneViewLayers['layerVisibility'];
+    /** Paint order for the minimap, keyed as `layerVisibility`. */
+    layerOrder?: SceneViewLayers['layerOrder'];
+    /** Optional animator: the minimap repaints on its ticks and paints its
+     *  `colorOverrides`. Pass the main canvas's animator so both show the same
+     *  colors. */
+    animator?: Animator;
     /** Visual tuning of the indicator stroke. */
     indicatorStyle?: IndicatorStyle;
     /** CSS class for sizing / positioning the canvas. */
@@ -6385,6 +7405,9 @@ interface RenderSceneToPixelsArgs<TData, TLayer extends string, TPose> {
      *  `alphaFor`. Pass the same function the on-screen canvas uses so an
      *  export matches what the user is looking at. Defaults to `() => 1`. */
     alphaFor?: (id: string) => number;
+    /** Animated vertex colors to paint, typically an animator's
+     *  `colorOverrides`, so an export shows the frame on screen. */
+    colorOverrides?: ColorOverrideRegistry;
     /** Background fill (any CSS color accepted by the renderer). Default:
      *  fully transparent. Passing a color is always valid. */
     background?: string;
@@ -6893,9 +7916,9 @@ declare function renderLabel(ctx: CanvasRenderingContext2D, text: string, x: num
 declare const defaultLabelTextRenderer: TextRenderer;
 
 /**
- * Text RenderLayer. Emits one TextDrawCommand per text node carrying the
- * node's resolved runs and bounding rect. Word wrap and multi-line layout
- * happen downstream in `drawText` / `layoutRuns`, not here.
+ * Text RenderLayer for text that is not in a scene: one `textCommandFromPose`
+ * command per item, the same command the `kit:text` node painter emits, so an
+ * item lays out — and wraps, or doesn't, per its style — as a node would.
  *
  * The GL renderer uses MSDF text. The resolved style's `fontFamily` must
  * be registered via `registerFont(family, variant, metricsUrl, atlasUrl)`
@@ -6930,10 +7953,10 @@ declare function createTextLayer<T>(opts: CreateTextLayerOpts<T>): RenderLayer<u
  *
  * `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.
+ * the caret on click. It reads the caret stops off `layoutTextPose`, the
+ * layout the painters draw 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 `pointInTextPose`. */
@@ -6943,19 +7966,6 @@ interface PointInTextPoseOpts {
 }
 /** 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`, 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;
-}
 /**
  * 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
@@ -6967,7 +7977,7 @@ interface CaretIndexAtOpts {
  * 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;
+declare function caretIndexAt(x: number, y: number, pose: TextPose): number;
 
 /**
  * Resize a text node's pose to fit its content. Pure helper — does not own
@@ -6977,8 +7987,9 @@ declare function caretIndexAt(x: number, y: number, pose: TextPose, opts?: Caret
  * Two modes:
  *
  *   - `axis: 'height'` (default): keep `pose.width`, recompute `height` as
- *     the wrapped block height plus optional vertical padding. The common
- *     case for column-layout text — chat bubbles, sticky notes, label cards.
+ *     the block height plus optional vertical padding — wrapped at the width
+ *     inside the horizontal padding when the style declares `wrap`. The
+ *     common case for column-layout text — chat bubbles, sticky notes.
  *
  *   - `axis: 'both'`: ignore wrapping; recompute both `width` (longest
  *     `\n`-split line) and `height` (line count × line height) plus padding.
@@ -7198,6 +8209,13 @@ interface TextEditScreenPose {
      */
     zoom?: number;
 }
+/** A box in CSS pixels relative to `useTextEdit`'s `container`. */
+interface TextEditClipRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 /** Options for `useTextEdit`. */
 interface UseTextEditOptions {
     /** Element the overlay is appended to. Must be `position: relative`/absolute. */
@@ -7224,6 +8242,15 @@ interface UseTextEditOptions {
     setStyle?: (id: string, style: TextStyle) => void;
     /** Read screen-space pose for `id`. Called per frame while editing. */
     getScreenPose: (id: string) => TextEditScreenPose | null;
+    /**
+     * The box, in CSS pixels relative to `container`, the overlay is visible
+     * within — where the canvas clips the glyphs the overlay stands in for.
+     * Re-read every frame. Omit it, or return `null`, to clip nothing.
+     *
+     * The clip cannot scroll, so a caret moving past its edge leaves the page
+     * where it is; a scrollable container would drag the canvas after the caret.
+     */
+    getClipRect?: () => TextEditClipRect | null;
     /** Commit text. Caller wraps in op/undo. */
     setText: (id: string, text: string) => void;
     /**
@@ -7386,9 +8413,9 @@ declare function unionAABB<TPose extends RectPose>(parts: Iterable<TPose | null
  * (`getText` / `getStyle` / `getRuns` / `setText` / `setRuns` / `setStyle`).
  *
  * Pose component: the helper reads `(x, y, width, height)` straight off
- * the node's pose (typed `RectPose`). Pass `view` and it projects that box
- * through the viewport; omit it and world units are handed through as
- * screen pixels, which is correct only for an unpanned, unzoomed canvas.
+ * the node's pose (typed `RectPose`) and projects that box through the view
+ * of the weasel canvas mounted inside `container` — see the `view` option.
+ * The overlay is clipped to that canvas's box, where its glyphs are clipped.
  * Consumers with non-rect poses should drop down to raw `useTextEdit` and
  * supply their own `getScreenPose`.
  */
@@ -7402,6 +8429,7 @@ interface DefaultTextData {
     runs?: readonly StyledRun[];
     fill?: FillStyle | null;
     stroke?: Stroke | null;
+    verticalAlign?: TextVerticalAlign;
 }
 /** All-optional projections + fontSize fallback. */
 interface UseSceneTextEditOptions<TData> {
@@ -7413,6 +8441,8 @@ interface UseSceneTextEditOptions<TData> {
     getPaint?: (data: TData) => TextPaint | undefined;
     /** Read rich-text runs from `data`. Default: `data.runs`. */
     getRuns?: (data: TData) => readonly StyledRun[] | undefined;
+    /** Read the box vertical alignment from `data`. Default: `data.verticalAlign`. */
+    getVerticalAlign?: (data: TData) => TextVerticalAlign | undefined;
     /** Produce updated data with new text. Default: `{ ...data, text }`. */
     setText?: (data: TData, text: string) => TData;
     /** Produce updated data with new runs. Default: `{ ...data, runs }`. */
@@ -7428,21 +8458,24 @@ interface UseSceneTextEditOptions<TData> {
     /** Fallback fontSize when `style.fontSize` is unset. Default `16`. */
     defaultFontSize?: number;
     /**
-     * Current viewport. Supply it on a canvas that pans or zooms: the overlay
-     * is then positioned at the node's projected screen origin and CSS-scaled
+     * The view to project through. Omit it and the view is read live from the
+     * weasel canvas mounted inside `container` (the one a double-click landed
+     * on, when there are several) — which is all a canvas that pans or zooms
+     * needs. With no canvas there, the node's world box is passed through as
+     * screen pixels.
+     *
+     * The overlay is positioned at the node's projected origin and CSS-scaled
      * by the view, so every typographic metric on it — including the
      * `fontSize` / `letterSpacing` a *run* carries — stays in world units and
-     * scales together. Omit it and the node's world box is passed through as
-     * screen pixels (correct at `{x: 0, y: 0, scale: 1}`).
+     * scales together.
      *
      * 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.
+     * Pass one to project through a camera other than the canvas's own. A
+     * thunk is re-read on every projection; a plain `View` is the value from
+     * the render that supplied it.
      */
     view?: View | (() => View);
     /**
@@ -7468,8 +8501,10 @@ interface UseSceneTextEditReturn extends UseTextEditReturn {
 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;
 
 /**
- * Build a `TextDrawCommand`. `textCommand` takes a plain string and wraps it
- * in one run; `textCommandFromRuns` takes the styled runs directly. Both
+ * Build a `TextDrawCommand`. `textCommandFromPose` is the command for a text
+ * node — what `kit:text` and `createTextLayer` both emit. `textCommand` takes
+ * a plain string and wraps it in one run; `textCommandFromRuns` takes the
+ * styled runs directly, for text that has no pose. All three
  * resolve through `resolveTextStyle` + `resolveRuns`, so every emitter of a
  * 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
@@ -7479,11 +8514,18 @@ declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends
  * 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;
+declare function textCommandFromRuns(x: number, y: number, runs: readonly StyledRun[], style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number): 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, paint?: TextPaint): DrawCommand;
+ *  the registered font's metrics, wrapped at `maxWidth`, aligned across
+ *  `width` (default `maxWidth`) and within `height` when `verticalAlign` is
+ *  given. */
+declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number): DrawCommand;
+/**
+ * The draw command for a text pose. Its wrap width, alignment box and runs
+ * come from `textPoseLayoutInput`, so the renderer lays it out into exactly
+ * the lines `layoutTextPose` reports for the same pose.
+ */
+declare function textCommandFromPose(pose: TextPose): TextDrawCommand;
 
 /**
  * Pure DOM ↔ `StyledRun[]` serializers for the contenteditable overlay
@@ -7975,10 +9017,8 @@ interface NestedHitOpts<TNode extends {
     /** Compose a child's local pose into world coords given its parent's world
      *  pose. Same shape as `composeRectPose` (the default expectation). */
     composePose: (parent: TPose, child: TPose) => TPose;
-    /** Derive an axis-aligned bounding rect from a (world-space) pose. Default
-     *  reads `x` / `y` / `width` / `height` straight off the pose (matches
-     *  `RectPose`). Override for non-rect poses (e.g. paths). */
-    poseBounds?: (pose: TPose) => Bounds;
+    /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Predicate for "this object is a nesting parent body". The leaf scan
      *  skips objects for which this returns true so a click on a parent's
      *  painted body resolves to a child leaf, not the parent itself. Default:
@@ -8007,6 +9047,22 @@ declare function nestedHitTester<TNode extends {
     id: string;
 }, TPose>(adapter: HitAdapter<TNode, TPose>, opts: NestedHitOpts<TNode, TPose>): NestedHitTester;
 
+type DerivePose<TPose> = (node: {
+    pose: TPose;
+}, deps: readonly ({
+    pose: TPose;
+} | undefined)[]) => TPose | null;
+/**
+ * A container's pose as the envelope of what it holds, read through
+ * `descriptor` — a rotated member contributes the extent of its ink. Register
+ * the result under `UNION_OF_CHILDREN` in `createScene`'s `registry` to teach
+ * a scene how to size its groups around a pose shape the kit cannot read.
+ *
+ * Returns `null` for an emptied container, which falls back to its authored
+ * pose rather than collapsing to a zero box at the origin.
+ */
+declare function unionOfChildrenVia<TPose>(descriptor: PoseDescriptor<TPose>): DerivePose<TPose>;
+
 /**
  * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
  * encoding behind move/line/curve/close calls and a final `build()`. Use
@@ -8242,6 +9298,35 @@ declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[], opt
  *  combine with `pathContainsPoint` at the call site. */
 declare function pathDistanceToPoint(path: Path, px: number, py: number): number;
 
+/**
+ * A station along a path: where it is at a fraction of its length, and which
+ * way it is heading there.
+ *
+ * For anything positioned *along* geometry rather than beside it — a label on a
+ * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
+ * flattened first, so the fraction is arc length along the drawn shape rather
+ * than a curve parameter, which is what makes 0.5 look like the middle.
+ */
+
+interface PathStation {
+    point: Vec2;
+    /** Unit vector along the path at `point`, pointing toward the end. */
+    tangent: Vec2;
+}
+interface PointAlongPathOptions {
+    /** Curve flattening tolerance, in world units. Default 0.5. */
+    flattenTolerance?: number;
+}
+/**
+ * Where `path` is at `t` of its total length, and its heading there.
+ *
+ * `t` is clamped to 0..1. Subpaths are measured in order and treated as one
+ * run, the way a browser measures a whole `<path>`. Returns `null` for a path
+ * with no points at all; a path of zero length answers at its single point,
+ * heading along +X.
+ */
+declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
+
 /**
  * In-place and copy-out path transforms. Translation is the most common —
  * called every pointermove during a drag — so the polygon variant mutates
@@ -8249,9 +9334,7 @@ declare function pathDistanceToPoint(path: Path, px: number, py: number): number
  *
  * `scalePathToBounds` is for the resize interaction: given the path's
  * current AABB and the desired new AABB, scales every coordinate
- * proportionally. Degenerate source bounds (zero width/height) collapse
- * the corresponding axis to the new origin — preferable to dividing by
- * zero or refusing to resize.
+ * proportionally.
  */
 
 /**
@@ -8270,9 +9353,9 @@ declare function translatePolygonInPlace(path: PolygonPath, dx: number, dy: numb
  * Scale a path's coords so its current AABB maps to `target`. Resize
  * interactions use this to make a polygon follow a corner-handle drag.
  *
- * Degenerate source axes (width or height == 0) collapse to `target.x` /
- * `target.y` — every coord on that axis becomes the new origin. Avoids
- * division by zero without throwing.
+ * A degenerate source axis (zero width or height) has no ratio to scale by,
+ * so `boxToBox` translates that axis instead — a zero scale is not
+ * invertible and would discard what is left on it.
  */
 declare function scalePathToBounds(path: Path, target: RectPath): Path;
 
@@ -8429,48 +9512,6 @@ interface CreatePathLayerOpts<T> {
 /** Build a `RenderLayer` that fills/strokes `Path` instances enumerated from a node list. */
 declare function createPathLayer<T>(opts: CreatePathLayerOpts<T>): RenderLayer<unknown>;
 
-/**
- * Bezier flattening — subdivide cubic and quadratic segments into polyline
- * approximations within a flatness tolerance. Used by hit-testing and
- * (eventually) any kernel that doesn't want to special-case curves.
- *
- * The flatness metric is the maximum perpendicular distance from any
- * control point to the chord between endpoints. When that distance falls
- * below `tolerance`, the segment is "flat enough" and emitted as a single
- * line segment.
- *
- * Tolerance is in world units. 0.5 is a sensible default for screen-rate
- * rendering at 1× zoom; consumers that zoom in heavily should pass a
- * tighter tolerance.
- */
-declare const DEFAULT_FLATTEN_TOLERANCE = 0.5;
-/**
- * Recursively subdivide a cubic bezier (P0..P3) and append `lineTo`-style
- * vertices to `out` (interleaved x,y). The starting endpoint is *not*
- * appended — callers usually emitted it as the segment's previous vertex.
- */
-declare function flattenCubic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[]): void;
-/** Recursively subdivide a quadratic bezier (P0, P1, P2). */
-declare function flattenQuadratic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[]): void;
-/**
- * Like `flattenCubic` but also appends, for each new flattened point, its
- * arc-length fraction `t` (relative to the polyline distance accumulated so
- * far inside this curve) to `arcOut`. Caller then post-processes the segment's
- * `arcOut` range by dividing each by the segment's total flattened arc length
- * to yield t ∈ (0, 1].
- *
- * The returned values are *cumulative distance from the segment start*, not
- * normalized fractions. Two-pass design (accumulate, then divide) keeps the
- * recursive splitter simple — it doesn't need to know the total length up
- * front.
- */
-declare function flattenCubicWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[], arcOut: number[]): number;
-/** Flatten a quadratic bezier into line segments within `tolerance`, appending
- *  points to `out` and their cumulative arc lengths to `arcOut`. The arc
- *  lengths are what lets per-anchor color and dash phase be interpolated
- *  evenly along the curve rather than per segment. */
-declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[]): number;
-
 /**
  * `pathFromD` — build a weasel `Path` from an **SVG path-data string** (the
  * value of SVG's `d` attribute, e.g. `"M0 0 L100 0 Z"`).
@@ -8564,17 +9605,16 @@ declare function splitPathByLine(path: Path, a: Point, b: Point, opts?: SplitByL
 declare function unionBoundsPath(paths: Iterable<Path>): RectPath | null;
 
 /**
- * `PoseProjection` for `Path` poses — wires `useResize` to operate
+ * `PoseDescriptor` for `Path` poses — wires `useResize` to operate
  * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel
- * the rest of the kit uses; `remapBounds` does an affine scale of every
- * coord against `src`/`dst`. Degenerate axes (zero src extent) collapse to
- * the new origin so resize from a flat edge doesn't produce NaN.
+ * the rest of the kit uses.
  *
- * Mirrors `scalePathToBounds` but takes `src` explicitly: the resize hook
- * knows the group's origin AABB and uses it for every leaf, instead of
- * each leaf scaling against its own AABB (which would ignore group context).
+ * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the
+ * resize hook knows the group's origin AABB and uses it for every leaf,
+ * instead of each leaf scaling against its own AABB (which would ignore
+ * group context).
  */
-declare const pathPoseDescriptor: PoseProjection<Path>;
+declare const pathPoseDescriptor: PoseDescriptor<Path>;
 
 /**
  * `OriginProjection` for `Path` poses. The "origin" is the top-left of the
@@ -8710,11 +9750,6 @@ declare function pathExclude(...paths: Path[]): PolygonPath;
  * Fracture N paths along every intersection into the maximal set of
  * non-overlapping regions. Returns one `PolygonPath` per region.
  *
- * Algorithm: for every non-empty subset S ⊆ {A1..AN}, emit the region
- * `(∩ S) − (∪ complement)` — points covered by exactly the members of S
- * and no others. By construction the emitted regions are pairwise disjoint
- * and their union equals `pathUnion(A1..AN)`.
- *
  * For N=2 this collapses to the three Illustrator "Divide" outputs
  * (A−B, B−A, A∩B). For N=3 up to 7 regions are emitted. The 2^N − 1
  * subset count limits this to small N in practice; passing more than ~8
@@ -8901,10 +9936,19 @@ interface PaintBindContext {
      * 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.
+     *
+     * `null` when that space has no inverse — a transform or view that flattens
+     * an axis. Nothing the paint draws there means anything, so `bind` should
+     * return `null` and draw nothing.
+     */
+    spaceInverse(units: GradientUnits | undefined): Mat3$1 | null;
+    /**
+     * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
+     * unit, and return the `v` the ramp's own row sits at — every ramp in a
+     * frame shares one texture, so a paint must sample at the returned `v` and
+     * not at a constant.
      */
-    spaceInverse(units: GradientUnits | undefined): Mat3$1;
-    /** Upload a stop ramp and bind it to a texture unit. */
-    bindRamp(stops: GradStop[], unit: number): void;
+    bindRamp(stops: GradStop[], unit: number): number;
 }
 /**
  * One paint kind.
@@ -9247,21 +10291,15 @@ interface ArrayAdapterConfig<TNode extends {
      *  Consumers own id generation and any palette/payload fields. Returning
      *  `null` aborts the insert. When omitted, `commitInsert` returns `null`. */
     createDefault?: (bounds: Bounds) => TNode | null;
-    /** Project a pose to an AABB for `hitTestArea`. Default: identity (works
-     *  when TPose carries top-level x/y/width/height). */
-    poseBounds?: (pose: TPose) => Bounds;
-    /** Tight intersection test against a pose. Default: AABB-vs-AABB using
-     *  `poseBounds`. Override for non-rect poses (e.g. polygons via
-     *  `pathPoseDescriptor.intersectsRect`). */
-    intersectsRect?: (pose: TPose, rect: Bounds) => boolean;
+    /** How to read and rewrite item poses. Default `RECT_POSE_DESCRIPTOR`,
+     *  which reads the pose as its own AABB — the canonical axis-aligned rect
+     *  pose. `AUTO_POSE_DESCRIPTOR` lives above `core/` and so cannot be the
+     *  default here; pass it for a scene whose poses may be Paths. */
+    poseDescriptor?: PoseDescriptor<TPose>;
     /** Factory for fresh node ids in `commitPaste`. Default: `crypto.randomUUID()`
      *  when available, otherwise a monotonic `paste-<n>` counter. Override
      *  when consumers want stable id schemes (e.g. `clip-${n++}`). */
     nextId?: () => string;
-    /** Translate a pose by `(dx, dy)`. Default: shallow-spread `{ x, y }`,
-     *  which matches the canonical axis-aligned rect pose. Override for
-     *  non-rect poses whose translation isn't a top-level `x`/`y` bump. */
-    translatePose?: (pose: TPose, dx: number, dy: number) => TPose;
 }
 /**
  * Combined adapter satisfying every narrow adapter the kit ships. Methods
@@ -9433,14 +10471,6 @@ interface GuidesLayerOpts {
  *  screen space, projected from world offsets via the active view. */
 declare function createGuidesLayer(opts: GuidesLayerOpts): RenderLayer<unknown>;
 
-/** 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;
-    width: number;
-    height: number;
-}
 /** Which feature of a box to test against candidates, per axis.
  *  'min' = left/top edge, 'center' = centerline, 'max' = right/bottom edge. */
 type AlignAnchor = 'min' | 'center' | 'max';
@@ -9453,31 +10483,18 @@ interface AlignMatchResult {
     activeX: Guide | null;
     activeY: Guide | null;
 }
-/** Bounds analog of the gesture `OriginProjection`: reads an AABB from a pose
- *  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 poses — edges, centers, or
  *  both, and whether the page box contributes its own. */
-interface DeriveAlignmentGuidesOptions<TPose = AlignBounds> {
+interface DeriveAlignmentGuidesOptions<TPose = Bounds> {
     /** Include the document/page box's edges + center as candidates. */
-    page?: AlignBounds;
+    page?: Bounds;
     /** 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>;
+    /** How to read each target. Pass the same descriptor `alignMoveBehavior`
+     *  gets, or the two sides disagree. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
 }
 /** Common options shared by the three alignment behavior factories. */
 interface AlignmentBehaviorBase {
@@ -9497,20 +10514,15 @@ interface AlignmentBehaviorBase {
 /** 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.
- *  Poses go through the same projection `alignMoveBehavior` matches with, so
+ *  Poses go through the same descriptor `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[];
+declare function deriveAlignmentGuides<TPose = Bounds>(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,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).
@@ -9522,7 +10534,7 @@ declare const RECT_ALIGN_PROJECTION: AlignBoundsProjection<RectPose>;
  * distance along that axis alone, so there is an exact answer rather than an
  * approximation. Pass the same number twice for a world-space tolerance.
  */
-declare function matchAlignment(bounds: AlignBounds, candidates: readonly Guide[], worldTolerance: {
+declare function matchAlignment(bounds: Bounds, candidates: readonly Guide[], worldTolerance: {
     x: number;
     y: number;
 }, anchors: {
@@ -9530,9 +10542,9 @@ declare function matchAlignment(bounds: AlignBounds, candidates: readonly Guide[
     y: readonly AlignAnchor[];
 }): AlignMatchResult;
 
-/** Options for move/insert — adds the bounds projection for non-rect poses. */
+/** Options for move/insert — adds the pose descriptor for non-rect poses. */
 interface AlignMoveArgs<TPose> extends AlignmentBehaviorBase {
-    projection?: AlignBoundsProjection<TPose>;
+    poseDescriptor?: PoseDescriptor<TPose>;
 }
 /** Move behavior: snap the dragged selection's union box (edges + center) to
  *  candidates, shaping the proposed translate. The gesture applies the
@@ -9545,10 +10557,10 @@ declare function alignMoveBehavior<TPose>(args: AlignMoveArgs<TPose>): MoveBehav
 declare function alignInsertBehavior<TPose>(args: AlignmentBehaviorBase): InsertBehavior<TPose>;
 /** Resize constraint: snap the moving edge(s) of the dragged rect to
  *  candidates. The pinned (anchor) edge stays fixed. Publishes the line(s). */
-declare function alignResizeBehavior<TPose extends ResizePose>(args: AlignmentBehaviorBase): BoundsConstraint<TPose>;
+declare function alignResizeBehavior<TPose extends Bounds>(args: AlignmentBehaviorBase): BoundsConstraint<TPose>;
 
 /** AABB center of an unrotated rect — the canonical rotation pivot. */
-declare function aabbCenter(bounds: ResizePose): {
+declare function aabbCenter(bounds: Bounds): {
     x: number;
     y: number;
 };
@@ -9558,7 +10570,7 @@ declare function rotatePoint(px: number, py: number, cx: number, cy: number, ang
     y: number;
 };
 /** Four corners of an unrotated rect, in TL/TR/BR/BL order. */
-declare function rectCorners(bounds: ResizePose): {
+declare function rectCorners(bounds: Bounds): {
     x: number;
     y: number;
 }[];
@@ -9843,65 +10855,6 @@ interface AnchorHit {
  *  are within `threshold` (controls are smaller and rendered on top). */
 declare function hitAnchor(path: PolygonPath, worldX: number, worldY: number, threshold: number): AnchorHit | null;
 
-/**
- * Typed keys for the gesture/behavior scratch store.
- *
- * Gestures expose `ctx.scratch: Record<string, unknown>` as a per-gesture
- * mutable bag that behaviors use to stash state across `onDown` / `onMove`
- * / `onEnd` calls. The store is `unknown`-valued because behaviors are
- * tool-agnostic — a single behavior may run under different tools with
- * different scratch shapes. Without a typing convention every read site
- * has to `(ctx.scratch as <some shape>)[KEY]`, and a writer changing the
- * shape can silently break readers with no compile-time signal.
- *
- * `ScratchKey<T>` is a phantom-typed string that carries its payload type
- * via a branded interface. `getScratch` and `setScratch` use the brand to
- * narrow / constrain at the typing layer; at runtime the key is just its
- * underlying string and the store remains a plain `Record`.
- *
- * @example
- * ```ts
- * // Module-level (or behavior-level) constant, shared by writer + reader:
- * const LASSO_VERTICES = scratchKey<readonly { x: number; y: number }[]>('lasso.vertices');
- *
- * // Writer (a tool's onMove):
- * setScratch(ctx.scratch, LASSO_VERTICES, vertices);
- *
- * // Reader (a behavior's onEnd):
- * const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];
- * //    ^?  readonly { x: number; y: number }[] | undefined
- * ```
- */
-/** Phantom-typed key for a scratch slot. The `__scratchKeyPayload` phantom
- *  field carries the value type without occupying any runtime memory. */
-interface ScratchKey<T> {
-    readonly name: string;
-    /** Phantom — never read at runtime. Only present so TypeScript can
-     *  recover `T` at use sites. */
-    readonly __scratchKeyPayload?: (_: T) => T;
-}
-/** Compatible scratch store shape. The kit's gesture context's `scratch`
- *  field already satisfies this; consumers don't need to construct one. */
-type ScratchStore = Record<string, unknown>;
-/**
- * Make a typed scratch key. Use module-level constants so the same key
- * is shared by writer and reader.
- *
- * Namespace the name by behavior or feature to avoid collisions
- * (`'behavior.field'` is a good convention). Two keys with the same
- * `name` refer to the same slot at runtime — the type parameter is a
- * compile-time contract, not a uniqueness guarantee.
- */
-declare function scratchKey<T>(name: string): ScratchKey<T>;
-/** Read a typed slot from the scratch store. Returns `undefined` if
- *  nothing has been written under the key. */
-declare function getScratch<T>(store: ScratchStore, key: ScratchKey<T>): T | undefined;
-/** Write a value to a typed slot. Overwrites whatever was there. */
-declare function setScratch<T>(store: ScratchStore, key: ScratchKey<T>, value: T): void;
-/** Remove a slot from the scratch store. Returns `true` if it was set,
- *  `false` if it wasn't. */
-declare function deleteScratch<T>(store: ScratchStore, key: ScratchKey<T>): boolean;
-
 /** Options for `selectFromLasso`. */
 interface SelectFromLassoOptions {
     /** Hit mode for `hitTestLasso`. Default 'intersect'. */
@@ -9919,7 +10872,11 @@ type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';
 /** Adapter for `useAlign`. */
 interface AlignAdapter<TPose> {
     getSelection(): NodeId[];
+    /** The pose as stored — local to the node's parent. */
     getPose(id: NodeId): TPose;
+    /** The parent chain, for a scene whose container poses define a frame.
+     *  Omit it (or leave `composition` unset) for an absolute-pose scene. */
+    getParent?(id: NodeId): NodeId | null;
     applyOps?(ops: Op[], label?: string): void;
 }
 /** Options for `useAlign`. */
@@ -9927,38 +10884,30 @@ interface UseAlignOptions<TPose> {
     /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
      *  for `{x,y,width,height}` poses. Pass `pathPoseDescriptor` for `Path`
      *  poses so polygon coords translate correctly. */
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
     /** Label passed to applyOps. Default 'Align'. */
     label?: string;
+    /** How local poses fold up to world. Default IDENTITY, where the two are
+     *  the same value and the alignment runs entirely in stored coordinates. */
+    composition?: PoseComposition<TPose>;
 }
 /** Return shape of `useAlign`. */
 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): {
+declare function alignDeltaFor(b: Bounds, u: Bounds, edge: AlignEdge): {
     dx: number;
     dy: number;
 };
-/** Translate `pose` by `(dx, dy)` using `geometry.translate` if available,
- *  otherwise via `remapBounds` with a translated `dst` rect. */
-declare function translatePoseViaDescriptor<TPose>(pose: TPose, dx: number, dy: number, geometry: PoseProjection<TPose>): TPose;
 /** Align the current multi-selection to a shared edge or center of the
  *  selection's union AABB. No-op when fewer than 2 items selected.
- *  Single batch — one undo step. */
+ *  Single batch — one undo step.
+ *
+ *  The edge is a world edge: bounds are measured and translated in world, and
+ *  each result is stored back in its own parent's frame. */
 declare function useAlign<TPose>(adapter: AlignAdapter<TPose>, options?: UseAlignOptions<TPose>): UseAlignReturn;
 
 /** Axis along which selection is distributed. `'x'` spreads horizontally. */
@@ -9970,18 +10919,25 @@ type DistributeMode = 'centers' | 'gaps';
 /** Adapter for `useDistribute`. */
 interface DistributeAdapter<TPose> {
     getSelection(): NodeId[];
+    /** The pose as stored — local to the node's parent. */
     getPose(id: NodeId): TPose;
+    /** The parent chain, for a scene whose container poses define a frame.
+     *  Omit it (or leave `composition` unset) for an absolute-pose scene. */
+    getParent?(id: NodeId): NodeId | null;
     applyOps?(ops: Op[], label?: string): void;
 }
 /** Options for `useDistribute`. */
 interface UseDistributeOptions<TPose> {
     /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
      *  for `{x,y,width,height}` poses. */
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
     /** Default mode when `distribute(axis)` is called without one. Default 'centers'. */
     defaultMode?: DistributeMode;
     /** Label passed to applyOps. Default 'Distribute'. */
     label?: string;
+    /** How local poses fold up to world. Default IDENTITY, where the two are
+     *  the same value and the spread runs entirely in stored coordinates. */
+    composition?: PoseComposition<TPose>;
 }
 /** Return shape of `useDistribute`. */
 interface UseDistributeReturn {
@@ -9990,7 +10946,10 @@ interface UseDistributeReturn {
 }
 /** Distribute the current multi-selection along `axis`. Requires ≥3 items;
  *  no-op otherwise. Endpoints (min and max along the axis) stay put; the
- *  remaining items are repositioned. Single batch — one undo step. */
+ *  remaining items are repositioned. Single batch — one undo step.
+ *
+ *  The span being divided is a world span: bounds are measured and translated
+ *  in world, and each result is stored back in its own parent's frame. */
 declare function useDistribute<TPose>(adapter: DistributeAdapter<TPose>, options?: UseDistributeOptions<TPose>): UseDistributeReturn;
 
 /** The six Boolean path operations, each acting on the current selection and
@@ -10122,7 +11081,7 @@ interface TweenPoseOptions<TPose> {
     easing?: EasingSpec;
     /** Pose descriptor with a `lerp(from, to, t)` method. Defaults to
      *  `RECT_POSE_DESCRIPTOR`, which interpolates x/y/width/height linearly. */
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
     /** When true (default), emit a transform op before the tween so undo
      *  restores the pre-animation pose. */
     recordOp?: boolean;
@@ -10138,7 +11097,7 @@ interface SpringPoseOptions<TPose> {
     stiffness?: number;
     damping?: number;
     mass?: number;
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
     recordOp?: boolean;
     opLabel?: string;
     onDone?: () => void;
@@ -10173,7 +11132,7 @@ interface AnimateOnSetPoseOptions<TPose> {
         damping?: number;
         mass?: number;
     };
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
     /** Predicate: return false to skip animation and write through immediately. */
     shouldAnimate?: (id: string, from: TPose, to: TPose) => boolean;
     /** Convenience: when true, auto-skip animation if the id is currently being
@@ -10214,7 +11173,7 @@ interface LifecycleAnimation<TPose> {
     exitTo?: (current: TPose) => TPose;
     ms?: number;
     easing?: EasingSpec;
-    geometry?: PoseProjection<TPose>;
+    geometry?: PoseDescriptor<TPose>;
 }
 /** Wrap an adapter so inserts and removals animate — the scene-graph
  *  equivalent of CSS enter/leave transitions. */
@@ -10259,6 +11218,8 @@ interface MomentumOptions {
      * decays the velocity). Default 'stop'.
      */
     boundary?: 'stop' | 'continue';
+    /** How to translate poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<unknown>;
 }
 /**
  * Move behavior that keeps a dragged node coasting after the pointer is
@@ -10730,43 +11691,6 @@ declare function CropIcon(): react_jsx_runtime.JSX.Element;
 declare const PAINTED_CURSOR_LAYER_ID = "painted-cursor";
 declare function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown>;
 
-/** What the registry knows at dispatch time. */
-interface EligibilityState {
-    focusedId: string | null;
-    heldTriggers: ReadonlySet<string>;
-    /** Ids the host reports as hotkey-engaged. A declared `offhand` registers
-     *  the binding, but `tool.offhand`'s invoker still reports engagement by
-     *  pushing an id — this retires only if that contract changes. */
-    engagedIds?: ReadonlySet<string>;
-    /** Whether the active mode allows these capability tags. Omitted → allow. */
-    allows?: (tags: readonly CapabilityTag[]) => boolean;
-}
-/**
- * The scope tier an entry's bindings are live at, or null when none are.
- * Ordered hotkey > active > ambient to match the dispatcher's own walk.
- */
-declare function liveScope(id: string, eligibility: Eligibility, state: EligibilityState): BindingScope | null;
-
-/**
- * Every binding the entry set contributes right now, each tiered by the
- * entry's own declared eligibility. Entries with no live tier are omitted.
- *
- * Order is preserved: `matchSorted` sorts by specificity within a scope and
- * breaks ties by declaration order, so the caller's entry order decides which
- * of two same-specificity bindings in one tier wins.
- */
-declare function scopeBindings(entries: Iterable<Contribution>, state: EligibilityState): ScopedBinding[];
-
-/**
- * Concatenate contribution bundles into one registry, preserving order —
- * entry order decides which of two same-specificity bindings in one scope
- * tier wins, so it is part of the result, not an accident of it.
- *
- * Throws on a duplicate id rather than dropping one: a feature silently
- * losing its bindings is the failure this registry exists to make loud.
- */
-declare function mergeContributions(...bundles: readonly Contribution[][]): Contribution[];
-
 /** Appearance of the dashed box drawn during a marquee or insert drag. */
 interface InsertOverlayStyle {
     fill?: string;
@@ -10775,4 +11699,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-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, ArrowIcon, 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_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, 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 DragPanParams, 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, EasingSpec, 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, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, HotkeyTrigger, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, IntersectIcon, type Joint, type JointTransform, KIT_STANDARD_ACTION_IDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerGroup, 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, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, type PaintedCursor, type PaintedCursorFrame, type PaintedCursorState, 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 PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerSession, type PointerSessionCallbacks, type PointerSessionCancelReason, type PointerSessionOptions, 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, 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, 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 UseHostAnchorOptions, 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, VERSION, type Vec2, type VelocityTracker, VertexColorChannel, View, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, ViewTransform, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, ZoomBound, 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, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, 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, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isDebugEnabled, isEditableTarget, isGradientFill, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, 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, openPointerSession, 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, polylineFromPoints, 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, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };
+export { ANCHOR_HIT_BASE_PX, type ActionShortcut, ActionsProviderIfRoot, type Affordance, type AffordanceBinding, type AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, type AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CellHighlightLayerOpts, type ChromeCtx, type ChromeId, type ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type ColorSpace, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, 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 CustomPaintContext, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DefaultTextData, DepRegistryProviderIfRoot, type DeriveAlignmentGuidesOptions, DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type Discriminator, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, 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, EasingSpec, Effect, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FeedDelta, type FeedNode, 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, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, IntersectIcon, type Joint, type JointTransform, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LayerCommandCache, type LayerDrawFailure, LayerEnumerableAdapter, type LayerGroup, type 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, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PathStation, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PointAlongPathOptions, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseComposition, PoseDescriptor, type PoseFeed, PoseOverrides, type PoseRotation, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PosedNode, type PressureToWidthOptions, type PreviewNode, type Pt, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, type RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, type ResolvableView, type ResolvedOverlay, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RunStylePatch, 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, type SceneViewLayers, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, 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 SimulationCore, type SimulationForce, type SimulationNode, type SimulationOptions, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, TextDrawCommand, type TextEditClipRect, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, type Tool, type ToolBundle, type ToolDef, 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 ToolPrefNumberFormat, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UNION_OF_CHILDREN, UnionIcon, Unit, 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 UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, VERSION, type Vec2, type VelocityTracker, VertexColorChannel, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, ZOOM_FLOOR, type ZoomBound, type ZoomClampOpts, type 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, clipboardCopyAction, clipboardCutAction, 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, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSimulation, createTextLayer, createTilePattern, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, dispatchApplyBatch, dlog, documentPose, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, dwarn, editAnchorsAction, effectivePose, ellipsePath, enterTextEditAction, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenPreviews, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, insertPreviewExtent, interpolateView, isBuiltinToolPref, isDebugEnabled, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, meanScale, mergeAlphaFromPrev, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, 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, pointAlongPath, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, polylineFromPoints, poseRotationOf, prefUnit, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, unionOfChildren, unionOfChildrenVia, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, worldToScreen, zoomAt, zoomAtLeast };