@weasel-js/core 1.6.0 → 1.7.0

package/dist/index.d.ts

@@ -1,68 +1,48 @@
-import * as React$1 from 'react';
-import React__default, { RefObject, ReactNode, Ref, MutableRefObject, MouseEvent, ComponentType } from 'react';
-import { a as UnitValue, b as UnitSystem, c as UnitEntry, d as Unit, U as UseMoveOptions, O as OriginProjection } from './grid-Dx2gQbNv.js';
-export { A as ANGLE_RADIANS, I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, e as UnitScale, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit, u as unitScale } from './grid-Dx2gQbNv.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, Point2 } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionPresentation, ActionVariant, 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, Point2 as Vec2, View, actionBindings, actionItems, buildDepsFromRequires, 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, GradientUnits, ColorSpace, TilePatternSpec, GradientKind, GradStop, GradientFill, MarkerKey, MarkerRef, Palette } from '@weasel-js/paint';
+import * as react from 'react';
+import react__default, { RefObject, ReactNode, Ref, MouseEvent, ComponentType, MutableRefObject } from 'react';
+import { UnitValue, UnitSystem, Display, UnitEntry, Unit } from '@weasel-js/quantity';
+export { ANGLE_RADIANS, IMPERIAL_INCHES, METRIC_MM, PIXELS, Unit, UnitEntry, UnitScale, UnitSystem, UnitValue, formatUnit, resolveUnit, unitScale } from '@weasel-js/quantity';
+import { y as RenderLayer, z as Dims, A as Scene, B as RectPose, F as InertiaConfig, V as ViewAnimationOptions, N as Node$1, H as GestureLifecycleOptions, J as PoseComposition, K as SliceDep, L as ToolsApi, O as Tool, Q as Contribution, U as LayerHit, D as DrawCommand, X as ChromeState, Y as VertexColorChannel, Z as RedrawSource, g as ShaderProgramHandle, _ as LayerGroup, $ as InsertExtras, a0 as SerializedScene, a1 as GeometryProjection, a2 as ContentHandlerEntry, a3 as SvgIngestOptions, a4 as AnyTool, a5 as PanBounds, a6 as Animator, a7 as ColorOverrideRegistry, a8 as UseSceneOptions, a9 as SceneRegistry, aa as RegisteredOp, ab as PoseOverrides, ac as DerivedDep, ad as ViewportDims, P as PathDrawCommand, ae as ViewApi, af as Affordance, ag as AffordanceRegion, ah as AffordanceBinding, ai as CommonAffordanceScratch, T as TextDrawCommand, aj as ShaderProgram, G as GlMat3, ak as BooleansAdapter, al as UseAnimatorOptions, am as SpringPresetName, an as EasingSpec, ao as AnimationHandle, ap as SampledTrack } from './builtins-DLn2lCr_.js';
+export { aq as AddLayerSpec, ar as AddNodeSpec, as as AnimateToBoundsOptions, at as AreaSelectDep, au as BezierEasing, av as BooleanOp, aw as BooleanOpResult, ax as ClipboardDep, ay as ClipboardIngestCtx, az as ColorOverride, aA as ColorOverrideFn, aB as ContainerNode, aC as ContributionChrome, C as CullRect, aD as CustomPaintContext, aE as DecayLoopConfig, aF as DecayOptions, aG as EASINGS, aH as EasingFn, aI as EasingName, aJ as EditAnchorsDep, E as Effect, aK as EventBooking, aL as EventBookingHandle, aM as EventTrack, aN as FitViewToBoundsOptions, a as GroupDrawCommand, aO as IDENTITY_POSE_COMPOSITION, b as ImageDrawCommand, c as ImageMinification, aP as IngestCtx, aQ as IngestionDep, aR as InsertDep, aS as Interpolate, aT as InterpolatorFactory, aU as Keyframe, aV as LassoSelectDep, aW as LayerCommandCache, aX as LayerDrawFailure, aY as LayerRecord, aZ as LayoutDep, a_ as LeafNode, a$ as LoopFactory, b0 as LoopOptions, b1 as NestedTimeline, b2 as NodeAtPointDep, b3 as PhysicsHandle, b4 as PhysicsOptions, b5 as PointerContextProvider, b6 as PointerContextValue, b7 as PointerWorldPos, b8 as PoseAdapter, b9 as PoseClosure, ba as PoseOverride, bb as RECT_POSE_COMPOSITION, bc as RIGID_POSE_COMPOSITION, R as RenderTarget, bd as ResizePolicy, be as SPRING_PRESETS, S as SPRITE_STRIDE, bf as SerializedNode, f as ShaderDrawCommand, h as ShaderUniform, bg as SnapDep, bh as SpringOptions, bi as SpringPreset, j as SpriteSheet, k as SpritesDrawCommand, bj as StaggerBuilder, bk as StaggerDelay, bl as StaggerFactory, bm as StaggerOptions, bn as StaggerPerItem, bo as StaggerSpringPoseOptions, bp as StaggerTweenOptions, bq as SvgUnpacker, br as SystemLayerRecord, bs as SystemLayerSpec, bt as TextEditDep, bu as TimelineClock, bv as TimelineEvent, bw as TimelineHandle, bx as TimelineOptions, by as TimelineTrack, bz as ToolDef, bA as Track, bB as TweenLoopOptions, bC as TweenOptions, bD as UseToolsOptions, bE as UserLayerRecord, bF as VIEW_ANIMATION_KEY, bG as ViewAnimationApi, bH as ViewChannel, bI as applyBooleanOp, bJ as asNodeId, n as blur, bK as composeRectPose, bL as composeRigidPose, bM as composeWorldPose, bN as createPointerStore, bO as cubicBezierEasing, p as cullDrawCommands, bP as decomposeRectPose, bQ as decomposeRigidPose, bR as drawLayers, bS as drawOneLayer, bT as easeIn, bU as easeInBack, bV as easeInBounce, bW as easeInCirc, bX as easeInCubic, bY as easeInElastic, bZ as easeInExpo, b_ as easeInOut, b$ as easeInOutBack, c0 as easeInOutBounce, c1 as easeInOutCirc, c2 as easeInOutCubic, c3 as easeInOutElastic, c4 as easeInOutExpo, c5 as easeInOutQuad, c6 as easeInOutQuart, c7 as easeInOutQuint, c8 as easeInOutSine, c9 as easeInQuad, ca as easeInQuart, cb as easeInQuint, cc as easeInSine, cd as easeOut, ce as easeOutBack, cf as easeOutBounce, cg as easeOutCirc, ch as easeOutCubic, ci as easeOutElastic, cj as easeOutExpo, ck as easeOutQuad, cl as easeOutQuart, cm as easeOutQuint, cn as easeOutSine, co as fitViewToBounds, q as frameRect, cp as isLayerPainted, cq as isLayerVisible, cr as linear, r as mat3, cs as rebaseLocalPose, ct as registerContentHandler, t as registerEffect, cu as resolveEasing, cv as resolveStrokeWidth, cw as subscribeToSources, cx as translateRectPose, cy as useDecayLoop, cz as usePointerContext, cA as usePointerPosition, cB as useTools, cC as useViewAnimation, cD as useViewAnimationOn, w as viewToMat3, x as vignette, cE as worldPoseLookup } from './builtins-DLn2lCr_.js';
+import { Stroke, FillStyle, TextureHandle, GradientUnits, ColorSpace, GradStop, TilePatternSpec, GradientKind, GradientFill, MarkerKey, MarkerRef, Palette } from '@weasel-js/paint';
 export { ColorInterpolationSpace, ColorSpace, FillStyle, GradStop, GradientFill, GradientKind, GradientUnits, HueInterpolation, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Region, STROKE_DASH_RATIOS, ScreenLength, Stroke, StrokeAlign, StrokeDashStyle, TextureHandle, TilePatternSpec, alignedStrokeRect, contrastLineColor, dashForStrokeStyle, hexToOklchDeg, hslToSrgb, interpolateSrgb, lerpColorArray, lerpOklab, lerpOklch, linearSrgbToOklab, linearToSrgb, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, resolveScreenLength, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf } from '@weasel-js/paint';
-import { D as DrawCommand, E as Effect, w as Scene, x as RectPose, y as InertiaConfig, V as ViewAnimationOptions, N as Node$1, z as PoseComposition, A as SliceDep, B as VertexColorChannel, f as ShaderProgramHandle, F as InsertExtras, H as SerializedScene, J as GeometryProjection, K as ContentHandlerEntry, L as SvgIngestOptions, O as PanBounds, Q as Animator, U as ColorOverrideRegistry, X as UseSceneOptions, Y as SceneRegistry, Z as RegisteredOp, _ as PoseOverrides, $ as DerivedDep, a0 as ViewportDims, P as PathDrawCommand, T as TextDrawCommand, a1 as ShaderProgram, G as GlMat3, a2 as BooleansAdapter, a3 as UseAnimatorOptions, a4 as SpringPresetName, a5 as EasingSpec, a6 as AnimationHandle, a7 as SampledTrack } from './depSchema-BhgZc0-Q.js';
-export { a8 as AddLayerSpec, a9 as AddNodeSpec, aa as AnimateToBoundsOptions, ab as AreaSelectDep, ac as BezierEasing, ad as BooleanOp, ae as BooleanOpResult, af as ClipboardDep, ag as ClipboardIngestCtx, ah as ColorOverride, ai as ColorOverrideFn, aj as ContainerNode, C as CullRect, ak as DecayLoopConfig, al as DecayOptions, am as EASINGS, an as EasingFn, ao as EasingName, ap as EditAnchorsDep, aq as EventBooking, ar as EventBookingHandle, as as EventTrack, at as FitViewToBoundsOptions, a as GroupDrawCommand, au as IDENTITY_POSE_COMPOSITION, b as ImageDrawCommand, c as ImageMinification, av as IngestCtx, aw as IngestionDep, ax as InsertDep, ay as Interpolate, az as InterpolatorFactory, aA as Keyframe, aB as LassoSelectDep, aC as LayerRecord, aD as LayoutDep, aE as LeafNode, aF as LoopFactory, aG as LoopOptions, aH as NestedTimeline, aI as NodeAtPointDep, aJ as PhysicsHandle, aK as PhysicsOptions, aL as PoseAdapter, aM as PoseClosure, aN as PoseOverride, aO as RECT_POSE_COMPOSITION, aP as RIGID_POSE_COMPOSITION, R as RenderTarget, aQ as ResizePolicy, aR as SPRING_PRESETS, S as SPRITE_STRIDE, aS as SerializedNode, e as ShaderDrawCommand, g as ShaderUniform, aT as SnapDep, aU as SpringOptions, aV as SpringPreset, i as SpriteSheet, j as SpritesDrawCommand, aW as StaggerBuilder, aX as StaggerDelay, aY as StaggerFactory, aZ as StaggerOptions, a_ as StaggerPerItem, a$ as StaggerSpringPoseOptions, b0 as StaggerTweenOptions, b1 as SvgUnpacker, b2 as SystemLayerRecord, b3 as SystemLayerSpec, b4 as TextEditDep, b5 as TimelineClock, b6 as TimelineEvent, b7 as TimelineHandle, b8 as TimelineOptions, b9 as TimelineTrack, ba as Track, bb as TweenLoopOptions, bc as TweenOptions, bd as UserLayerRecord, be as VIEW_ANIMATION_KEY, bf as ViewAnimationApi, bg as ViewApi, bh as ViewChannel, bi as applyBooleanOp, bj as asNodeId, m as blur, bk as composeRectPose, bl as composeRigidPose, bm as composeWorldPose, bn as cubicBezierEasing, o as cullDrawCommands, bo as decomposeRectPose, bp as decomposeRigidPose, bq as easeIn, br as easeInBack, bs as easeInBounce, bt as easeInCirc, bu as easeInCubic, bv as easeInElastic, bw as easeInExpo, bx as easeInOut, by as easeInOutBack, bz as easeInOutBounce, bA as easeInOutCirc, bB as easeInOutCubic, bC as easeInOutElastic, bD as easeInOutExpo, bE as easeInOutQuad, bF as easeInOutQuart, bG as easeInOutQuint, bH as easeInOutSine, bI as easeInQuad, bJ as easeInQuart, bK as easeInQuint, bL as easeInSine, bM as easeOut, bN as easeOutBack, bO as easeOutBounce, bP as easeOutCirc, bQ as easeOutCubic, bR as easeOutElastic, bS as easeOutExpo, bT as easeOutQuad, bU as easeOutQuart, bV as easeOutQuint, bW as easeOutSine, bX as fitViewToBounds, p as frameRect, bY as linear, q as mat3, bZ as rebaseLocalPose, b_ as registerContentHandler, r as registerEffect, b$ as resolveEasing, c0 as resolveStrokeWidth, c1 as translateRectPose, c2 as useDecayLoop, c3 as useViewAnimation, c4 as useViewAnimationOn, v as viewToMat3, u as vignette, c5 as worldPoseLookup } from './depSchema-BhgZc0-Q.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';
+import { View, HitShape, HandleKind, NodeId, PointerSessionCancelReason, DeviceProfile, Bounds, Action, SelectionMode, SelectionExtendKey, SelectionApi, DepSchema, GestureBinding, ToolKeybinding, HotkeyTrigger, ModifierState, RuleCtx, Rule, IngestItem, OngoingOverlay, DebugSink, DepName, ActionsProp, OverlayRole, ResizeAnchor, Point2 } from '@weasel-js/routing';
+export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionPresentation, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepName, DepRegistry, DepSchema, DetectedDeviceFacts, DeviceProfile, Dispatcher, DispatcherContext, DragSample, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, MatchResult, ModeShortcutHandlers, 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, ToolLifecycleCtx, ToolModifiers, ToolPresentation, ToolSlot, UiOngoingControl, Point2 as Vec2, View, actionBindings, actionItems, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDepRegistry, createDispatcher, defineTool, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, pastDragThreshold, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
+import { S as SimulationNode, U as UseSimulationOptions, a as Simulation, P as PathBuilder } from './math-MCQcf_gc.js';
+export { D as DEFAULT_ALPHA_DECAY, b as DEFAULT_ALPHA_MIN, c as DEFAULT_VELOCITY_DECAY, d as PathStation, e as PointAlongPathOptions, f as SimulationCore, g as SimulationForce, h as SimulationOptions, i as aabbCenter, j as createSimulation, k as ellipsePath, l as linePath, p as pointAlongPath, m as pointInRotatedRect, n as polygonFromPoints, o as polylineFromPoints, r as rectCorners, q as rectPath, s as regularPolygonPath, t as rotatePoint, u as rotatedRectCorners, v as starPath } from './math-MCQcf_gc.js';
+import { Yoke } from '@weasel-js/routing/react';
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, DepRegistryProvider, DispatcherChannels, InputScope, OngoingAction, UseGestureDispatcherOptions, Yoke, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useYoke } from '@weasel-js/routing/react';
+import { GestureSpec } from '@weasel-js/gestures';
 export { ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetSpec, WheelSpec } from '@weasel-js/gestures';
-import { S as SimulationNode, U as UseSimulationOptions, a as Simulation, P as PathBuilder } from './math-DRa6HBBs.js';
-export { D as DEFAULT_ALPHA_DECAY, b as DEFAULT_ALPHA_MIN, c as DEFAULT_VELOCITY_DECAY, d as PathStation, e as PointAlongPathOptions, f as SimulationCore, g as SimulationForce, h as SimulationOptions, i as aabbCenter, j as createSimulation, k as ellipsePath, l as linePath, p as pointAlongPath, m as pointInRotatedRect, n as polygonFromPoints, o as polylineFromPoints, r as rectCorners, q as rectPath, s as regularPolygonPath, t as rotatePoint, u as rotatedRectCorners, v as starPath } from './math-DRa6HBBs.js';
-import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1 } from '@weasel-js/routing/react';
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, DepRegistry, DepRegistryProvider, DispatcherChannels, OngoingAction, UseGestureDispatcherOptions, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, 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-D_74YlWs.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-D_74YlWs.js';
+import { B as BoundsConstraint, P as PointSnapBehavior, R as RotateBehavior, L as LassoSelectBehavior, S as SnapStrategy, M as MoveBehavior, I as InsertBehavior } from './types-qYpyTAiZ.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-qYpyTAiZ.js';
 import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-rZa9W5hJ.js';
 export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-rZa9W5hJ.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-7mCcm6qG.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-7mCcm6qG.js';
-import { M as MoveAdapter, A as AreaSelectAdapter, c as LassoHitMode, d as LassoSelectAdapter, R as ResizeAdapter, e as RotateAdapter, L as LayoutStrategy, f as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, b as LayoutDropTargetMode, O as OrderedAdapter, a as SceneAdapter, g as LayoutSnap } from './types-CxC8P6W0.js';
-export { h as ContainerBounds, D as DropRegion, i as DropTarget, j as LayoutChild, k as LayoutContainer, l as LayoutDragged, S as SnapTarget } from './types-CxC8P6W0.js';
+import { U as UseResizeOptions } from './pointSnapToGrid-Dp2IxLGb.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-Dp2IxLGb.js';
+import { M as MoveAdapter, A as AreaSelectAdapter, c as LassoHitMode, d as LassoSelectAdapter, R as ResizeAdapter, e as RotateAdapter, L as LayoutStrategy, f as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, b as LayoutDropTargetMode, O as OrderedAdapter, a as SceneAdapter, g as LayoutSnap } from './types-D-9QWBy5.js';
+export { h as ContainerBounds, D as DropRegion, i as DropTarget, j as LayoutChild, k as LayoutContainer, l as LayoutDragged, S as SnapTarget } from './types-D-9QWBy5.js';
+import { U as UseMoveOptions, O as OriginProjection } from './grid-CY5UKlZh.js';
+export { R as RECT_ORIGIN_PROJECTION, g as gridSnapStrategy, p as pointToGridCell } from './grid-CY5UKlZh.js';
 import { a as PolygonPath, P as Path, R as RectPath } from './path-JEV2c5If.js';
 export { b as PathFillRule } from './path-JEV2c5If.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { PaintedCursorState, CursorSpec } from '@weasel-js/cursor';
+export { BakeOptions, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSpec, PaintedCursor, PaintedCursorFrame, PaintedCursorState, ResolvedCursor, bakeCursor, createPaintedCursorState, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
 import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
+import { ModeRegistry, ModeDecorations } from '@weasel-js/modes';
 import { PlacementAlign, Rect, Mat3 } 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, TextVerticalAlign, TextPaint } 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, RunSourceMap, SCRIPT_METRICS, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextPaint, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextTransform, TextVerticalAlign, TransformedRunText, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, layoutTextPose, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, textPoseLayoutInput, toRuns, transformRunTexts, verticalAlignOffset } from '@weasel-js/text';
+import { Reflection } from '@weasel-js/registry';
+export { Reflectable, ReflectedEntry, Reflection, RegisterOptions, Registrant, createReflectable } from '@weasel-js/registry';
 import { G as Guide } from './types-D2tTKEU0.js';
 export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-_XOyF7t4.js';
-export { U as UseInsertOptions } from './options-CzjxFoYZ.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 { FontStyle, FontVariant, LocalFontOutlinesResult, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
-
-/**
- * The kit version a build was compiled from, so an app can report what it is
- * running. Substituted at build time — by `tsup.config.ts` for the published
- * package, and by `scripts/vite-build-info.ts` for anything in this repo that
- * bundles core's source through the workspace aliases.
- *
- * Apps pair this with their own compile timestamp; the kit deliberately does
- * not carry one, since a published package's build date says nothing about
- * when the app embedding it was built.
- */
-/**
- * Semver of `@weasel-js/core` as of the build.
- *
- * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler
- * that hasn't been given the define — honest about not knowing rather than
- * throwing, since nothing about version reporting should be able to break a
- * consumer's build.
- */
-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;
+export { FontFamilyFaces, FontStyle, FontVariant, LocalFontOutlinesResult, OutlineFaceInfo, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
 
 /** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
 interface ViewTransform {
@@ -78,64 +58,6 @@ declare function worldToScreen(worldX: number, worldY: number, view: ViewTransfo
 /** 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
- * with `gridSnapStrategy` / `createGridLayer` so the visual hover preview
- * uses the exact same spacing as the snap behavior.
- *
- * Wires three things you'd otherwise glue by hand:
- *   1. pointermove on a target element → client coords
- *   2. client coords → world coords via your `ViewTransform`
- *   3. world coords → integer `{col, row}` via `pointToGridCell`
- *
- * State updates only fire when the cell actually changes (not on every
- * pointer tick). Pass `onChange` to trigger a canvas redraw on each transition.
- */
-
-/** Options for `useGridCellHover`. */
-interface UseGridCellHoverOptions {
-    /** Element to attach pointer listeners to (typically the canvas). */
-    ref: RefObject<HTMLElement | null>;
-    /** Read the current view transform. Called on every pointermove so it can
-     *  reflect live pan/zoom without a re-binding step. */
-    view: () => ViewTransform;
-    /** Cell spacing in world units. Same value you pass to `createGridLayer`
-     *  and `createCellHighlightLayer`. */
-    spacing: UnitValue;
-    /** Required if `spacing` is tagged (e.g. `{ value: 1, unit: 'ft' }`). */
-    unitSystem?: UnitSystem;
-    /** Origin the cell grid is anchored to, in world units. Default `(0, 0)`. */
-    origin?: {
-        x: number;
-        y: number;
-    };
-    /** Fires when the hovered cell changes (including to/from `null`). Use it
-     *  to invalidate your layer renderer. */
-    onChange?: (cell: {
-        col: number;
-        row: number;
-    } | null) => void;
-    /** Disable the listeners without unmounting. Default `true`. */
-    enabled?: boolean;
-}
-/** Return shape of `useGridCellHover`. */
-interface UseGridCellHoverReturn {
-    /** Current hovered cell, or `null` when the pointer is outside the element. */
-    cell: {
-        col: number;
-        row: number;
-    } | null;
-    /** Stable callback that returns the current cell — drop straight into
-     *  `createCellHighlightLayer({ getCell })`. */
-    getCell: () => {
-        col: number;
-        row: number;
-    } | null;
-}
-/** 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
@@ -178,489 +100,209 @@ declare function viewZoom(view: View): number;
  */
 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. */
+ * `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;
-    /** 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[];
+    kind: 'body' | 'handle' | 'rotation' | 'anchor';
+    shape: HitShape;
 }
-/**
- * @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. */
+/** A handle drawn during the current frame, and where. */
+interface RecordedHandle {
     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';
+    position: {
         x: number;
         y: number;
-        hitRadiusPx: number;
-    } | {
-        kind: 'rect';
+    };
+    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;
-    } | {
-        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: {
+}
+/** A node's transform origin as used during the current frame. */
+interface RecordedOrigin {
+    id: string;
+    point: {
         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?: {
+/** 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;
 }
-/**
- * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
- * so existing implementations keep typechecking; the added fields are how a
- * consumer's own chrome says the things kit chrome says through
- * `AffordanceRegion` — which cursor to show, and whether it owns the point
- * outright.
- */
-interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
-    /** Cursor while the pointer is over this hit. Reaches the hover-cursor
-     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
-    cursor?: CursorSpec;
-    /** `'exclusive'` bars every binding whose target doesn't consult the
-     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
-     *  meaning as `AffordanceHit.strength`, which it becomes. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-}
-
-/**
- * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
- * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
- * supplies it explicitly so layers don't have to know about DPR.
- */
-interface Dims {
-    width: number;
-    height: number;
-}
-/**
- * What a layer's `draw` threw, and which layer threw it.
- *
- * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an
- * uncaught `requestAnimationFrame` error on the window and takes the whole
- * frame with it — every other layer included. One broken layer painting
- * nothing, named in the console, is the lesser wrong.
- */
-interface LayerDrawFailure {
-    layerId: string;
-    error: unknown;
-}
-/**
- * Several consecutive layers composited as one.
- *
- * A layer's own `effects` run over that layer alone, which is the wrong
- * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not
- * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A
- * group draws its members into one buffer, runs one chain over it, and
- * composites the result back once.
- *
- * Membership is by `RenderLayer.id` — the same names `layerOrder` and
- * `layerVisibility` use, not the `layers` map's slot keys.
- *
- * Only *consecutive* members share a buffer, because anything drawn between
- * two members has to land between them. A group whose members are separated in
- * the render order is drawn as one bracket per run, with a warning: the
- * picture is right, the declaration almost certainly is not.
- *
- * This is a render-stack bracket, not a scene `ContainerNode` — it holds no
- * ids, survives no reload, and nothing in the scene knows about it.
- */
-interface LayerGroup {
-    /** Names the group in warnings; not a layer id and never drawn. */
-    id: string;
-    /**
-     * Member layer ids. Order here is ignored — the render order decides.
-     *
-     * A name claims that layer and every layer under it in the `:` namespace, so
-     * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers
-     * draws as — the same set `before`/`after: 'scene'` anchors against. The
-     * separator is required: `'scene'` does not reach `scenery`. A name matching
-     * no layer being drawn is warned about rather than ignored.
-     */
-    layers: readonly string[];
-    /**
-     * Passes over the group's combined pixels, in order. A thunk is re-read on
-     * every frame, so an animating radius costs no React render; an array is
-     * read once per frame either way.
-     */
-    effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);
-    /** Opacity applied to the group's composited result, not to each member. */
-    alpha?: number;
-    /** 4×5 color matrix (row-major, 20 numbers) applied to the composited
-     *  result. See `GroupDrawCommand.colorMatrix`. */
-    colorMatrix?: number[];
-}
-/** One layer's memoized output, keyed by layer id. Owned by the canvas that
- *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */
-type LayerCommandCache = Map<string, {
-    deps: readonly unknown[];
-    cmds: DrawCommand[];
-}>;
-/**
- * A single named render sub-layer within a canvas renderer.
- *
- * @template TData - The data object passed to each draw call.
- */
-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. */
+/** A render layer that drew during the current frame. */
+interface RecordedLayer {
     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;
+    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[];
 }
+
 /**
- * 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.
+ * The kit version a build was compiled from, so an app can report what it is
+ * running. Substituted at build time — by `tsup.config.ts` for the published
+ * package, and by `scripts/vite-build-info.ts` for anything in this repo that
+ * bundles core's source through the workspace aliases.
  *
- * `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.
+ * Apps pair this with their own compile timestamp; the kit deliberately does
+ * not carry one, since a published package's build date says nothing about
+ * when the app embedding it was built.
  */
-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.
+ * Semver of `@weasel-js/core` as of the build.
  *
- * **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.
+ * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler
+ * that hasn't been given the define — honest about not knowing rather than
+ * throwing, since nothing about version reporting should be able to break a
+ * consumer's build.
  */
-declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: string[] | undefined): boolean;
+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;
+
 /**
- * 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.
+ * Pointer-tracking glue that turns hover position into a grid cell, suitable
+ * for dropping straight into `createCellHighlightLayer({ getCell })`. Pairs
+ * with `gridSnapStrategy` / `createGridLayer` so the visual hover preview
+ * uses the exact same spacing as the snap behavior.
  *
- * 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.
+ * Wires three things you'd otherwise glue by hand:
+ *   1. pointermove on a target element → client coords
+ *   2. client coords → world coords via your `ViewTransform`
+ *   3. world coords → integer `{col, row}` via `pointToGridCell`
  *
- * 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.
+ * State updates only fire when the cell actually changes (not on every
+ * pointer tick). Pass `onChange` to trigger a canvas redraw on each transition.
  */
-declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
+
+/** Options for `useGridCellHover`. */
+interface UseGridCellHoverOptions {
+    /** Element to attach pointer listeners to (typically the canvas). */
+    ref: RefObject<HTMLElement | null>;
+    /** Read the current view transform. Called on every pointermove so it can
+     *  reflect live pan/zoom without a re-binding step. */
+    view: () => ViewTransform;
+    /** Cell spacing in world units. Same value you pass to `createGridLayer`
+     *  and `createCellHighlightLayer`. */
+    spacing: UnitValue;
+    /** Required if `spacing` is tagged (e.g. `{ value: 1, unit: 'ft' }`). */
+    unitSystem?: UnitSystem;
+    /** Origin the cell grid is anchored to, in world units. Default `(0, 0)`. */
+    origin?: {
+        x: number;
+        y: number;
+    };
+    /** Fires when the hovered cell changes (including to/from `null`). Use it
+     *  to invalidate your layer renderer. */
+    onChange?: (cell: {
+        col: number;
+        row: number;
+    } | null) => void;
+    /** Disable the listeners without unmounting. Default `true`. */
+    enabled?: boolean;
+}
+/** Return shape of `useGridCellHover`. */
+interface UseGridCellHoverReturn {
+    /** Current hovered cell, or `null` when the pointer is outside the element. */
+    cell: {
+        col: number;
+        row: number;
+    } | null;
+    /** Stable callback that returns the current cell — drop straight into
+     *  `createCellHighlightLayer({ getCell })`. */
+    getCell: () => {
+        col: number;
+        row: number;
+    } | null;
+}
+/** Track which grid cell the pointer is over; pairs with `createCellHighlightLayer`. */
+declare function useGridCellHover(opts: UseGridCellHoverOptions): UseGridCellHoverReturn;
 
 /**
  * Grid overlay — a reusable render layer that draws a world-space grid with
@@ -1375,6 +1017,9 @@ declare function meanScale(s: {
     y: number;
 }): number;
 
+/** Whether `value` is a plain object — a literal or `Object.create(null)` — from any realm. */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+
 /**
  * Screen-pixel lengths in world units, per axis.
  *
@@ -1502,6 +1147,7 @@ declare function useDropZone<T extends HTMLElement>(opts: DropZoneOptions): (el:
  * and missed-release recovery, teardown — belongs to `openPointerSession`.
  */
 interface ThresholdDragOptions {
+    /** Travel, in CSS pixels, that makes the press a drag. Default `DRAG_THRESHOLD_PX`. */
     threshold?: number;
     /** Element the session opens on. Defaults to `e.currentTarget`; a list must
      *  pass its container, since a grabbed row unmounting drops capture. */
@@ -1610,7 +1256,7 @@ interface DeviceProfileProviderProps {
  * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so
  * overlays, affordances, and consumer chrome all read the same object.
  */
-declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): React$1.FunctionComponentElement<React$1.ProviderProps<DeviceProfile | null>>;
+declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): react.FunctionComponentElement<react.ProviderProps<DeviceProfile | null>>;
 
 /**
  * Compute the largest uniform zoom (px per content-unit) that fits a content
@@ -1837,10 +1483,9 @@ declare function actionShortcuts(action: Action, params?: Readonly<Record<string
  *   - `onMove`: update the in-scratch `currentDelta`, and publish the frame's
  *     poses as ephemeral overrides. No *document* writes, so the undo stack
  *     still sees one entry for the whole drag.
- *   - `onEnd('commit')`: emit the final delta as transform ops and route
- *     them through the consumer `applyOps` hook when present, else
- *     `scene.applyBatch(ops, 'Move', adapter)` — either way a single batch
- *     → exactly one undo entry for the whole drag.
+ *   - `onEnd('commit')`: emit the final delta as transform ops and commit
+ *     them as one batch (`commitGestureOps`) → at most one undo entry for the
+ *     whole drag, none when the binding's params make it transient.
  *   - `onEnd('cancel')`: drop the overrides — the document was never mutated,
  *     so the committed poses are the restoration.
  *
@@ -1893,8 +1538,9 @@ declare const moveAction: Action & {
  *
  * Performs real anchor-relative resize math for rect-shaped poses. Reads
  * `ctx.drag.affordance.anchor` to determine which corner is fixed, captures
- * start poses, applies per-frame bounds remapping, and commits a single
- * `scene.batch` entry on end.
+ * start poses, applies per-frame bounds remapping, and commits one batch on
+ * end — labeled, transient and observed per the `resizePolicy` dep's
+ * lifecycle fields.
  *
  * ## Behaviors / point-snap / expandIds — via the `resizePolicy` dep
  *
@@ -1960,7 +1606,8 @@ declare const resizeAction: Action & {
  * - 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.
+ * - Behaviors (`opts.behaviors`) see the first rotated node's turned pose; a
+ *   pose one returns from `onMove` sets the rotation for the whole selection.
  * - No overlay rendering — deferred to Phase 7 overlay surface.
  * - Shift-snap (15° quantum) is NOT wired in this phase — omitted deliberately
  *   to keep the invoker self-contained (would need to read shift from onMove ctx).
@@ -2211,7 +1858,8 @@ declare const cloneAction: Action & {
  * `viewportDragPanAction` — ongoing Action descriptor for drag-to-pan the viewport.
  *
  * ## Bindings
- * - Plain drag (any target) → pan the viewport in screen space
+ * None of its own. The hand tool binds a drag to it, and a canvas that pans on
+ * any unclaimed drag adds `dragPanContribution`.
  *
  * ## Design notes
  * The drag delta from the dispatcher is in screen space (pixels). The pan
@@ -2459,25 +2107,34 @@ declare const editAnchorsAction: Action & {
  * Implements lasso-select via the full pointermove stream (accumulated in
  * `InvocationCtx.drag.points` by the dispatcher extension):
  *   - `start`: initializes vertex list from the drag-start world point.
- *   - `onMove`: appends the current world point (skipping duplicates closer
- *     than `minVertexSpacing = 2` world-px).
+ *   - `onMove`: appends the current world point, skipping one closer than
+ *     the binding's `params.minVertexSpacing` (default 2 world-px) to the
+ *     last vertex.
  *   - `onEnd('commit')`: performs hit-testing against the accumulated polygon.
- *     Uses `dep.hitTestLasso(polygon, 'centers')` when available, otherwise
- *     falls back to the polygon's AABB via `dep.hitTestArea(bounds)`.
+ *     Uses `dep.hitTestLasso(polygon, mode)` when available — `mode` from the
+ *     binding's `params.mode`, default `'intersect'` — otherwise falls back to
+ *     the polygon's AABB via `dep.hitTestArea(bounds)`.
  *     Extends selection with shift, replaces otherwise.
  *   - `onEnd('cancel')`: no-op.
  *
+ * ## Behaviors
+ *
+ * `opts.behaviors` (`LassoSelectBehavior[]`) run over a `GestureContext`
+ * whose `origin.get('gesture')` is the start pose, whose scratch holds the
+ * vertices under `LASSO_VERTICES`, and whose adapter answers selection and
+ * hit-testing from the `lassoSelect` dep. `onEnd` is first-non-undefined-wins:
+ * `Op[]` is applied in place of the default selection, `null` aborts, and
+ * all-`undefined` falls through to it.
+ *
  * ## Dep
  *
  * Requires `lassoSelect` dep from DepSchema:
  *   `{ hitTestLasso?(...), hitTestArea(...), getSelection(), setSelection(ids) }`
  *
- * ## What this does NOT wire (vs `useLassoSelect`)
+ * ## What this does NOT wire
  *
- * - Live overlay rendering — deferred to the overlay surface.
- * - `LassoSelectBehavior` pipeline — uses default replace/extend semantics.
- * - Transient vs. committed history modes — always transient (no undo entry),
- *   matching `useLassoSelect`'s `defaultTransient: true` convention.
+ * - Committed history — always transient (no undo entry); a behavior's ops
+ *   are applied the same way.
  * - Debug sink recording.
  */
 
@@ -2785,7 +2442,7 @@ declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose
 
 /** Options for `useResizePolicy`. Each omitted field falls back to the kit
  *  default. */
-interface UseResizePolicyOptions<TPose> {
+interface UseResizePolicyOptions<TPose> extends GestureLifecycleOptions {
     constraints?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];
     pointSnap?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never[];
     expandIds?: (ids: string[]) => string[];
@@ -2928,49 +2585,12 @@ declare function createVelocityTracker(): VelocityTracker;
  *  over the last 100ms — the throw speed a momentum decay starts from. */
 declare function useVelocityTracker(): VelocityTracker;
 
-/**
- * Detects two-finger pinch on a canvas element.
- *
- * @param onPinch Called with the gesture midpoint in **client coordinates** and
- *   a per-frame scale factor (ratio of current distance to previous frame's
- *   distance, not cumulative from gesture start). With 3+ fingers, the first
- *   two by insertion order are tracked.
- */
-declare function usePinchGesture(canvasRef: React.RefObject<HTMLElement | null>, onPinch: (anchor: {
-    x: number;
-    y: number;
-}, scaleFactor: number) => void, enabled?: boolean): void;
-
 /**
  * `InterpolatorFactory<View>` for camera animation — built once per animation,
  * called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.
  */
 declare function interpolateView(from: View, to: View): (t: number) => View;
 
-/**
- * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
- *
- * `@weasel-js/routing` never reads an overlay — it collects the live ones and
- * hands them back in scope order — so it leaves the element type open. What a
- * weasel canvas draws is a `RenderLayer`, and every kit call site should see
- * that rather than `unknown`, so core binds the parameter once, here, and
- * re-exports these names under the ones they have always had.
- */
-
-/** What a canvas overlay is, at this layer. */
-type Overlay = RenderLayer<unknown>;
-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>;
-declare const useTools: (opts: UseToolsOptions) => ToolsApi;
-
 /** Options for `useKeybindings`. */
 interface UseKeybindingsOptions {
     /** Skip all wiring. Useful for touch apps or test isolation. */
@@ -2982,7 +2602,7 @@ interface UseKeybindingsOptions {
     /**
      * Gate for keyboard tool activation: return false to refuse a tool the
      * active mode doesn't allow. `<SceneCanvas>` wires this from
-     * `getActiveMode` + each tool's `eligibility.capabilities`, using the same predicate
+     * its `modes` registry + each tool's `eligibility.capabilities`, using the same predicate
      * `ToolPalette` uses to grey a button out — so the grey-out becomes a
      * guarantee rather than a hint.
      *
@@ -3029,9 +2649,6 @@ 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. */
@@ -3071,12 +2688,26 @@ interface ToolPrefNumber extends ToolPrefBase<'number', number> {
     max?: number;
     step?: number;
     control?: ToolPrefNumberControl;
-    format?: ToolPrefNumberFormat;
+    /** How the value shows, speaks and reads back when typed — `compact()`
+     *  reads `2.00M`. Presentation only: the stored value stays a number. */
+    display?: Display;
     unit?: ToolPrefNumberUnit;
 }
+/**
+ * Stored-value bridge for a boolean leaf whose field is not a boolean — the
+ * flag counterpart of {@link ToolPrefEnumEncoding}. `TextStyle.fontStyle` is
+ * the case: it stores `'italic'`, and the control is an Italic toggle.
+ */
+interface ToolPrefBooleanEncoding {
+    /** Whether `stored` reads as on. */
+    read: (stored: unknown, siblings: Record<string, unknown> | undefined) => boolean;
+    /** What to store for `on`. `undefined` removes the field. */
+    write: (on: boolean, siblings: Record<string, unknown> | undefined) => unknown;
+}
 /** An on/off pref. */
 interface ToolPrefBoolean extends ToolPrefBase<'boolean', boolean> {
     control?: ToolPrefBooleanControl;
+    encoding?: ToolPrefBooleanEncoding;
 }
 /** A free-text pref. */
 interface ToolPrefString extends ToolPrefBase<'string', string> {
@@ -3104,8 +2735,16 @@ interface ToolPrefEnumEncoding<T extends string = string> {
     /** What to store for `option`. `undefined` removes the field. */
     write: (option: T, siblings: Record<string, unknown> | undefined) => unknown;
 }
-/** A pref with a fixed set of labeled choices. */
-interface ToolPrefEnum<T extends string = string> extends ToolPrefBase<'enum', T> {
+/** A pref with a fixed set of labeled choices. `default` is `undefined` only
+ *  for a {@link ToolPrefEnum.clearable} leaf, whose absence is a value. */
+interface ToolPrefEnum<T extends string = string> extends ToolPrefBase<'enum', T | undefined> {
+    /**
+     * The field may hold none of the options, and that absence is a state of
+     * its own rather than a missing value — a script that is neither super nor
+     * sub. A toggle control then lets the chosen segment be clicked off, which
+     * removes the field.
+     */
+    clearable?: boolean;
     /** `short` is the label a segmented control uses when a full one would not
      *  fit — a capital or two. `icon` names a glyph in the host UI's set
      *  (weasel-ui resolves it against `ICON_PATHS`) and outranks `short` where
@@ -3136,207 +2775,84 @@ interface ToolPrefColor extends ToolPrefBase<'color', string> {
     alpha?: boolean;
 }
 /**
- * Open leaf: any node with a `kind` outside the built-ins. Schema-driven
- * UIs (weasel-ui `PrefsForm` / `SelectionPanel`) dispatch it to an
- * app-supplied renderer. Deliberately NOT index-signatured so concrete
- * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.
- */
-type ToolPrefCustom = ToolPrefBase<string, unknown>;
-/**
- * A whole `FillStyle`, not a color inside one. Use it wherever the value is
- * the tagged paint union — a solid color, a pattern, a gradient — rather
- * than a hex string.
- *
- * Addressing `…fill.color` instead reads `undefined` off a gradient (so the
- * control shows its default and claims the text is black) and writes a
- * hybrid `{ fill: 'gradient', stops, color }` that the renderer's structural
- * `'color' in paint` checks then paint flat solid. The union has to be
- * edited as a union.
- */
-interface ToolPrefPaint extends ToolPrefBase<'paint', unknown> {
-    /** Offer an opacity control alongside the color. */
-    alpha?: boolean;
-}
-/**
- * A leaf whose value is one object, with its own fields hanging off it.
- *
- * A compound value — a stroke, a shadow, a pattern spec — could be described
- * as several sibling leaves addressing into it (`data.stroke.width`,
- * `data.stroke.cap`). It shouldn't be: each control would then write one field
- * of a value it can only half see, and writing into something that is not an
- * object yet corrupts it. Here the fields are `children` of one leaf, and
- * every edit commits the parent object whole.
- *
- * `children` paths are relative to the object. They are ordinary leaves, so a
- * field that is itself a union (a stroke's `paint`) declares the kind that
- * edits that union. A child may also be a {@link ToolPrefGroup}, which
- * organises the fields under a heading without contributing to the path —
- * the same rule group keys follow at the top level. A `TextStyle` needs it:
- * its character and paragraph fields belong to one value but read as two
- * lists.
- */
-interface ToolPrefObject extends ToolPrefBase<'object', unknown> {
-    children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
-    /**
-     * Lift a non-object value into the object form, for a consumer field that
-     * may also be held as a scalar. Called before a child edit is applied;
-     * without it a scalar-valued leaf shows its children empty and refuses the
-     * edit.
-     */
-    fromScalar?: (value: unknown) => Record<string, unknown>;
-}
-/** One built-in pref leaf. `ToolPrefLeaf` widens this to include
- *  app-defined kinds. */
-type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor | ToolPrefPaint | ToolPrefObject;
-/**
- * The built-in kinds, as a table. A kind added to {@link ToolPrefKind} is a
- * compile error here, and from here it is one in every renderer's `never`
- * guard — the only thing standing between a new kind and rendering as
- * nothing in four places at once.
- */
-declare const TOOL_PREF_KINDS: Record<ToolPrefKind, true>;
-/**
- * Narrows a leaf to the built-in union, so a renderer's switch discriminates
- * on {@link ToolPrefKind} instead of the open `string` that
- * {@link ToolPrefCustom} widens `kind` to. An app-defined kind answers false
- * and belongs to the renderer's custom-renderer path.
- */
-declare function isBuiltinToolPref(leaf: ToolPrefLeaf): leaf is ToolPref;
-/** Built-in or app-defined leaf. */
-type ToolPrefLeaf = ToolPref | ToolPrefCustom;
-/** Nestable group: branch nodes a tool can use to organize its prefs. */
-interface ToolPrefGroup {
-    /** Heading for the group's rows. **Empty means no heading** — for a group
-     *  that exists to organise, not to name: one whose children are themselves
-     *  groups carrying the labels a reader needs. Give it a name whenever the
-     *  name is the referent (a `Border` group over `Top` / `Right` / `Bottom`
-     *  reads as nothing without it). */
-    name: string;
-    description?: string;
-    children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
-}
-
-/**
- * `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;
+ * Open leaf: any node with a `kind` outside the built-ins. Schema-driven
+ * UIs (weasel-ui `PrefsForm` / `SelectionPanel`) dispatch it to an
+ * app-supplied renderer. Deliberately NOT index-signatured so concrete
+ * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.
+ */
+type ToolPrefCustom = ToolPrefBase<string, unknown>;
+/**
+ * A whole `FillStyle`, not a color inside one. Use it wherever the value is
+ * the tagged paint union — a solid color, a pattern, a gradient — rather
+ * than a hex string.
+ *
+ * Addressing `…fill.color` instead reads `undefined` off a gradient (so the
+ * control shows its default and claims the text is black) and writes a
+ * hybrid `{ fill: 'gradient', stops, color }` that the renderer's structural
+ * `'color' in paint` checks then paint flat solid. The union has to be
+ * edited as a union.
+ */
+interface ToolPrefPaint extends ToolPrefBase<'paint', unknown> {
+    /** Offer an opacity control alongside the color. */
+    alpha?: boolean;
 }
-/** A render layer that drew during the current frame. */
-interface RecordedLayer {
-    id: string;
-    label: string;
-    space: 'world' | 'screen';
-    index: number;
+/**
+ * A leaf whose value is one object, with its own fields hanging off it.
+ *
+ * A compound value — a stroke, a shadow, a pattern spec — could be described
+ * as several sibling leaves addressing into it (`data.stroke.width`,
+ * `data.stroke.cap`). It shouldn't be: each control would then write one field
+ * of a value it can only half see, and writing into something that is not an
+ * object yet corrupts it. Here the fields are `children` of one leaf, and
+ * every edit commits the parent object whole.
+ *
+ * `children` paths are relative to the object. They are ordinary leaves, so a
+ * field that is itself a union (a stroke's `paint`) declares the kind that
+ * edits that union. A child may also be a {@link ToolPrefGroup}, which
+ * organises the fields under a heading without contributing to the path —
+ * the same rule group keys follow at the top level. A `TextStyle` needs it:
+ * its character and paragraph fields belong to one value but read as two
+ * lists.
+ */
+interface ToolPrefObject extends ToolPrefBase<'object', unknown> {
+    children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
+    /**
+     * Lift a non-object value into the object form, for a consumer field that
+     * may also be held as a scalar. Called before a child edit is applied;
+     * without it a scalar-valued leaf shows its children empty and refuses the
+     * edit.
+     */
+    fromScalar?: (value: unknown) => Record<string, unknown>;
 }
-/** Everything the sink collected, ready for the overlay to draw. */
-interface DebugSnapshot {
-    hitboxes: RecordedHitbox[];
-    handles: RecordedHandle[];
-    bounds: RecordedBounds[];
-    origins: RecordedOrigin[];
-    snap: RecordedSnap[];
-    layers: RecordedLayer[];
+/** One built-in pref leaf. `ToolPrefLeaf` widens this to include
+ *  app-defined kinds. */
+type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor | ToolPrefPaint | ToolPrefObject;
+/**
+ * The built-in kinds, as a table. A kind added to {@link ToolPrefKind} is a
+ * compile error here, and from here it is one in every renderer's `never`
+ * guard — the only thing standing between a new kind and rendering as
+ * nothing in four places at once.
+ */
+declare const TOOL_PREF_KINDS: Record<ToolPrefKind, true>;
+/**
+ * Narrows a leaf to the built-in union, so a renderer's switch discriminates
+ * on {@link ToolPrefKind} instead of the open `string` that
+ * {@link ToolPrefCustom} widens `kind` to. An app-defined kind answers false
+ * and belongs to the renderer's custom-renderer path.
+ */
+declare function isBuiltinToolPref(leaf: ToolPrefLeaf): leaf is ToolPref;
+/** Built-in or app-defined leaf. */
+type ToolPrefLeaf = ToolPref | ToolPrefCustom;
+/** Nestable group: branch nodes a tool can use to organize its prefs. */
+interface ToolPrefGroup {
+    /** Heading for the group's rows. **Empty means no heading** — for a group
+     *  that exists to organise, not to name: one whose children are themselves
+     *  groups carrying the labels a reader needs. Give it a name whenever the
+     *  name is the referent (a `Border` group over `Top` / `Right` / `Bottom`
+     *  reads as nothing without it). */
+    name: string;
+    description?: string;
+    children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
 }
 
 /** Options for `useSelectTool`: how a point resolves to nodes, how a click
@@ -3391,11 +2907,6 @@ interface UseSelectToolOptions<TPose> {
     /** 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
-     *  but not read by this tool. */
-    move?: UseMoveOptions<TPose>;
     /**
      * When this returns true, a Shift/Meta extend-click must NOT change the
      * node selection.
@@ -3410,16 +2921,6 @@ interface UseSelectToolOptions<TPose> {
      * clicking a different node exits edit mode as usual.
      */
     extendClickLocked?: () => boolean;
-    /** Optional debug sink. Reserved for future overlay/affordance hitbox
-     *  recording. */
-    debug?: DebugSink;
-    /** Reparent-on-drop behavior for drag-to-move. `'off'` (default)
-     *  preserves translate-only commits. `'top'` lands the moved nodes at
-     *  the top of the container under the drop point. `'above'` lands them
-     *  immediately above the hit sibling in z-order (falls back to `'top'`
-     *  semantics when the hit is itself a container). Requires the
-     *  `nodeAtPoint` dep to be registered (sourced by `<SceneCanvas>`). */
-    reparentOnDrop?: 'off' | 'top' | 'above';
 }
 /** Intersection of the move + area-select adapter interfaces.
  *  Resize and rotate run through `resizeAction` / `rotateAction`. */
@@ -3430,17 +2931,96 @@ type SelectAdapter<TNode extends {
  *  - `select.pick` classifies the press (pointerDown) — it runs the tool's own
  *    pickBest/pickEvery so click semantics (selection replace, extend,
  *    deferred collapse) live in one place.
- *  - drag is owned exclusively by the dispatcher via `Tool.bindings`
- *    (selected-body → moveAction, rotate-handle → rotateAction, handle:* →
- *    resizeAction, empty → areaSelectAction, click on empty → clearSelection).
- *  - Move ghosts render via the preview-ghost layer (driven by moveAction's
- *    `previewIds`/`previewPose`); the marquee renders via the dispatcher
- *    overlay layer (driven by areaSelectAction's `overlay()`).
+ *  - an empty drag marquees (`areaSelect`) and a click on empty clears the
+ *    selection (`clearSelection`); the marquee renders via the dispatcher
+ *    overlay layer, driven by areaSelectAction's `overlay()`.
+ *  - moving and transforming the selection are not the tool's: they are the
+ *    ambient bindings in `selectionContributions.ts`.
  */
 declare function useSelectTool<TNode extends {
     id: string;
 }, TPose>(adapter: SelectAdapter<TNode, TPose>, options: UseSelectToolOptions<TPose>): Tool<null>;
 
+/** Option surface for the `rotate` action. */
+
+/** Options for the `rotate` action. `selectionTransformBindings` threads
+ *  them into the rotation handle's binding. */
+interface UseRotateOptions<TPose> {
+    /** Behaviors are typed against the pose shape; typed `never` for a pose
+     *  without a numeric `rotation`. `onMove` sees the first rotated node's
+     *  turned pose, and a pose it returns sets the rotation for the whole
+     *  selection. */
+    behaviors?: TPose extends RotatedPose ? RotateBehavior<TPose>[] : never;
+    /** History label for the committed rotation. Default `'Rotate'`. */
+    rotateLabel?: string;
+    /** Commit without an undo entry (`scene.untracked`), bypassing the
+     *  consumer `applyOps` hook. Unset, a behavior's `defaultTransient` decides. */
+    transient?: boolean;
+    /** Fired when the rotation starts, with the ids it turns. */
+    onGestureStart?: (ids: string[]) => void;
+    /** Fired once per `onGestureStart`: `true` when the rotation wrote to the
+     *  document, `false` on cancel, a behavior abort, or no net turn. */
+    onGestureEnd?: (committed: boolean) => void;
+    /** Multi-selection pivot mode. Default `'union'`.
+     *  - `'each'`: each item rotates around its own center.
+     *  - `'union'`: each item rotates around the selection's union center;
+     *    item centers orbit the union center while also gaining the same
+     *    rotation delta.
+     *  Has no effect on single-id gestures. */
+    pivot?: 'each' | 'union';
+}
+
+/**
+ * The ambient bindings that act on the selection: moving it, cloning it, and
+ * resizing or rotating it from its handles. They belong to the selection, not
+ * to the select tool, so they run under any tool that does not claim the
+ * gesture itself. `<SceneCanvas features>` installs them as the `move` and
+ * `transform` presets.
+ */
+
+/** Options for {@link selectionMoveContribution}. */
+interface SelectionMoveOptions<TPose = unknown> {
+    /** Move-action options: `behaviors` become the move bindings'
+     *  `opts.behaviors`, everything else their `opts.params`. */
+    move?: UseMoveOptions<TPose>;
+    /** Reparent-on-drop behavior for drag-to-move. `'off'` (default) keeps
+     *  translate-only commits. `'top'` lands the moved nodes at the top of the
+     *  container under the drop point; `'above'` lands them immediately above the
+     *  hit sibling. Requires the `nodeAtPoint` dep (`<SceneCanvas>` sources it). */
+    reparentOnDrop?: 'off' | 'top' | 'above';
+}
+/** Id of the entry {@link selectionMoveContribution} builds. */
+declare const SELECTION_MOVE_ID = "selection.move";
+/** Id of the entry {@link selectionTransformContribution} builds. */
+declare const SELECTION_TRANSFORM_ID = "selection.transform";
+/** Drag a body to move the selection; Alt-drag to clone it. */
+declare function selectionMoveBindings<TPose>(options?: SelectionMoveOptions<TPose>): GestureBinding[];
+/** Options for {@link selectionTransformContribution}. Resize takes its
+ *  options through the `resizePolicy` dep (`useResizePolicy`), not here. */
+interface SelectionTransformOptions<TPose = unknown> {
+    /** Rotate-action options: `behaviors` become the rotate binding's
+     *  `opts.behaviors`, everything else its `opts.params`. */
+    rotate?: UseRotateOptions<TPose>;
+}
+/** Drag a resize handle to resize the selection, the rotation handle to rotate it. */
+declare function selectionTransformBindings<TPose>(options?: SelectionTransformOptions<TPose>): GestureBinding[];
+/** An always-live entry carrying {@link selectionMoveBindings}. Add it to a
+ *  canvas's ambient list; `<SceneCanvas features={['move']}>` does. */
+declare function selectionMoveContribution<TPose>(options?: SelectionMoveOptions<TPose>): Contribution;
+/** An always-live entry carrying {@link selectionTransformBindings}. Add it
+ *  to a canvas's ambient list; `<SceneCanvas features={['transform']}>` does. */
+declare function selectionTransformContribution<TPose>(options?: SelectionTransformOptions<TPose>): Contribution;
+/** Id of the entry {@link areaSelectContribution} builds. */
+declare const AREA_SELECT_ID = "selection.areaSelect";
+/** A press on empty canvas: no hit, and not on chrome over it — the rotation
+ *  handle and the outer half of a resize handle sit off the body. */
+declare const onEmptyCanvas: (hit: unknown, body?: string) => boolean;
+/** An always-live entry that marquee-selects on a drag across empty canvas,
+ *  under any tool that does not claim the drag itself. No preset installs it:
+ *  the select tool already marquees, and a canvas that wants it under every
+ *  tool adds this to its ambient list. */
+declare function areaSelectContribution(): Contribution;
+
 /**
  * Pick the topmost id from a body-hit list, using whatever signal the
  * adapter exposes.
@@ -3524,6 +3104,14 @@ interface HandScratch {
  */
 declare function useHandTool(opts?: UseHandToolOptions): Tool<HandScratch | null>;
 
+/** Id of the entry {@link dragPanContribution} builds. */
+declare const DRAG_PAN_ID = "viewport.dragPanBinding";
+/** An always-live entry that pans the view on a drag no tool claims. No preset
+ *  installs it: the hand tool pans, space-held or chosen, and a canvas that
+ *  should pan on a plain drag — a viewer, a map — adds this to its ambient
+ *  list. `params` are `viewport.dragPan`'s, as the hand tool passes them. */
+declare function dragPanContribution(params?: DragPanParams): Contribution;
+
 /** Text tool. Drag-rect insertion is owned end-to-end by the dispatcher's
  *  `insertAction` (kind: `'text'`); click-on-selected-text-node enters edit
  *  mode via the `enterTextEdit` action.
@@ -3585,10 +3173,17 @@ declare namespace useTextTool {
                 readonly default: false;
             };
             script: {
-                kind: string;
+                kind: "enum";
                 name: string;
                 description: string;
+                control: "toggle";
+                clearable: true;
                 default: undefined;
+                options: {
+                    value: string;
+                    label: string;
+                    icon: string;
+                }[];
             };
             textTransform: {
                 kind: "enum";
@@ -3919,34 +3514,22 @@ interface LinePoint {
  */
 declare function useLineTool(): Tool<null>;
 
-/** Option surface for the `lasso-select` action.
- *
- *  Lives in a sibling file (not `lassoSelect.ts`) so the type contract stays
- *  stable even after the legacy `useLassoSelect` hook is gone.
- *  Consumers should import from here directly; `lassoSelect.ts`
- *  re-exports the same symbol for back-compat. */
+/** Option surface for the `lasso-select` action. */
 
 /** Options for the `lasso-select` action. */
 interface UseLassoSelectOptions {
     behaviors?: LassoSelectBehavior[];
-    /** When set, overrides any behavior's `defaultTransient`. */
-    transient?: boolean;
-    /** Label used when transient is false and the hook falls back to applyOps. Default 'Lasso select'. */
-    label?: string;
-    onGestureStart?: () => void;
-    onGestureEnd?: (committed: boolean) => void;
     /** Skip vertices closer than this many world-px to the previous one.
      *  Default 2. Set 0 to record every move sample. */
     minVertexSpacing?: number;
-    /** Optional debug sink; receives the live polygon AABB on every move. */
-    debug?: DebugSink;
 }
 
 /** Options for `useLassoTool` — the lasso-select action's options plus the
  *  tool's own hit mode and activation key. */
-interface UseLassoToolOptions extends Pick<UseLassoSelectOptions, 'behaviors' | 'transient' | 'label' | 'onGestureStart' | 'onGestureEnd' | 'minVertexSpacing' | 'debug'> {
-    /** Hit mode forwarded to the default `selectFromLasso` behavior when no
-     *  explicit `behaviors` array is passed. Default 'intersect'. */
+interface UseLassoToolOptions extends UseLassoSelectOptions {
+    /** Hit mode for the action's own selection commit, which runs when no
+     *  behavior claims the gesture. A behavior carries its own, as
+     *  `selectFromLasso({ mode })` does. Default 'intersect'. */
     mode?: LassoHitMode;
     /** Override the default keybinding (`{ key: 'L' }`). Pass `null` to omit. */
     keybinding?: ToolKeybinding | null;
@@ -4798,6 +4381,13 @@ interface CanvasSurfaceHelpers {
  *  are split so a per-view set can be built independently of the surface's,
  *  not to make layers ask for one. */
 interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {
+    /**
+     * The view this draw is for: a `<CanvasView>` id, or `null` for the
+     * surface's own camera. One layer array paints every view, so a layer that
+     * belongs in some views and not others — a minimap's indicator — declines
+     * the rest by this id.
+     */
+    readonly viewId: string | null;
 }
 
 /**
@@ -5286,12 +4876,14 @@ type LayerSlotValue<TNode extends {
 }, TPose> = StandardSlotConfig<TNode, TPose> | CustomLayerEntry | null;
 /** The canvas's render stack, as named slots. The standard slots (grid,
  *  scene, selection overlay, cell highlight) can be configured, replaced with
- *  a layer of your own, or switched off; further keys add custom layers. */
+ *  a layer of your own, or switched off; further keys add custom layers.
+ *  `TSceneSlot` is what the scene slot accepts: `<SceneCanvas>` takes a
+ *  partial config and fills the rest from its defaults. */
 type LayersMap<TNode extends {
     id: string;
-}, TPose> = {
+}, TPose, TSceneSlot = SceneSlotConfig<TNode, TPose>> = {
     grid?: GridSlotConfig | null;
-    scene?: SceneSlotConfig<TNode, TPose> | null;
+    scene?: TSceneSlot | null;
     /** Selection-overlay slot. Canvas constructs the layer from a
      *  `SelectionOverlaySlotConfig`; pass a `CustomLayerEntry` (`{ layer }`) to
      *  supply a pre-built layer (e.g. from `<SceneCanvas>`). */
@@ -5302,7 +4894,7 @@ type LayersMap<TNode extends {
      *  is set. */
     cellHighlight?: CustomLayerEntry | null;
 } & {
-    [customKey: string]: LayerSlotValue<TNode, TPose> | undefined;
+    [customKey: string]: LayerSlotValue<TNode, TPose> | TSceneSlot | undefined;
 };
 /**
  * What `<SceneCanvas selectionMode>` lets the canvas do to the selection.
@@ -5366,6 +4958,11 @@ interface CanvasProps<TNode extends {
      *  `subscribeFrame` callback, still waits for a frame — painting it in place
      *  would recurse. */
     syncPaint?: boolean;
+    /** External state the paint reads that no layer declares — typically what
+     *  an `alphaFor` consults. Each source is subscribed while mounted and
+     *  repaints the canvas when it notifies. A layer that reads outside state
+     *  declares it on `RenderLayer.subscribe` instead. */
+    redrawOn?: readonly RedrawSource[];
     /**
      * Combined adapter for scene-slot rendering, bounds computation, and
      * move/resize/rotate gesture math. Optional — bare-Canvas consumers that
@@ -5433,9 +5030,7 @@ interface CanvasProps<TNode extends {
      * Requires `inputElement`: with no element of its own there is nowhere for
      * pointer input, focus or the cursor to live, and nothing renders.
      *
-     * N canvases can then share one GL context and one buffer. Each needs its
-     * own `<WeaselProvider isolate>` — under a shared `<ActionsProvider>` only
-     * the newest responds to input and the rest go silently dead.
+     * N canvases can then share one GL context and one buffer.
      */
     paintInto?: {
         canvas: HTMLCanvasElement | null;
@@ -5449,14 +5044,14 @@ interface CanvasProps<TNode extends {
      */
     inputElement?: HTMLElement | null;
     className?: string;
-    style?: React__default.CSSProperties;
+    style?: react__default.CSSProperties;
     tabIndex?: number;
     /** Fired when the canvas element gains focus. The canvas is focusable by
      *  default (`tabIndex` 0), so consumers driving focus-dependent chrome —
      *  a focus ring, a "keyboard shortcuts active" hint — need to observe it. */
-    onFocus?: React__default.FocusEventHandler<HTMLCanvasElement>;
+    onFocus?: react__default.FocusEventHandler<HTMLCanvasElement>;
     /** Fired when the canvas element loses focus. */
-    onBlur?: React__default.FocusEventHandler<HTMLCanvasElement>;
+    onBlur?: react__default.FocusEventHandler<HTMLCanvasElement>;
     /**
      * When `true` (default), the canvas element receives focus on `pointerdown`
      * so keyboard events (tool hotkeys, undo/redo) are captured without a
@@ -5506,7 +5101,7 @@ interface CanvasProps<TNode extends {
      * Useful for custom layers that render scene content outside of the standard
      * slot system and need to stay in sync with gesture previews.
      */
-    helpersRef?: React__default.MutableRefObject<CanvasHelpers<TPose> | null>;
+    helpersRef?: react__default.MutableRefObject<CanvasHelpers<TPose> | null>;
     /**
      * Debug overlay configuration.
      *  - `undefined` (default): read `?debug=…` from the URL.
@@ -5520,7 +5115,7 @@ interface CanvasProps<TNode extends {
     debug?: DebugConfig | false;
     /** Test-only escape hatch: writes the live debug sink to this ref so tests
      *  can call `snapshot()` after a render. No effect when debug is off. */
-    debugSinkRef?: React__default.MutableRefObject<(DebugSink & {
+    debugSinkRef?: react__default.MutableRefObject<(DebugSink & {
         snapshot(): DebugSnapshot;
     }) | null>;
     /**
@@ -5757,43 +5352,63 @@ declare function sceneToAdapter<TData, TLayer extends string, TPose>(scene: Scen
  */
 declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
 
-/** Option surface for the `rotate` action.
- *
- *  Lives in a sibling file (not `rotate.ts`) so the type contract stays stable
- *  even after the legacy `useRotate` hook is gone.
- *  Consumers should import from here directly; `rotate.ts` re-exports the
- *  same symbols for back-compat. */
-
-/** 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` 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;
-    /** Optional debug sink. When supplied, records the rotation-handle
-     *  position + circular hitbox at gesture start. Tree-shakes via
-     *  optional-chain when omitted. */
-    debug?: DebugSink;
-    /** World-pixel distance from the AABB top edge to the rotation handle.
-     *  Used for debug-recording the handle position. Default
-     *  `DEFAULT_ROTATION_HANDLE_DISTANCE`. */
-    rotationHandleDistance?: number;
-    /** Hit-test radius for the rotation handle, in screen pixels. Used for
-     *  the recorded debug hitbox circle. Default `8`. */
-    handleHitRadius?: number;
-    /** Multi-selection pivot mode. Default `'union'`.
-     *  - `'each'`: each item rotates around its own center.
-     *  - `'union'`: each item rotates around the selection's union center;
-     *    item centers orbit the union center while also gaining the same
-     *    rotation delta.
-     *  Has no effect on single-id gestures. */
-    pivot?: 'each' | 'union';
+/** Reads the surface's deps from inside `SurfaceContribution.attach`. */
+interface ContributionDepReader {
+    get<K extends DepName>(name: K): DepSchema[K] | undefined;
 }
+/**
+ * A feature a surface installs in one step. Every role is optional: `bindings`,
+ * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus
+ * the two below. Installing it installs every role it declares, and removing
+ * it removes them.
+ */
+interface SurfaceContribution extends Contribution {
+    /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */
+    views?: readonly CanvasViewProps[];
+    /**
+     * Runs once the surface mounts; returns its teardown. For what the roles
+     * above cannot say — a registered (hit-testable) layer, a subscription.
+     *
+     * Keyed by the function's identity, so a contribution built once (in a
+     * `useMemo`, or at module scope) attaches once however often the host
+     * re-renders.
+     */
+    attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;
+}
+/**
+ * Concatenate contribution bundles into one registry, preserving order. Throws
+ * on a duplicate entry id, dep name or view id — two features answering for
+ * the same name is a bug in whichever was added second.
+ */
+declare function mergeContributions<T extends SurfaceContribution>(...bundles: readonly (readonly T[])[]): T[];
+
+/**
+ * The behavior presets `<SceneCanvas features>` composes. A bare canvas renders
+ * its scene and keeps a selection nothing sets; every behavior beyond that is
+ * turned on by naming a preset here.
+ */
+/** A behavior preset for `<SceneCanvas features>`. `draw` names every other
+ *  one. */
+type Feature = 'view' | 'pick' | 'move' | 'transform' | 'edit' | 'arrange' | 'paths' | 'ingest' | 'draw';
+/** Every preset except `draw`, which only abbreviates them. */
+type BaseFeature = Exclude<Feature, 'draw'>;
+/** Every preset `<SceneCanvas features>` accepts, `draw` last. */
+declare const SCENE_CANVAS_FEATURES: readonly Feature[];
+/**
+ * The kit-standard actions each preset registers.
+ *
+ * Every id `useStandardActions` knows appears under exactly one preset, except
+ * the ones in {@link TOOL_DRIVEN_ACTION_IDS}. `move` and `transform` also bring
+ * the ambient bindings that route drags to their actions, and `pick` brings the
+ * select tool; this table is only the registration half.
+ */
+declare const FEATURE_ACTION_IDS: Readonly<Record<BaseFeature, readonly string[]>>;
+/**
+ * Kit-standard actions no preset registers: they belong to the tools that bind
+ * them. A canvas registers each one whenever a tool it carries names it in a
+ * binding — `insert` with any shape tool, `enterTextEdit` with the text tool.
+ */
+declare const TOOL_DRIVEN_ACTION_IDS: readonly string[];
 
 /**
  * The kit's built-in shape kinds — one table, every other spelling derived.
@@ -5802,7 +5417,7 @@ interface UseRotateOptions<TPose> {
  * 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.
+ * `BUILTIN_TOOL_IDS` / `defaultNodeRouting` / `defaultNodeProperties` enumerate.
  *
  * This module imports nothing on purpose: `useBuiltinShapeTools` imports the
  * package barrel, so anything barrel-reachable that needs these lists at
@@ -5823,7 +5438,7 @@ interface ShapeKindDescriptor {
 /**
  * Declaration order is the enumeration order of every derived list —
  * `KIT_SHAPE_KINDS`, and through it `defaultNodeRouting` /
- * `defaultNodeProperties` / `BUNDLE_TOOLS.exhaustive`.
+ * `defaultNodeProperties` / `BUILTIN_TOOL_IDS`.
  */
 declare const SHAPE_KINDS: {
     readonly rect: {
@@ -6064,30 +5679,28 @@ declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$
  *  number they always got. Kit-internal use sites multiply by
  *  `DeviceProfile.targetScale`. */
 declare const DEFAULT_HANDLE_SIZE: 8;
+/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,
+ *  since the defaults fill in whatever it leaves out. */
+type SceneCanvasLayers<TNode extends {
+    id: string;
+}, TPose> = LayersMap<TNode, TPose, Partial<SceneSlotConfig<TNode, TPose>>>;
 /** Built-in tool ids that aren't shape tools — the ones with no entry in
  *  the `core/shapeKinds` table. */
 declare const NON_SHAPE_BUILTIN_TOOLS: readonly ["select", "hand"];
 /** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop
- *  is supplied. Pass a subset via `defaultTools` to slim the registered set. */
+ *  is supplied, via `defaultTools`. */
 type BuiltinToolId = (typeof NON_SHAPE_BUILTIN_TOOLS)[number] | BuiltinShapeToolId;
-/** Named preset tool collections for the `toolBundle` prop. Maps to a
- *  `BuiltinToolId[]` consumed by SceneCanvas's internal `useTools`. */
-type ToolBundle = 'minimal' | 'standard' | 'exhaustive';
-/** Tool-id contents of each named `ToolBundle`. Public so consumers (e.g.
- *  the Bundle Inspector) can introspect the same map SceneCanvas uses to
- *  expand `toolBundle` without mirroring it. The `src/index.barrel.test.ts`
- *  parity gate enforces that every `ToolBundle` id appears here with a
- *  non-empty tool list. */
-declare const BUNDLE_TOOLS: Record<ToolBundle, readonly BuiltinToolId[]>;
+/** Every built-in tool id, shape tools included. */
+declare const BUILTIN_TOOL_IDS: readonly BuiltinToolId[];
 /** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields
  *  modality dispatch needs; extends as the kit's `Hit` type evolves. */
 interface SceneCanvasHit {
     id: string;
     kind: string;
 }
-/** 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. */
+/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing
+ *  else it renders that scene and keeps a selection no input sets; `features`
+ *  turns behavior on by preset, and the rest configures what those turn on. */
 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
@@ -6108,10 +5721,11 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
         nodes: ReadonlyArray<unknown>;
     };
     /** Layer configuration. When omitted, SceneCanvas applies kit defaults
-     *  (a scene slot that paints `node.data.color` rects + a default
-     *  selection overlay). Partial slot configs deep-merge with the
-     *  defaults; pass `slot: null` to suppress a default explicitly. */
-    layers?: LayersMap<Node$1<TData, TLayer, TPose>, TPose>;
+     *  (a scene slot that paints `node.data.fill` rects + a default
+     *  selection overlay). A partial scene or selection-overlay config is
+     *  spread over that slot's defaults; pass `slot: null` to suppress a
+     *  default explicitly. */
+    layers?: SceneCanvasLayers<Node$1<TData, TLayer, TPose>, TPose>;
     /** Layout strategies keyed by container node id (or a resolver). Forwarded
      *  to `sceneToAdapter` so `useMove`'s layout pass runs on configured
      *  containers (reflow on enter, reparent + reflow on commit). */
@@ -6271,25 +5885,53 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * Default `'single'`.
      */
     selectionMode?: CanvasSelectionMode;
+    /**
+     * Behavior presets to turn on, composable in any combination. A canvas
+     * with none renders its scene and keeps a selection (the `selection` API
+     * works) that no input sets: no tools, no standard actions or their keys,
+     * no clipboard, no drop or paste, and no selection chrome. The dispatcher
+     * is still mounted, so bindings a consumer adds work.
+     *
+     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool
+     *   (H, or hold Space). Passing `viewport` implies it.
+     * - `pick` — the select tool, as the initial active tool and Escape's
+     *   return target: click to pick, drag on empty to marquee, click on empty
+     *   to clear; and the selection outline.
+     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it
+     *   runs under any tool that does not claim the drag.
+     * - `transform` — resize and rotation handles, drawn and bound.
+     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,
+     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,
+     *   and their keys.
+     * - `arrange` — align, distribute, reorder, flip.
+     * - `paths` — pathfinder operations, path-edit entry and anchor editing.
+     * - `ingest` — dropped and pasted content (Cmd/Ctrl+V arrives as a paste).
+     * - `draw` — all of the above.
+     *
+     * Tools add the actions they bind — a shape tool brings `insert` — so
+     * `defaultTools` composes with any preset. `actions` then adds, overrides
+     * or removes on top of what the presets registered.
+     */
+    features?: readonly Feature[];
     /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.
      *
      *  **Patch form** (`Record<string, AnyTool | true | false>`): merged
-     *  into the built-in registry on top of whatever `defaultTools` /
-     *  `toolBundle` already selected.
+     *  into the built-in registry on top of whatever `defaultTools` and
+     *  `features` already selected.
      *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,
-     *      `'hand'`, …) even when it's outside the active tier — useful
-     *      for `toolBundle: 'minimal'` + `tools={{ pen: true }}`. Unknown
+     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown
      *      built-in ids warn in dev and are ignored.
      *    - `AnyTool` adds a new id or replaces an existing one
      *      (dev-only warning on replace).
      *    - `false` omits a bundled tool entirely.
      *  Auto-wiring (keybindings, dispatcher, action registry) still runs.
      *
-     *  **Takeover form** (`ToolsApi`): the internal default `useSelectTool`
-     *  is bypassed and this `tools` value is forwarded to Canvas as-is —
-     *  the consumer owns active-slot management. Keybindings are still
-     *  auto-wired against the supplied registry; pass `enableKeybindings={false}`
-     *  to opt out. */
+     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and
+     *  this `tools` value is forwarded to Canvas as-is — the consumer owns
+     *  active-slot management, and `pick`'s select tool is theirs to supply.
+     *  Every other preset still applies. Keybindings are still auto-wired
+     *  against the supplied registry; pass `enableKeybindings={false}` to opt
+     *  out. */
     tools?: ToolsApi | Record<string, AnyTool | true | false>;
     /**
      * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas
@@ -6322,51 +5964,43 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      */
     onToolsCreated?: (tools: ToolsApi) => void;
     /**
-     * Named preset for the built-in tool set: `'minimal'` (select + hand),
-     * `'standard'` (select + hand + rect + ellipse + line), or `'exhaustive'` (every built-in including polygon,
-     * star, lasso, text, clone). When set, defines the starting set;
-     * `defaultTools` (if also passed) overrides it. Ignored when the
-     * consumer supplies their own `tools` prop.
-     */
-    toolBundle?: ToolBundle;
-    /**
-     * Which built-in tools SceneCanvas registers in its internal `useTools`.
-     * Default: `['select']` (plus `'hand'` when the
-     * `viewport` feature is on). Pass a smaller array to slim — e.g.
-     * `['select']` for move-only. Wins over `toolBundle` when both are
-     * passed. Ignored when the consumer supplies their own `tools` prop.
+     * Built-in tools SceneCanvas registers in its internal `useTools`, on top
+     * of the ones presets bring (`select` from `pick`, `hand` from `view`).
+     * Default: none. Each tool also registers the kit actions it binds, so
+     * `['rect']` brings `insert`. Ignored when the consumer supplies their own
+     * `tools` prop.
      */
     defaultTools?: readonly BuiltinToolId[];
     /** Per-tool option overrides for the built-in shape/lasso/clone tools.
      *  Each entry is a narrow subset of the underlying hook's options
      *  surface — `lasso.mode`, `clone.cloneSelection`, etc. */
     toolOptions?: BuiltinToolOptions;
-    /** Initial active-slot tool id. Default: `'select'`. Must be one of the
-     *  registered tools (via `defaultTools` / `toolBundle`). Useful for
-     *  demos / consumers that want to land on a non-select tool — e.g. the
-     *  lasso demo starts with `initialActiveTool="lasso"`. Ignored when the
-     *  consumer supplies their own `tools` prop. */
+    /** Initial active-slot tool id. Default: `'select'` when it is
+     *  registered, otherwise none — a canvas can run on ambient bindings
+     *  alone. Must be one of the registered tools. The lasso demo starts with
+     *  `initialActiveTool="lasso"`. Ignored when the consumer supplies their
+     *  own `tools` prop. */
     initialActiveTool?: string;
-    /** Always-on tools to register alongside the internal default select.
-     *  Use this for wheel/keyboard zoom + pan tools that should run alongside
-     *  the default select. If you supply your own `tools` prop, this is
-     *  ignored — wire `ambient` through your own `useTools` call instead. */
-    ambient?: AnyTool[];
-    /** Viewport feature wiring.
+    /** Always-on entries to register alongside the internal tools — every one
+     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions
+     *  and `attach` all install from this one list, and uninstall when the
+     *  entry leaves it. A tool is a contribution too, so one can go here. If
+     *  you supply your own `tools` prop, this is ignored — wire `ambient`
+     *  through your own `useTools` call instead. */
+    ambient?: readonly SurfaceContribution[];
+    /** Configures the `view` preset, and implies it: passing this turns
+     *  `view` on.
      *
      *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or
      *    an object to tune. Omitted means off.
      *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0) and `pinchZoom`
-     *    (two-finger pinch) are opt-OUT: on by default; pass `false` to
-     *    disable. All three are wired by registering the kit's `viewport.*`
-     *    action descriptors with the actions registry — disabling via the
-     *    `actions` prop (`actions: { 'viewport.wheelPan': null }`) also works
-     *    and runs after this.
+     *    (two-finger pinch) are on under `view`; pass `false` to disable one.
+     *    All three are wired by registering the kit's `viewport.*` action
+     *    descriptors with the actions registry — disabling via the `actions`
+     *    prop (`actions: { 'viewport.wheelPan': null }`) also works and runs
+     *    after this.
      *
-     *  When omitted entirely, no hand tool is registered but the default wheel
-     *  pan, Cmd+wheel/key zoom and pinch zoom remain wired (canvas-first
-     *  default). Pass `{ pan: false, zoom: false, pinchZoom: false }` to opt
-     *  out entirely. */
+     *  Without `view`, none of them are wired. */
     viewport?: {
         inertia?: boolean | {
             friction?: number;
@@ -6468,10 +6102,16 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      */
     views?: readonly CanvasViewProps[];
     /**
-     * Children rendered alongside the canvas. Useful for siblings that need
-     * the same `<ActionsProvider>` scope (e.g. shortcuts overlays, probes).
+     * Children rendered alongside the canvas, inside its input scope (e.g.
+     * shortcuts overlays, probes).
      */
     children?: ReactNode;
+    /**
+     * A yoke to join, from `useYoke()`: canvases on one yoke share the
+     * active tool, the gesture in flight and history. Omitted, this canvas
+     * keeps its own.
+     */
+    yoke?: Yoke;
     /**
      * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,
      * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a
@@ -6486,20 +6126,14 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      */
     chromeVisibility?: VisibilityRules;
     /**
-     * Returns the active mode id + the capability tags the mode allows.
-     * Defaults to `{ id: 'normal', allowedCapabilities: new Set() }` when
-     * omitted. Apps using the modality machine should derive this from
-     * `modality.machine.registry.current()` (mode.id + mode.allows union
-     * with implicit capability tags).
-     *
-     * Threading this through enables mode-aware chrome (selection outline,
-     * resize handles, rotation handle are off in path-edit mode) and the
-     * dispatcher's eligibility filter in later phases.
+     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).
+     * The canvas reads the active mode from it to gate chrome, tool
+     * activation and the dispatcher's eligibility filter, repaints when it
+     * switches, and hands every registered mode to the dev-time route-conflict
+     * check. Omitted, the canvas behaves as the kit's normal mode and nothing
+     * revokes anchor editing.
      */
-    getActiveMode?: () => {
-        id: string;
-        allowedCapabilities: ReadonlySet<string>;
-    };
+    modes?: ModeRegistry;
     /**
      * Override detected device facts. Merged over what `matchMedia` reports;
      * `targetScale` is re-derived from the merged `coarsePointer` unless you
@@ -6617,22 +6251,23 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      */
     onDoubleClick?: (hit: SceneCanvasHit | null) => void;
 };
-declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose>, ref: React__default.ForwardedRef<SceneCanvasApi>): react_jsx_runtime.JSX.Element;
+declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose>, ref: react__default.ForwardedRef<SceneCanvasApi>): react__default.JSX.Element;
 /**
  * The canvas component: renders a `Scene` and wires the interaction stack
  * around it.
  *
- * Mounting one gives you the whole default kit — an adapter synthesized from
- * the scene, the built-in tools and actions, selection, undo, and the gesture
- * dispatcher — with each piece replaceable through props. This is the intended
- * entry point; the lower-level primitives it composes are not part of the
- * public surface.
+ * Mounted bare it renders the scene, keeps a selection no input sets, and
+ * runs a gesture dispatcher for whatever bindings the consumer adds. The
+ * `features` presets turn the kit's behavior on — `features={['draw']}` is the
+ * whole editor: tools, standard actions and their keys, selection chrome,
+ * undo. This is the intended entry point; the lower-level primitives it
+ * composes are not part of the public surface.
  *
  * Its ref exposes a `SceneCanvasApi` for the imperative operations that do not
  * fit a prop (view control, hit queries, redraw requests).
  */
 declare const SceneCanvas: <TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose> & {
-    ref?: React__default.Ref<SceneCanvasApi>;
+    ref?: react__default.Ref<SceneCanvasApi>;
 }) => ReturnType<typeof SceneCanvasInner>;
 
 /** Which of the host's edges the panel is held against, per axis. */
@@ -6730,7 +6365,7 @@ interface CursorCoordsHudProps {
 }
 /** Debug overlay showing the pointer's client and world coordinates and the
  *  current frame rate, pinned to the canvas's top-right corner. */
-declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }: CursorCoordsHudProps): react_jsx_runtime.JSX.Element | null;
+declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }: CursorCoordsHudProps): react.JSX.Element | null;
 
 /** Props for `<PickHud>`. */
 interface PickHudProps {
@@ -6754,7 +6389,7 @@ interface PickHudProps {
 }
 /** Debug overlay listing every node under the pointer, with the one a click
  *  would actually select shown in bold. */
-declare function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps): react_jsx_runtime.JSX.Element | null;
+declare function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps): react.JSX.Element | null;
 
 /**
  * imageCache — the kit's per-`src` image loader + cache.
@@ -7122,9 +6757,7 @@ declare function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOv
  * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,
  * a `View`, and a per-node `drawOne`, render one frame.
  *
- * Step 1 of the detached-minimap spec
- * (`docs/superpowers/specs/2026-05-31-detached-minimap-design.md`). The full
- * `<SceneCanvas>` render pipeline does much more than this (slots, layer
+ * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer
  * ordering, debug sinks, tool overlays). The helper deliberately re-implements
  * the small subset needed for a non-interactive scene view rather than
  * refactoring `<SceneCanvas>` to share code — the spec calls for that
@@ -7279,7 +6912,7 @@ interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {
      *  pointer listeners or call `toBlob` for snapshots through this. */
     canvasRef?: Ref<HTMLCanvasElement>;
 }
-declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
+declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react.JSX.Element;
 /**
  * Pointer-inert read-only scene view. See `SceneViewCanvasProps` for the
  * full surface and the module docstring for the rendering model.
@@ -7600,17 +7233,121 @@ interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
     className?: string;
     /** Forwarded ref to the underlying `<canvas>`. */
     canvasRef?: Ref<HTMLCanvasElement>;
+    /** The view id this minimap publishes its pointer under. Default
+     *  `'minimap'`. */
+    id?: string;
 }
-declare function MinimapCanvasInner<TData, TLayer extends string, TPose>(props: MinimapCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
 /**
  * Opinionated minimap. See `MinimapCanvasProps` for the full surface and
- * the module docstring for the rendering / pointer model.
+ * the module docstring for the rendering / input model.
+ *
+ * Its dispatcher, actions and deps are its own, so it never competes with
+ * the main canvas for input. The pointer store is shared when one is in scope.
  *
  * `forwardRef` is not used because the component is generic over
  * `<TData, TLayer, TPose>` and React's `forwardRef` erases generics. The
  * `canvasRef` prop is the plain-prop equivalent.
  */
-declare const MinimapCanvas: typeof MinimapCanvasInner;
+declare function MinimapCanvas<TData, TLayer extends string, TPose>(props: MinimapCanvasProps<TData, TLayer, TPose>): react.JSX.Element;
+
+/**
+ * A minimap over a `<SceneCanvas>`, written as one `SurfaceContribution`: a
+ * view through a fit camera, the pan that moves the main camera from inside
+ * it, the visible-rect indicator, and a linked crosshair.
+ */
+
+/** Options for {@link createLinkedCursorContribution}. */
+interface LinkedCursorOptions {
+    /** Entry id. Default `'linked-cursor'`. */
+    id?: string;
+    /** Views on this surface the crosshair may paint in. Default `[null]`, the
+     *  surface's own camera — the main canvas beside a detached minimap. */
+    views?: readonly (string | null)[];
+}
+/**
+ * The linked crosshair alone: this surface paints the pointer's position
+ * whenever the pointer is over some other view — another surface under the
+ * same `<PointerContextProvider>`, such as a detached `<MinimapCanvas>`.
+ *
+ * A surface carrying `createMinimapContribution` already has one, in both its
+ * views; this is for a surface without.
+ */
+declare function createLinkedCursorContribution(opts?: LinkedCursorOptions): SurfaceContribution;
+/** Options for {@link createMinimapContribution}. */
+interface MinimapContributionOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {
+    /** View and entry id. Default `'minimap'`. */
+    id?: string;
+    /** Where the minimap paints, in CSS pixels from the canvas top-left. A
+     *  function is re-read every frame, so it can follow the canvas's size. */
+    rect: ViewRect | ((outer: View, dims: Dims) => ViewRect);
+    /** What the minimap frames. Default `'scene'`, the union of leaf poses. */
+    fit?: MinimapFit<TData, TLayer, TPose>;
+    /** The surface layers the minimap paints. Default: all of them. */
+    layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];
+    /** Ground painted before the minimap's layers, so the main canvas does not
+     *  show through. */
+    background?: string;
+    /** The visible-rect indicator's stroke. */
+    indicatorStyle?: IndicatorStyle;
+}
+/**
+ * A minimap inside a `<SceneCanvas>`, installed with one entry:
+ *
+ * ```tsx
+ * const minimap = useMemo(() => createMinimapContribution({ rect: { x: 8, y: 8, w: 160, h: 110 } }), []);
+ * <SceneCanvas ambient={[minimap]} … />
+ * ```
+ *
+ * Press in it to center the main camera on that point, drag to keep it there.
+ * It shows the main camera's visible rect, and a crosshair where the pointer is
+ * over the other view. Build it once — each instance keeps the live state its
+ * layers read.
+ */
+declare function createMinimapContribution<TData = unknown, TLayer extends string = string, TPose = unknown>(opts: MinimapContributionOptions<TData, TLayer, TPose>): SurfaceContribution;
+
+/**
+ * The minimap's input: press to recenter the main camera on a world point,
+ * drag to keep it there. Both read `rootView` — never `view`, which inside the
+ * minimap's own view answers the minimap's camera.
+ */
+
+declare const MINIMAP_CENTER = "minimap.center";
+declare const MINIMAP_PAN = "minimap.pan";
+/** Move `root` so world point (`x`, `y`) sits at the center of its host,
+ *  keeping its scale. A no-op while the host is unmeasured. */
+declare function centerRootOn(root: ViewApi, x: number, y: number): void;
+/** Recenter the main camera on the pressed world point. */
+declare function minimapCenterAction(): Action;
+/** Keep the main camera centered on the pointer's world point while dragging.
+ *  Pair it with `minimap.center` on `pointerDown`, which handles the press.
+ *  A recenter lands the moment it is computed, so there is nothing to commit
+ *  and a cancel ends where a release does. */
+declare function minimapPanAction(): Action;
+
+/**
+ * The minimap's chrome: the main camera's visible rect, drawn in the minimap,
+ * and the linked crosshair, drawn in every view the pointer is not over.
+ */
+
+/** The halo's color: dark enough to separate the accent from any content. */
+declare const CROSSHAIR_HALO = "rgba(0, 0, 0, 0.6)";
+/** An axis-aligned rect, `{ x, y, w, h }`. */
+interface CrosshairRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * The linked crosshair at (`x`, `y`) as rects in the caller's units, where one
+ * screen pixel is `unitsPerPx` of them: four halo rects to paint first, then
+ * four bars. A painter with no weasel renderer — a 2D canvas — draws the same
+ * crosshair from these.
+ */
+declare function crosshairRects(x: number, y: number, unitsPerPx: number): {
+    halo: CrosshairRect[];
+    bars: CrosshairRect[];
+};
 
 /** Plain RGBA raster — structurally `ImageData`-compatible ({ width, height,
  *  data }), deliberately free of printer/dpi/physical-unit concepts. */
@@ -7772,74 +7509,21 @@ declare function SelectionContextProviderIfRoot({ children, }: {
  */
 declare function usePublishSelection(ids: readonly NodeId[], kinds?: readonly (string | undefined)[]): void;
 
-/**
- * @experimental
- * PointerContext — a tiny ambient context that publishes the world-space
- * position of the canvas pointer, refreshed on every `pointermove` over
- * the canvas. Cleared (set to `null`) on `pointerleave`.
- *
- * Why ref-based and not state-based: cursor moves fire dozens of times per
- * second; routing those through React state would re-render every consumer
- * in the tree. The context exposes a stable `pointerRef` whose `.current`
- * is mutated directly by the publisher, plus a thunk `getDropPoint()` that
- * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk
- * inside their callbacks — no subscription, no re-render.
- *
- * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when
- * the caller didn't pass an explicit `getDropPoint` option. Other future
- * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse
- * the same context.
- */
-
-/** @experimental World-space pointer position, or `null` when the pointer
- *  isn't over the publishing canvas. */
-type PointerWorldPos = {
-    worldX: number;
-    worldY: number;
-} | null;
-/** @experimental */
-interface PointerContextValue {
-    /** Live ref — mutate to publish, read for the latest snapshot. The
-     *  identity is stable for the lifetime of the provider. */
-    readonly pointerRef: MutableRefObject<PointerWorldPos>;
-    /** Convenience thunk equivalent to `() => pointerRef.current`. Stable
-     *  identity for the lifetime of the provider; safe to pass to hooks. */
-    readonly getDropPoint: () => PointerWorldPos;
-}
-/**
- * @experimental
- * Wrap the part of the React tree that should share a pointer-position
- * context. Usually placed at the demo / app root, alongside
- * `<ActionsProvider>` and `<SelectionContextProvider>`.
- *
- * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts
- * an internal provider when no parent provider is in scope, so child hooks
- * (`useClipboard` without an explicit `getDropPoint`) read the canvas's
- * tracked pointer for free.
- */
-declare function PointerContextProvider({ children }: {
-    children: ReactNode;
-}): ReactNode;
-/** @experimental Read the surrounding pointer-context value, or `null` when
- *  no provider is in scope. */
-declare function usePointerContext(): PointerContextValue | null;
-
 /** Mount a `<PointerContextProvider>` only when none is already in scope. */
 declare function PointerProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
-/** Mount an `<ActionsProvider>` only when none is already in scope, so
- *  nesting canvases share one action registry instead of shadowing it. */
+/** Mount an `<ActionsProvider>` only when none is already in scope. */
 declare function ActionsProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 /** Mount a `<DepRegistryProvider>` only when none is already in scope, so a
  *  consumer's dep sources are not shadowed by a nested canvas. */
 declare function DepRegistryProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 interface WeaselProviderProps {
     children: ReactNode;
@@ -7864,7 +7548,7 @@ interface WeaselProviderProps {
  * state has to be shared by things outside a canvas: a toolbar, a property
  * panel, or two canvases that should agree on the selection.
  */
-declare function WeaselProvider({ children, isolate }: WeaselProviderProps): react_jsx_runtime.JSX.Element;
+declare function WeaselProvider({ children, isolate }: WeaselProviderProps): react.JSX.Element;
 
 /** Options for `useCanvasFocus`. */
 interface UseCanvasFocusOptions {
@@ -7923,6 +7607,33 @@ interface GateLayerOptions<TData> {
  *  without the layer knowing anything about focus. */
 declare function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData>;
 
+/** Options for {@link workspaceTintLayer}. */
+interface WorkspaceTintLayerOptions {
+    registry: ModeRegistry;
+    /** The page, in world coordinates. When given, the tint covers only the
+     *  workspace around it, each strip fading toward the page edge if the mode
+     *  names a gradient. Without it the tint covers the whole canvas. */
+    page?: () => Rect | null;
+    /** Opacity for every mode's tint, in place of its `workspace.intensity`. */
+    intensity?: number;
+    id?: string;
+    label?: string;
+}
+/**
+ * A screen-space layer painting the active mode's `WorkspaceVisual`: nothing in
+ * a mode without a tint, otherwise a wash at the mode's intensity, bottom-up or
+ * top-down when the mode names a gradient. It subscribes to the registry, so a
+ * mode switch repaints it.
+ */
+declare function workspaceTintLayer(opts: WorkspaceTintLayerOptions): RenderLayer<unknown>;
+/** A world-space layer drawing a `ModeDecorations`' active painter. It
+ *  subscribes to the decorations, so a mode switch or a new painter repaints
+ *  it. */
+declare function modeDecorationLayer(decorations: ModeDecorations, opts?: {
+    id?: string;
+    label?: string;
+}): RenderLayer<unknown>;
+
 /**
  * Z-ordered child renderer — replaces the manual `for (id of getChildren()) ...`
  * pattern with a `RenderLayer` factory that consumes an `OrderedAdapter`.
@@ -8595,6 +8306,9 @@ interface UseTextEditOptions {
      * `UseTextEditReturn.selection`.
      */
     isEditorChrome?: (el: Element) => boolean;
+    /** What Escape does to the edit: `'cancel'` (the default) drops it,
+     *  `'commit'` keeps the text as Enter would. */
+    escape?: 'cancel' | 'commit';
 }
 /** Options for `useTextEdit().startEdit`. */
 interface StartEditOptions {
@@ -8794,6 +8508,8 @@ interface UseSceneTextEditOptions<TData> {
      * the character controls.
      */
     isEditorChrome?: (el: Element) => boolean;
+    /** Forwarded to `useTextEdit`: what Escape does to the edit. */
+    escape?: 'cancel' | 'commit';
 }
 /** Return shape extends `UseTextEditReturn` with an `onDoubleClick`
  *  binding for the canvas container. Double-clicking inside a text
@@ -9039,6 +8755,19 @@ declare function isMeshGradientFill(fill: FillStyle | null | undefined): fill is
  *  `color` — a mesh seeded from a solid has to show *something* curved, or
  *  switching kind looks like nothing happened. */
 declare function seedMeshPatch(color: string): MeshGradientFill;
+/**
+ * A stop list as a mesh: one full-height band per gap between neighboring
+ * stops, colored left to right. The bands blend exactly the way the ramp
+ * does, so a horizontal gradient survives the switch unchanged. A zero-width
+ * gap is a hard break and gets no band.
+ */
+declare function meshFromStops(stops: readonly GradStop[]): MeshGradientFill;
+/**
+ * A mesh read as a stop list: every patch's top edge — corner 0 to corner 1 —
+ * placed by its `x` across the mesh's horizontal extent. The inverse of
+ * `meshFromStops`, and for any other mesh the ramp across its top.
+ */
+declare function meshStops(mesh: MeshGradientFill): GradStop[];
 /**
  * The `<defs>` entry for a mesh paint, in weasel's own namespace.
  *
@@ -9486,6 +9215,10 @@ interface SetPathArgs {
  *  history's coalesce window. Pass an explicit key to opt out. */
 declare function createSetPathOp(args: SetPathArgs): Op;
 
+/** Rebuilds an op from its serialized `args`. */
+type OpFactory = (args: unknown) => Op;
+/** Every registered op factory, keyed by op name, in registration order. */
+declare const opFactoryRegistry: Reflection<OpFactory>;
 /** Register an op-factory builder under a stable name. The builder receives
  *  the serialized `args` and must return an `Op` equivalent to one freshly
  *  constructed at the original call site (`apply` and `invert` behave the
@@ -9693,8 +9426,8 @@ interface PointInPathOptions {
 declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
 
 /**
- * Path-vs-geometry hit-test helpers. Five pure functions covering all
- * combinations of path-vs-point, path-vs-rect, and path-vs-polygon.
+ * Path-vs-geometry hit-test helpers: pure functions covering path-vs-point,
+ * path-vs-rect, and path-vs-polygon in both directions.
  *
  * `RectPath` short-circuits to AABB arithmetic. A `PolygonPath` is treated as
  * its filled region: whether a point is inside comes from `pointInPath`, so
@@ -9721,13 +9454,8 @@ declare function pathIntersectsPolygon(path: Path, polygon: readonly Point2[], o
  * `pathContainsPoint` from `pathHitTest.ts` to get a closed-region
  * pick distance (0 inside, stroke-distance outside).
  *
- * Implementation: walks the command stream. Line segments use the exact
- * point-to-segment formula. Cubic beziers sample N+1 points along the
- * curve and reduce to point-to-segment over the polyline approximation —
- * cheap and accurate to ~1 px for typical edit-tool sampling counts.
- * Quadratic beziers fall through to the cubic sampler via equivalence.
- *
- * RectPath short-circuits to AABB-perimeter math: O(1).
+ * A polygon path defers to geom's `nearestOnPath`; a RectPath short-circuits
+ * to AABB-perimeter math.
  */
 
 /** Closest Euclidean distance from (px, py) to the boundary of `path`.
@@ -9981,22 +9709,37 @@ declare function decomposePath(parent: Path, world: Path): Path;
  *  single subpath comes back as a one-element array. */
 declare function splitSubpaths(path: PolygonPath): PolygonPath[];
 
-/** Options for `splitByLine`. */
-interface SplitByLineOptions {
-    /** Polyline flattening tolerance for the boundary-crossing gate. */
+/** Options for `splitPathBySegment`. */
+interface SplitBySegmentOptions {
+    /**
+     * Flattening tolerance for the check that decides whether contours cross
+     * each other. Only a path whose contours do cross is flattened (see
+     * `splitPathBySegment`).
+     */
     flattenTolerance?: number;
 }
 /**
- * Split `path` along the finite segment a->b into closed pieces (Knife).
+ * Split `path` along the finite segment a→b into closed pieces (Knife).
+ *
+ * Only chords the segment crosses end to end are cut: a stretch of the segment
+ * that starts or stops inside the fill cuts nothing, and nothing beyond the
+ * segment's ends is touched, so a concave shape splits exactly where the
+ * stroke crosses it. Curves are split at the crossing parameters by de
+ * Casteljau subdivision, so every piece traces the original boundary exactly
+ * and keeps its quadratic and cubic segments; the new edges along the cut are
+ * straight lines.
+ *
+ * Each connected piece the cut produces is returned as its own path, holes
+ * included. Contours the segment misses entirely are returned together as one
+ * final piece. A single chord that does not disconnect the shape (across a
+ * ring, say) returns one slit piece.
+ *
+ * A path whose contours cross each other or themselves is first resolved into
+ * non-overlapping rings by a polygon union, which flattens its curves.
  *
- * Returns `null` unless the segment enters AND exits the path boundary
- * (>=2 proper crossings) and both half-planes yield non-empty area. Otherwise
- * returns one `PolygonPath` per side of the line. Beziers are flattened
- * (see `pathIntersect`). The infinite line is used *within* a gated shape, so a
- * concave shape only partly crossed may be cut at far-side crossings - accepted
- * (see spec non-goals).
+ * Returns `null` when no chord is cut.
  */
-declare function splitPathByLine(path: Path, a: Point, b: Point, opts?: SplitByLineOptions): Path[] | null;
+declare function splitPathBySegment(path: Path, a: Point, b: Point, opts?: SplitBySegmentOptions): Path[] | null;
 
 /**
  * AABB union over a heterogeneous set of `Path` poses. Returns the
@@ -10380,6 +10123,15 @@ interface PaintKindEntry {
     colorOf(paint: FillStyle): string | undefined;
     /** Editor slot. */
     Editor?: ComponentType<PaintKindEditorProps>;
+    /**
+     * The stop list this paint reads as. With `fromStops`, it is what makes a
+     * kind a gradient: `listGradientKinds` returns the kinds carrying both, and
+     * `switchGradientKind` converts between any two of them through the list.
+     */
+    stopsOf?(paint: FillStyle): GradStop[];
+    /** A paint of this kind built from a stop list, in `bounds` units. The
+     *  converse of `stopsOf`; supply both or neither. */
+    fromStops?(stops: GradStop[]): FillStyle;
     /**
      * Render slot: bind program, uniforms and textures for `fill` and return the
      * bound program; `null` declines the paint.
@@ -10405,6 +10157,8 @@ interface PaintKindEntry {
      */
     toSvg?(id: string, fill: FillStyle): string;
 }
+/** Every registered paint kind, with the overrides each displaced. */
+declare const paintKindRegistry: Reflection<PaintKindEntry>;
 /**
  * A consumer's own paint, typed as a `FillStyle`.
  *
@@ -10417,12 +10171,27 @@ interface PaintKindEntry {
 declare function asPaint<T extends {
     fill: string;
 }>(paint: T): FillStyle;
-/** Register a paint kind. Returns a disposer that removes it. */
+/** Register a paint kind. Returns a disposer that removes it. Re-registering an
+ *  existing id is an override; disposing it uncovers whatever it displaced. */
 declare function registerPaintKind(entry: PaintKindEntry): () => void;
 /** The entry for `kind`, or `undefined`. */
 declare function getPaintKind(kind: string | undefined): PaintKindEntry | undefined;
 /** Every registered kind, built-ins first, in registration order. */
 declare function listPaintKinds(): readonly PaintKindEntry[];
+/** Every registered gradient kind — the ones that read as and build from a
+ *  stop list — in registration order. */
+declare function listGradientKinds(): readonly PaintKindEntry[];
+/**
+ * `paint` retargeted to gradient kind `kind`, or `undefined` when either side
+ * is not a gradient kind.
+ *
+ * Between two of the stop gradients this is `withGradientKind`, which carries
+ * the geometry. Any other pair goes through the stop list — `stopsOf` on the
+ * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.
+ * Lossy wherever the kinds hold different information; an editor that wants a
+ * switch to be undoable should keep the original paint.
+ */
+declare function switchGradientKind(paint: FillStyle, kind: PaintKind): FillStyle | undefined;
 /** The registry entry for a paint, or `undefined` when its kind is unknown. */
 declare function paintKindOf(fill: FillStyle): PaintKindEntry | undefined;
 /** @internal Test helper — do not call from product code. */
@@ -10476,11 +10245,18 @@ interface MarkerEntry {
     /** `'auto'` (default) follows the line; a number is a fixed angle in
      *  radians, ignoring the line — SVG's `orient="<angle>"`. */
     orient?: 'auto' | number;
+    /** The stroke fields `path` reads besides `ctx.size` — `[]` for a shape
+     *  drawn from size alone. Declared, a head is reused across stroke objects
+     *  whose listed fields are equal; omitted, only across frames that pass the
+     *  same stroke object, since `path` might read any of it. */
+    reads?: readonly (keyof Stroke)[];
     /** Emits the `<marker>` def. Consumed by `@weasel-js/svg`. */
     toSvg?(id: string, entry: MarkerEntry): string;
 }
-/** Register a marker. Returns a disposer. Re-registering a built-in id is an
- *  override; disposing it restores the built-in rather than deleting the key. */
+/** Every registered marker, with the overrides each displaced. */
+declare const markerRegistry: Reflection<MarkerEntry>;
+/** Register a marker. Returns a disposer. Re-registering an existing id is an
+ *  override; disposing it uncovers whatever it displaced rather than deleting the key. */
 declare function registerMarker(entry: MarkerEntry): () => void;
 /** The entry for `key`, or `undefined`. */
 declare function getMarker(key: string | undefined): MarkerEntry | undefined;
@@ -10499,15 +10275,17 @@ declare function _resetMarkersForTests(): void;
  * line ends.
  */
 
-/** The size of one marker unit, in the same world units as `strokeWidth`. */
-declare function resolveMarkerSize(ref: MarkerRef, strokeWidth: number): number;
+/** The size of one marker unit, in the same world units as `strokeWidth`.
+ *  `scale` is the view scale a `{ px }` size resolves against, as a `{ px }`
+ *  stroke width does. */
+declare function resolveMarkerSize(ref: MarkerRef, strokeWidth: number, scale?: number): number;
 declare function markerKeyOf(ref: MarkerRef): string;
 /**
  * How far back the ribbon stops for `ref`, in world units. Zero for an absent
  * marker, an unregistered key, or an open head — never throws, because an
  * unknown key is a data problem and dropping the head is the graceful answer.
  */
-declare function markerInset(ref: MarkerRef | undefined, strokeWidth: number): number;
+declare function markerInset(ref: MarkerRef | undefined, strokeWidth: number, scale?: number): number;
 /** The start and end insets a stroke asks for. `markerMid` never insets —
  *  trimming at an interior vertex would cut the line in two. */
 declare function strokeInsets(stroke: Stroke, strokeWidth: number): {
@@ -10554,22 +10332,6 @@ interface MarkerSiteRequest {
 }
 declare function markerSites(pl: Polyline, want: MarkerSiteRequest): MarkerSite[];
 
-/**
- * Turning a stroke's markers into draw commands.
- *
- * Separate `PathDrawCommand`s rather than triangles appended to the stroke
- * ribbon: an entry may carry a fill and an outline at once, or a paint that
- * differs from the line's, neither of which one mesh can express — and folding
- * them in would drag the whole marker vocabulary into the ribbon cache key.
- */
-
-/**
- * Every marker command for `path` under `stroke`. `strokeWidth` is the already
- * width-resolved stroke width; `flattenTolerance` matches what the ribbon used,
- * so markers land on the same flattened vertices the stroke did.
- */
-declare function markerDrawCommands(path: Path, stroke: Stroke, strokeWidth: number, flattenTolerance: number | undefined): PathDrawCommand[];
-
 /**
  * The kit's built-in stroke-marker vocabulary.
  *
@@ -10780,7 +10542,8 @@ type ModKey = keyof ModifierState;
  *      ...so the gesture applies the same delta to every dragged id.
  *
  * The pose-shape-aware delta extraction lives here — gestures stay pose-shape
- * agnostic. Default projection is `{x, y}`-bearing (rect / path / polygon).
+ * agnostic. Default projection reads a rect's `{x, y}` or a Path's bounds
+ * origin, matching `gridSnapStrategy`'s own default.
  * Pass `origin` for exotic poses.
  */
 declare function snap<TPose>(strategy: SnapStrategy<TPose>, opts?: {
@@ -11253,10 +11016,11 @@ interface SelectFromLassoOptions {
     /** Hit mode for `hitTestLasso`. Default 'intersect'. */
     mode?: LassoHitMode;
 }
-/** Default behavior for `useLassoSelect` / `useLassoTool`: replace selection
- *  with polygon hits, or extend the existing selection when shift is held at
- *  gesture start. Tiny / degenerate lassos behave like a click — clear (or
- *  preserve, with shift). */
+/** A lasso behavior (`useLassoTool({ behaviors })`): replace selection with
+ *  polygon hits in its own `mode`, or extend the existing selection when shift
+ *  is held at gesture start. Tiny / degenerate lassos behave like a click —
+ *  clear (or preserve, with shift). Hits come from the gesture adapter's
+ *  `hitTestLasso`, which under `lassoSelectAction` is the `lassoSelect` dep. */
 declare function selectFromLasso(opts?: SelectFromLassoOptions): LassoSelectBehavior;
 
 /** Edge or center the selection should align to within the selection's visual
@@ -12075,32 +11839,32 @@ interface IconProps {
 /** Classic cursor-arrow shape — filled silhouette pointing top-left to
  *  bottom-right with the diagonal "tail" along the lower edge. Used for
  *  `useSelectTool`. */
-declare function SelectIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function SelectIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Freeform marquee — outlined irregular loop with a short tail
  *  suggesting "the lasso closed where you released the pointer." Used
  *  for `useLassoTool`. */
-declare function LassoIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function LassoIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined rectangle with a small crosshair at the upper-left corner,
  *  signaling "this is a drawing tool, not just a shape." Used for the
  *  rectangle insertion tool (`useInsertTool` today, future `useRectTool`). */
-declare function RectIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function RectIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined ellipse. Used for the ellipse insertion tool. */
-declare function EllipseIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function EllipseIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Framed picture with a sun and mountain — the conventional "image" glyph.
  *  Used for the image insertion tool (`useImageTool`). */
-declare function ImageIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ImageIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Eyedropper — diagonal stem running from upper-right (bulb) to
  *  lower-left (tip), with a small squared bulb cap at the top. Used
  *  for the eyedropper / color-picker tool. */
-declare function EyedropperIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function EyedropperIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Diagonal line. Used for the line insertion tool. */
-declare function LineIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function LineIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** `LineIcon`'s diagonal with a filled head, so the two read as one tool with
  *  and without the marker. Used for the arrow insertion tool.
@@ -12109,82 +11873,82 @@ declare function LineIcon({ className, size }: IconProps): react_jsx_runtime.JSX
  *  under antialiasing and the notch disappears, leaving a blob. Its base
  *  corners are `tip ∓ 5.6·d ± 2.1·d⊥` — computed, and the shaft stops half a
  *  unit inside the base so its round cap hides under the fill. */
-declare function ArrowIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ArrowIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined hexagon. Used for the polygon insertion tool. */
-declare function PolygonIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PolygonIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined five-point star. Used for the star insertion tool. */
-declare function StarIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function StarIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Slanted pencil pointing toward the upper-right corner. Used for the
  *  freehand pencil insertion tool. */
-declare function PencilIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PencilIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Serif "T" — top bar + stem + small bottom serif. Used for
  *  `useTextTool`. Visually consistent with the layer-list text icon. */
-declare function TextIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function TextIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Pen nib — angled filled body with a pointed tip and a small ink dot
  *  at the very tip, plus a short "control" handle extending out the
  *  back. Used for `usePenTool`. */
-declare function PenIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PenIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Open hand — rounded palm with four upward fingers (variable length)
  *  and a thumb stub. Used for `useHandTool` (viewport pan). */
-declare function HandIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function HandIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Placeholder for tools without `presentation.icon`. A circle with "?"
  *  inside — readable, debuggable, not hidden. */
-declare function UnknownIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function UnknownIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Icon for the union operation: two overlapping circles merged into one filled shape. */
-declare function UnionIcon(): react_jsx_runtime.JSX.Element;
+declare function UnionIcon(): react.JSX.Element;
 /** Icon for the intersect operation: only the overlap of two circles filled. */
-declare function IntersectIcon(): react_jsx_runtime.JSX.Element;
+declare function IntersectIcon(): react.JSX.Element;
 /** Icon for the subtract operation: the front circle removed from the back one. */
-declare function SubtractIcon(): react_jsx_runtime.JSX.Element;
+declare function SubtractIcon(): react.JSX.Element;
 /** Icon for the exclude operation: both circles filled except their overlap. */
-declare function ExcludeIcon(): react_jsx_runtime.JSX.Element;
+declare function ExcludeIcon(): react.JSX.Element;
 /** Icon for the divide operation: two circles split into their separate regions. */
-declare function DivideIcon(): react_jsx_runtime.JSX.Element;
+declare function DivideIcon(): react.JSX.Element;
 /** Icon for the crop operation: the back shape clipped to the front one. */
-declare function CropIcon(): react_jsx_runtime.JSX.Element;
+declare function CropIcon(): react.JSX.Element;
 
 /** Cut: scissors. */
-declare function CutIcon(): react_jsx_runtime.JSX.Element;
+declare function CutIcon(): react.JSX.Element;
 /** Copy: a document peeking out behind another. */
-declare function CopyIcon(): react_jsx_runtime.JSX.Element;
+declare function CopyIcon(): react.JSX.Element;
 /** Paste: a clipboard with a filled clip. */
-declare function PasteIcon(): react_jsx_runtime.JSX.Element;
+declare function PasteIcon(): react.JSX.Element;
 /** Duplicate: the source outlined, the copy filled. */
-declare function DuplicateIcon(): react_jsx_runtime.JSX.Element;
+declare function DuplicateIcon(): react.JSX.Element;
 /** Group: corner brackets framing two filled rects. */
-declare function GroupIcon(): react_jsx_runtime.JSX.Element;
+declare function GroupIcon(): react.JSX.Element;
 /** Ungroup: two filled rects escaping a frame broken to two dashed corners. */
-declare function UngroupIcon(): react_jsx_runtime.JSX.Element;
+declare function UngroupIcon(): react.JSX.Element;
 /** Bring forward: two stacked rects, the front one filled. */
-declare function BringForwardIcon(): react_jsx_runtime.JSX.Element;
+declare function BringForwardIcon(): react.JSX.Element;
 /** Bring to front: three stacked rects, the frontmost filled. */
-declare function BringToFrontIcon(): react_jsx_runtime.JSX.Element;
+declare function BringToFrontIcon(): react.JSX.Element;
 /** Send backward: two stacked rects, the rear one filled. */
-declare function SendBackwardIcon(): react_jsx_runtime.JSX.Element;
+declare function SendBackwardIcon(): react.JSX.Element;
 /** Send to back: three stacked rects, the rearmost filled. */
-declare function SendToBackIcon(): react_jsx_runtime.JSX.Element;
+declare function SendToBackIcon(): react.JSX.Element;
 /** Flip horizontal: an outlined and a filled chevron either side of a dashed vertical axis. */
-declare function FlipXIcon(): react_jsx_runtime.JSX.Element;
+declare function FlipXIcon(): react.JSX.Element;
 /** Flip vertical: an outlined and a filled chevron either side of a dashed horizontal axis. */
-declare function FlipYIcon(): react_jsx_runtime.JSX.Element;
+declare function FlipYIcon(): react.JSX.Element;
 
-declare function AlignLeftIcon(): react_jsx_runtime.JSX.Element;
-declare function AlignRightIcon(): react_jsx_runtime.JSX.Element;
-declare function AlignTopIcon(): react_jsx_runtime.JSX.Element;
-declare function AlignBottomIcon(): react_jsx_runtime.JSX.Element;
-declare function AlignCenterXIcon(): react_jsx_runtime.JSX.Element;
-declare function AlignCenterYIcon(): react_jsx_runtime.JSX.Element;
+declare function AlignLeftIcon(): react.JSX.Element;
+declare function AlignRightIcon(): react.JSX.Element;
+declare function AlignTopIcon(): react.JSX.Element;
+declare function AlignBottomIcon(): react.JSX.Element;
+declare function AlignCenterXIcon(): react.JSX.Element;
+declare function AlignCenterYIcon(): react.JSX.Element;
 
-declare function DistributeHorizontalIcon(): react_jsx_runtime.JSX.Element;
-declare function DistributeVerticalIcon(): react_jsx_runtime.JSX.Element;
+declare function DistributeHorizontalIcon(): react.JSX.Element;
+declare function DistributeVerticalIcon(): react.JSX.Element;
 
 /**
  * @experimental
@@ -12201,11 +11965,11 @@ interface ActionGlyphProps extends IconProps {
     fillOpacity?: number;
 }
 /** @experimental Undo: a straight run returning in a half circle, arrowhead on the run. */
-declare function UndoIcon(p: ActionGlyphProps): react_jsx_runtime.JSX.Element;
+declare function UndoIcon(p: ActionGlyphProps): react.JSX.Element;
 /** @experimental Redo: the undo glyph mirrored. */
-declare function RedoIcon(p: ActionGlyphProps): react_jsx_runtime.JSX.Element;
+declare function RedoIcon(p: ActionGlyphProps): react.JSX.Element;
 /** @experimental Delete: a lidded trash can. */
-declare function DeleteIcon(p: ActionGlyphProps): react_jsx_runtime.JSX.Element;
+declare function DeleteIcon(p: ActionGlyphProps): react.JSX.Element;
 
 /**
  * @experimental
@@ -12246,4 +12010,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, type ActionGlyphProps, type ActionShortcut, ActionsProviderIfRoot, type Affordance, type AffordanceBinding, type AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, type AlignEdge, AlignLeftIcon, type AlignMatchResult, type AlignMoveArgs, AlignRightIcon, AlignTopIcon, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, type AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, type BakedMesh, type BindRigOptions, BooleansAdapter, BoundsConstraint, BringForwardIcon, BringToFrontIcon, 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 CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, CopyIcon, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateTiledLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CustomPaintContext, CutIcon, type CycleHandle, type CycleVertexColorsOptions, 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, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DefaultTextData, DeleteIcon, DepRegistryProviderIfRoot, type DeriveAlignmentGuidesOptions, DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type Discriminator, type DistributeAdapter, type DistributeAxis, DistributeHorizontalIcon, type DistributeMode, DistributeVerticalIcon, 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, DuplicateIcon, EasingSpec, Effect, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FeedDelta, type FeedNode, type FillPoseBox, type FitTextPoseOptions, type FlagKey, FlipXIcon, FlipYIcon, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, GlMat3, type GridLayerOpts, type GridSlotConfig, GroupIcon, 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 ImageRasterSize, 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 KeyModifiers, type KeyState, type KeyStateAttachOptions, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LayerCommandCache, type LayerDrawFailure, LayerEnumerableAdapter, type LayerGroup, type LayerHit, type LayerSlotValue, type LayersMap, LayoutDropTargetMode, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, type MeshGradientFill, type MeshPatch, type MeshPoint, 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, PasteIcon, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, 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, PointerContextProvider, type PointerContextValue, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PointerWorldPos, 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, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, RectIcon, RectPath, RectPose, RedoIcon, type RegisterNodeShapeOptions, RegisteredOp, type RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, type ResolvableView, type ResolvedOverlay, type Rig, type RigApply, type RigApplyContext, type RigScene, 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, SendBackwardIcon, SendToBackIcon, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type ShapeKind, type SharedAnchor, Simulation, SimulationNode, type Skeleton, type Slew, type SlewRates, 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 TileBleed, type TileGridOptions, type TilePatternOpts, type TilePeriod, type TileRange, 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, UndoIcon, UngroupIcon, UnionIcon, Unit, UnitEntry, 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 UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, VERSION, 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, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bakeMesh, bezierCubic, bezierQuadratic, bindRig, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, cornerWeights, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createKeyState, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSlew, createTextLayer, createTilePattern, createTiledLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleFill, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, definesFrame, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, dispatchApplyBatch, dlog, documentPose, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, dwarn, editAnchorsAction, effectivePose, effectiveRangeStyle, enterTextEditAction, enumerateAnchors, evalPatch, 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, isMeshGradientFill, isPatternSpec, isTensorPatch, isValidPatch, isVectorImageSrc, keySpecShortcut, lassoSelectAction, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, meanScale, mergeAlphaFromPrev, meshBounds, meshGradientXml, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, openFilePicker, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, patchBounds, patchCorner, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInTextPose, poseRotationOf, prefUnit, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectMarkerPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveVisibility, rgbaToHex, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotationDegreesUnit, rotationHandle, roundRectPath, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, seedMeshPatch, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, slewToward, sliceAction, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, squarePath, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, tiledProject, toHex8, transformPath, translatePath, 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, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerContext, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRig, 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 };
+export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, type ActionGlyphProps, type ActionShortcut, ActionsProviderIfRoot, Affordance, AffordanceBinding, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, type AlignEdge, AlignLeftIcon, type AlignMatchResult, type AlignMoveArgs, AlignRightIcon, AlignTopIcon, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUILTIN_TOOL_IDS, type BakedMesh, type BindRigOptions, BooleansAdapter, BoundsConstraint, BringForwardIcon, BringToFrontIcon, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CROSSHAIR_HALO, 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, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, Contribution, type ContributionDepReader, CopyIcon, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateTiledLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, type CrosshairRect, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, CutIcon, type CycleHandle, type CycleVertexColorsOptions, 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, DRAG_PAN_ID, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DefaultTextData, DeleteIcon, DepRegistryProviderIfRoot, type DeriveAlignmentGuidesOptions, DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type Discriminator, type DistributeAdapter, type DistributeAxis, DistributeHorizontalIcon, type DistributeMode, DistributeVerticalIcon, 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, DuplicateIcon, EasingSpec, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, FEATURE_ACTION_IDS, type Feature, type FeedDelta, type FeedNode, type FillPoseBox, type FitTextPoseOptions, type FlagKey, FlipXIcon, FlipYIcon, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, GlMat3, type GridLayerOpts, type GridSlotConfig, GroupIcon, 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 ImageRasterSize, 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 KeyModifiers, type KeyState, type KeyStateAttachOptions, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerGroup, LayerHit, type LayerSlotValue, type LayersMap, LayoutDropTargetMode, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, type LinkedCursorOptions, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MINIMAP_CENTER, MINIMAP_PAN, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, type MeshGradientFill, type MeshPatch, type MeshPoint, MinimapCanvas, type MinimapCanvasProps, type MinimapContributionOptions, 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 OpFactory, 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, PasteIcon, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, 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 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, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, RectIcon, RectPath, RectPose, RedoIcon, RedrawSource, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, type ResolvableView, type ResolvedOverlay, type Rig, type RigApply, type RigApplyContext, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RunStylePatch, SCENE_CANVAS_FEATURES, SELECTION_MOVE_ID, SELECTION_TRANSFORM_ID, SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasLayers, 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 SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionTransformOptions, SendBackwardIcon, SendToBackIcon, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type ShapeKind, type SharedAnchor, Simulation, SimulationNode, type Skeleton, type Slew, type SlewRates, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitBySegmentOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, type SurfaceContribution, SvgIngestOptions, TOOL_DRIVEN_ACTION_IDS, TOOL_PREF_KINDS, TextDrawCommand, type TextEditClipRect, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileBleed, type TileGridOptions, type TilePatternOpts, type TilePeriod, type TileRange, Tool, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefBooleanEncoding, 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, ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UNION_OF_CHILDREN, UndoIcon, UngroupIcon, UnionIcon, 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 UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, VERSION, type VelocityTracker, VertexColorChannel, ViewAnimationOptions, ViewApi, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, ZOOM_FLOOR, type ZoomBound, type ZoomClampOpts, type ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, areaSelectContribution, arrayAdapter, asPaint, axisAlignedBounds, bakeMesh, bezierCubic, bezierQuadratic, bindRig, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, centerRootOn, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, cornerWeights, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createKeyState, createLinkedCursorContribution, createMinimapContribution, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSlew, createTextLayer, createTilePattern, createTiledLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, crosshairRects, cycleFill, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, definesFrame, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, dispatchApplyBatch, dlog, documentPose, domPositionToCharOffset, domToRuns, dragPanContribution, dwarn, editAnchorsAction, effectivePose, effectiveRangeStyle, enterTextEditAction, enumerateAnchors, evalPatch, 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, isMeshGradientFill, isPatternSpec, isPlainObject, isTensorPatch, isValidPatch, isVectorImageSrc, keySpecShortcut, lassoSelectAction, listGradientKinds, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerInset, markerKeyOf, markerRegistry, markerSites, matchAlignment, meanScale, mergeAlphaFromPrev, mergeContributions, meshBounds, meshFromStops, meshGradientXml, meshStops, minimapCenterAction, minimapPanAction, modeDecorationLayer, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, onEmptyCanvas, opFactoryRegistry, openFilePicker, or, paintAlpha, paintKindOf, paintKindRegistry, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, patchBounds, patchCorner, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInTextPose, poseRotationOf, prefUnit, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectMarkerPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveVisibility, rgbaToHex, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotationDegreesUnit, rotationHandle, roundRectPath, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, seedMeshPatch, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, selectionMoveBindings, selectionMoveContribution, selectionTransformBindings, selectionTransformContribution, setFlagOverRange, shapeCoversPoint, slewToward, sliceAction, snap, snapPoint, solid, solidVertexColors, spiro, splitPathBySegment, splitSubpaths, springPose, springVertexColors, squarePath, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, switchGradientKind, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, tiledProject, toHex8, transformPath, translatePath, 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, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRig, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useVelocityTracker, useVisibleRaf, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, workspaceTintLayer, worldEditToStorage, worldToScreen, zoomAt, zoomAtLeast };