@weasel-js/core 1.6.1 → 1.7.0

package/dist/index.d.ts

@@ -1,44 +1,48 @@
 import * as react from 'react';
 import react__default, { RefObject, ReactNode, Ref, MouseEvent, ComponentType, MutableRefObject } from 'react';
-import { a as UnitValue, b as UnitSystem, c as UnitEntry, d as Unit, U as UseMoveOptions, O as OriginProjection } from './grid-BXdz8GF2.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-BXdz8GF2.js';
-import { View, HitShape, HandleKind, 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, DebugSink, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, IngestItem, OngoingOverlay, 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, 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, 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 { 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, a1 as ViewApi, T as TextDrawCommand, a2 as ShaderProgram, G as GlMat3, a3 as BooleansAdapter, a4 as UseAnimatorOptions, a5 as SpringPresetName, a6 as EasingSpec, a7 as AnimationHandle, a8 as SampledTrack } from './builtins-HWyuLzE-.js';
-export { a9 as AddLayerSpec, aa as AddNodeSpec, ab as AnimateToBoundsOptions, ac as AreaSelectDep, ad as BezierEasing, ae as BooleanOp, af as BooleanOpResult, ag as ClipboardDep, ah as ClipboardIngestCtx, ai as ColorOverride, aj as ColorOverrideFn, ak as ContainerNode, C as CullRect, al as DecayLoopConfig, am as DecayOptions, an as EASINGS, ao as EasingFn, ap as EasingName, aq as EditAnchorsDep, ar as EventBooking, as as EventBookingHandle, at as EventTrack, au as FitViewToBoundsOptions, a as GroupDrawCommand, av as IDENTITY_POSE_COMPOSITION, b as ImageDrawCommand, c as ImageMinification, aw as IngestCtx, ax as IngestionDep, ay as InsertDep, az as Interpolate, aA as InterpolatorFactory, aB as Keyframe, aC as LassoSelectDep, aD as LayerRecord, aE as LayoutDep, aF as LeafNode, aG as LoopFactory, aH as LoopOptions, aI as NestedTimeline, aJ as NodeAtPointDep, aK as PhysicsHandle, aL as PhysicsOptions, aM as PointerContextProvider, aN as PointerContextValue, aO as PointerWorldPos, aP as PoseAdapter, aQ as PoseClosure, aR as PoseOverride, aS as RECT_POSE_COMPOSITION, aT as RIGID_POSE_COMPOSITION, R as RenderTarget, aU as ResizePolicy, aV as SPRING_PRESETS, S as SPRITE_STRIDE, aW as SerializedNode, e as ShaderDrawCommand, g as ShaderUniform, aX as SnapDep, aY as SpringOptions, aZ as SpringPreset, i as SpriteSheet, j as SpritesDrawCommand, a_ as StaggerBuilder, a$ as StaggerDelay, b0 as StaggerFactory, b1 as StaggerOptions, b2 as StaggerPerItem, b3 as StaggerSpringPoseOptions, b4 as StaggerTweenOptions, b5 as SvgUnpacker, b6 as SystemLayerRecord, b7 as SystemLayerSpec, b8 as TextEditDep, b9 as TimelineClock, ba as TimelineEvent, bb as TimelineHandle, bc as TimelineOptions, bd as TimelineTrack, be as Track, bf as TweenLoopOptions, bg as TweenOptions, bh as UserLayerRecord, bi as VIEW_ANIMATION_KEY, bj as ViewAnimationApi, bk as ViewChannel, bl as applyBooleanOp, bm as asNodeId, m as blur, bn as composeRectPose, bo as composeRigidPose, bp as composeWorldPose, bq as createPointerStore, br as cubicBezierEasing, o as cullDrawCommands, bs as decomposeRectPose, bt as decomposeRigidPose, bu as easeIn, bv as easeInBack, bw as easeInBounce, bx as easeInCirc, by as easeInCubic, bz as easeInElastic, bA as easeInExpo, bB as easeInOut, bC as easeInOutBack, bD as easeInOutBounce, bE as easeInOutCirc, bF as easeInOutCubic, bG as easeInOutElastic, bH as easeInOutExpo, bI as easeInOutQuad, bJ as easeInOutQuart, bK as easeInOutQuint, bL as easeInOutSine, bM as easeInQuad, bN as easeInQuart, bO as easeInQuint, bP as easeInSine, bQ as easeOut, bR as easeOutBack, bS as easeOutBounce, bT as easeOutCirc, bU as easeOutCubic, bV as easeOutElastic, bW as easeOutExpo, bX as easeOutQuad, bY as easeOutQuart, bZ as easeOutQuint, b_ as easeOutSine, b$ as fitViewToBounds, p as frameRect, c0 as linear, q as mat3, c1 as rebaseLocalPose, c2 as registerContentHandler, r as registerEffect, c3 as resolveEasing, c4 as resolveStrokeWidth, c5 as translateRectPose, c6 as useDecayLoop, c7 as usePointerContext, c8 as usePointerPosition, c9 as useViewAnimation, ca as useViewAnimationOn, v as viewToMat3, u as vignette, cb as worldPoseLookup } from './builtins-HWyuLzE-.js';
-import { CursorSpec, PaintedCursorState } from '@weasel-js/cursor';
-export { BakeOptions, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSpec, PaintedCursor, PaintedCursorFrame, PaintedCursorState, ResolvedCursor, bakeCursor, createPaintedCursorState, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
-import { ClaimableGesture, GestureSpec } from '@weasel-js/gestures';
-export { ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetSpec, WheelSpec } 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 { 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 { 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 { 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 { 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';
+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 {
@@ -300,490 +304,6 @@ interface UseGridCellHoverReturn {
 /** Track which grid cell the pointer is over; pairs with `createCellHighlightLayer`. */
 declare function useGridCellHover(opts: UseGridCellHoverOptions): UseGridCellHoverReturn;
 
-interface ChromeState {
-    /** Currently selected ids. Live; reflects useSelection's React state. */
-    readonly selection: readonly NodeId[];
-    /** True when the canvas is in multi-mode AND >= 2 ids are selected. */
-    readonly multiActive: boolean;
-    /** Bounds for any selection member id. Honors active-tool overlay state
-     *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed
-     *  pose bounds). Returns null for unknown ids or ids whose bounds aren't
-     *  computable. */
-    boundsOf(id: string): Bounds | null;
-    /** Multi-union AABB when `multiActive`. Computed lazily from `boundsOf`
-     *  over every selected id, expanding rotated members to the extent of
-     *  their ink; null otherwise. */
-    readonly unionBounds: Bounds | null;
-    /** Active modifier state at the moment of the call. */
-    readonly modifiers: ModifierState;
-    /** True iff the node's pose-descriptor declares it can carry a rotation.
-     *  Affordances consult this to decide whether to expose rotate cursors /
-     *  drag-bands. Defaults to `true` when the descriptor doesn't declare
-     *  (back-compat) or when the id is unknown — the rotation gesture will
-     *  no-op visually for poses without AABB fields, but the affordance
-     *  doesn't lie about the cursor. Optional on the interface so unit-test
-     *  call sites that construct `ChromeState` by hand keep compiling;
-     *  affordances should treat an absent predicate as "true". */
-    canRotate?(id: string): boolean;
-}
-
-/**
- * @experimental
- * A single interactive piece of chrome. Pure functions; the kit composes
- * multiple affordances into a single RenderLayer per tool via
- * `composeAffordanceLayer`.
- *
- * Affordances declare interactive regions in a target's *local* frame.
- * The framework (`composeAffordanceLayer`) composes the target's bounds
- * transform (rotation around the AABB center, when present) for both paint
- * and hit-test, so the affordance never touches rotation, view.scale, or
- * world↔screen math.
- */
-interface Affordance {
-    /** Stable id for debug overlays + visibility maps. */
-    id: string;
-    /** Enumerate this affordance's interactive regions. Each region lives in
-     *  some target id's local frame (or in the world frame when `targetId`
-     *  is `null`). Returning `[]` means "no chrome for this state" (no
-     *  selection, multi-mode disabled, etc.). */
-    regions(state: ChromeState): readonly AffordanceRegion[];
-    /** Optional non-interactive decoration (e.g., a leader line drawn from
-     *  a bounds edge to a handle — visual only, not draggable). Receives
-     *  raw state + view because the decoration may live outside any single
-     *  target's local frame. Most affordances leave this undefined. */
-    decorate?(state: ChromeState, view: View): DrawCommand[];
-}
-/**
- * @experimental
- * One interactive region produced by an affordance. The framework owns
- * the local↔world transform for `targetId` (when non-null), so `shape`,
- * `paint.sizePx`, and `hitRadiusPx` are always specified in coordinates
- * the affordance can reason about directly.
- */
-interface AffordanceRegion<TScratch = unknown> {
-    /** Stable id, e.g. `corner-min-min`. Used for debug overlays + a11y. */
-    id: string;
-    /** Target id whose `state.boundsOf(targetId)` defines this region's
-     *  local frame. `bounds.rotation` (if present) is the only transform
-     *  applied — translation is the AABB origin; scale is identity. Pass
-     *  `null` for affordances anchored to the viewport / world frame
-     *  (identity transform). */
-    targetId: string | null;
-    /** Region geometry, expressed in the target's local frame.
-     *
-     *  - `point` — circular hit (`hitRadiusPx` is screen-space).
-     *  - `rect`  — axis-aligned rect (target rotation applies).
-     *  - `annulus` — outer ellipse minus inner rect cutout. Used for
-     *    invisible zones that sit *around* the AABB (e.g. rotate-on-
-     *    hover band). The outer ellipse is defined by world-space
-     *    semi-axes `rx` / `ry` around `(cx, cy)`; the inner rect is the
-     *    same target-local rect that defines the AABB. Hit-test:
-     *    inside outer ellipse AND outside inner rect. */
-    shape: {
-        kind: 'point';
-        x: number;
-        y: number;
-        hitRadiusPx: number;
-    } | {
-        kind: 'rect';
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | {
-        kind: 'annulus';
-        /** Outer-ellipse center (target-local). */
-        cx: number;
-        cy: number;
-        /** Outer-ellipse semi-axes (target-local). */
-        rx: number;
-        ry: number;
-        /** Inner rect (target-local) — the cutout. Typically the
-         *  selection's AABB. */
-        innerX: number;
-        innerY: number;
-        innerWidth: number;
-        innerHeight: number;
-        /** Minimum band thickness outside the inner rect, in **screen**
-         *  pixels. The framework widens `rx`/`ry` to at least
-         *  `innerHalfExtent + minBandPx / meanScale(view.scale)` for both
-         *  paint and hit-test.
-         *
-         *  This exists because the clamp has to know the view and the
-         *  affordance doesn't: `ChromeState` carries no scale. Expressing the
-         *  floor in world units instead (which is what the rotate ring used
-         *  to do) makes the band shrink on screen as you zoom in, until the
-         *  ring around a small shape is too thin to hover. */
-        minBandPx?: number;
-    };
-    /** Optional paint. World position is derived from `shape` + target
-     *  transform; visual size stays in screen pixels (so handles don't
-     *  warp under zoom or non-uniform scale). Omit for hit-only regions.
-     *
-     *  - `square` — small fixed-size square (only valid over `point` shapes).
-     *  - `annulus` — fill + stroke the annulus ring (only valid over
-     *    `annulus` shapes). Uses even-odd fill rule to punch the inner-rect
-     *    cutout.
-     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
-    paint?: {
-        kind: 'square';
-        sizePx: number;
-        fill?: FillStyle;
-        stroke?: Stroke;
-    } | {
-        kind: 'annulus';
-        fill?: FillStyle;
-        stroke?: Stroke;
-        insetPx?: number;
-    } | {
-        kind: 'custom';
-        draw: (ctx: CustomPaintContext) => DrawCommand[];
-    };
-    /** Discriminator a press on this region reports as `AffordanceHit.kind` —
-     *  the string routing specs match on (`'handle:top-left'`,
-     *  `'rotate-handle'`, `'anchor:3'`). Omit for regions that only exist
-     *  inside a consumer-registered layer, where the layer id is the
-     *  discriminator; `buildAffordanceAt` falls back to
-     *  `<affordanceId>:<regionId>`. */
-    hitKind?: string;
-    /** Cursor to show while hovering this region. Read by the hover-cursor
-     *  pump in `useGestureDispatcher` via `AffordanceHit.cursor`, which
-     *  `buildAffordanceAt` fills in from the region the walk landed on. */
-    cursor?: CursorSpec;
-    /** `'exclusive'` bars every binding whose target doesn't consult the
-     *  affordance. Read only when the affordance is composed into a
-     *  consumer-registered layer; kit chrome routes through
-     *  `buildAffordanceAt`, which reports `'shared'`. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-    /** Drag binding produced when this region is hit. Lazily called so
-     *  affordances don't pay binding-construction cost on every paint frame —
-     *  state snapshots (e.g., capturing per-leaf poses at click time) belong
-     *  inside `bind()`, not inside `regions()`. */
-    bind(): AffordanceBinding<TScratch>;
-}
-/** Context passed to a region's `paint.kind === 'custom'` draw callback.
- *  Provides both the world-space anchor (already transformed) and the
- *  original local shape, for affordances that want to do additional
- *  geometry themselves. */
-interface CustomPaintContext {
-    /** World-space mapping of `shape`. For `point`, only `x`/`y` are set.
-     *  For `rect`, all four fields are set. */
-    world: {
-        x: number;
-        y: number;
-        width?: number;
-        height?: number;
-    };
-    /** The original local shape (same object identity as `region.shape`). */
-    local: AffordanceRegion['shape'];
-    view: View;
-    state: ChromeState;
-}
-/**
- * @experimental
- * Result of an affordance hit — what the region computed about itself.
- *
- * `initialScratch` is the payload: what the region already knows (which
- * corner, which target id) so the action that picks up the drag doesn't
- * re-derive it. `<SceneCanvas>` reads it out of the layer hit-test and packs
- * it into `AffordanceHit`, which flows to the matching action through
- * `InvocationCtx.drag.affordance`.
- *
- * This used to also carry a `drag: DragChannel` naming the handlers the
- * tool-routing dispatcher should wire up. Every implementation supplied a
- * no-op stub that claimed, because the real routing had already moved to
- * bindings; the field went with that dispatcher.
- */
-interface AffordanceBinding<TScratch = unknown> {
-    initialScratch?: TScratch;
-}
-/**
- * The fields `buildAffordanceAt` lifts out of a region's `initialScratch`
- * when it turns a region hit into an `AffordanceHit`.
- *
- * Scratch is otherwise opaque — whatever the affordance wants to hand the
- * action that picks up the drag. These few names are the exception: they mean
- * the same thing to every affordance, and the actions that consume them
- * (`resizeAction`, `rotateAction`) read them off `AffordanceHit` rather than
- * out of scratch. An affordance that doesn't set them simply produces a hit
- * without those fields.
- */
-interface CommonAffordanceScratch {
-    /** The node (or `MULTI_RESIZE_TARGET_ID`) this chrome acts on. Becomes
-     *  `AffordanceHit.targetIds`. */
-    targetId?: string;
-    /** For resize chrome: which corner stays pinned. Mirrors the kit's
-     *  `ResizeAnchor`, spelled inline so `affordances/` doesn't take a type
-     *  dependency on the gesture layer for one field. */
-    anchor?: {
-        x: 'min' | 'max' | 'free';
-        y: 'min' | 'max' | 'free';
-    };
-    /** World-space invariant point of the transform — the fixed corner for a
-     *  resize, the pivot for a rotation. */
-    fixedPoint?: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
- * so existing implementations keep typechecking; the added fields are how a
- * consumer's own chrome says the things kit chrome says through
- * `AffordanceRegion` — which cursor to show, and whether it owns the point
- * outright.
- */
-interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
-    /** Cursor while the pointer is over this hit. Reaches the hover-cursor
-     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
-    cursor?: CursorSpec;
-    /** `'exclusive'` bars every binding whose target doesn't consult the
-     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
-     *  meaning as `AffordanceHit.strength`, which it becomes. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-}
-
-/**
- * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
- * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
- * supplies it explicitly so layers don't have to know about DPR.
- */
-interface Dims {
-    width: number;
-    height: number;
-}
-/**
- * What a layer's `draw` threw, and which layer threw it.
- *
- * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an
- * uncaught `requestAnimationFrame` error on the window and takes the whole
- * frame with it — every other layer included. One broken layer painting
- * nothing, named in the console, is the lesser wrong.
- */
-interface LayerDrawFailure {
-    layerId: string;
-    error: unknown;
-}
-/**
- * Several consecutive layers composited as one.
- *
- * A layer's own `effects` run over that layer alone, which is the wrong
- * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not
- * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A
- * group draws its members into one buffer, runs one chain over it, and
- * composites the result back once.
- *
- * Membership is by `RenderLayer.id` — the same names `layerOrder` and
- * `layerVisibility` use, not the `layers` map's slot keys.
- *
- * Only *consecutive* members share a buffer, because anything drawn between
- * two members has to land between them. A group whose members are separated in
- * the render order is drawn as one bracket per run, with a warning: the
- * picture is right, the declaration almost certainly is not.
- *
- * This is a render-stack bracket, not a scene `ContainerNode` — it holds no
- * ids, survives no reload, and nothing in the scene knows about it.
- */
-interface LayerGroup {
-    /** Names the group in warnings; not a layer id and never drawn. */
-    id: string;
-    /**
-     * Member layer ids. Order here is ignored — the render order decides.
-     *
-     * 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. */
-    id: string;
-    /** Human-readable name for UI toggles. */
-    label: string;
-    /**
-     * Emit a DrawCommand tree for the GL backend to dispatch.
-     *
-     * For world-space layers (the default), emit commands in WORLD COORDS —
-     * `drawLayers` automatically wraps them in `{ kind: 'group', transform:
-     * viewToMat3(view), ... }` before handing them to the renderer. Do NOT
-     * apply the view transform yourself.
-     *
-     * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel
-     * coords directly; `drawLayers` passes them through unchanged. If part
-     * of a screen-space layer's output needs to track the view, wrap that
-     * subset manually with `viewToMat3(view)`.
-     */
-    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
-    /**
-     * Optional cache key. When present and a `LayerCommandCache` is supplied to
-     * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as
-     * every entry is `Object.is`-equal to the previous call's. A layer with no
-     * `deps` rebuilds on every frame.
-     *
-     * **The returned commands must be treated as immutable.** A cached tree is
-     * handed to the renderer again on later frames, so mutating a tree you
-     * previously returned corrupts the cache silently rather than erroring.
-     *
-     * **Screen-space layers are not protected against a stale `view`/`dims`
-     * the way world-space layers are** (see `space` below) — include them in
-     * `deps` if `draw` reads them.
-     */
-    deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];
-    /**
-     * Whether the layer is shown when no explicit visibility entry exists.
-     * Defaults to `true` when absent.
-     */
-    defaultVisible?: boolean;
-    /**
-     * When true, the layer is always drawn regardless of the visibility map.
-     * Useful for layers that must never be hidden (e.g. base grid).
-     */
-    alwaysOn?: boolean;
-    /**
-     * Coordinate space the layer draws in.
-     *
-     * - `'world'` (default): the layer's `draw` returns world-space commands;
-     *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`
-     *   automatically.
-     * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)
-     *   commands; `drawLayers` passes them through unchanged. World-anchored
-     *   chrome inside a screen-space layer must call `worldToScreen` or wrap
-     *   the relevant subset with `viewToMat3(view)` manually.
-     */
-    space?: 'world' | 'screen';
-    /**
-     * Full-screen passes run over this layer's own pixels before it joins the
-     * frame — a blur here blurs the world and leaves the HUD drawn above it
-     * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.
-     *
-     * Costs nothing while empty: the renderer allocates no offscreen buffer
-     * until a layer actually declares one. See `GroupDrawCommand.effects` for
-     * what a pass may read, and {@link LayerGroup} to run one chain over
-     * several layers at once instead of one chain each.
-     */
-    effects?: readonly Effect[];
-    /**
-     * Optional hit-test for **consumer-attached** layers.
-     *
-     * Only layers registered through `CanvasExtensionApi.registerLayer` are
-     * hit-tested: `hitTestExtras` walks them last-registered-first on
-     * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`
-     * thunk ahead of the kit's own selection chrome. First non-null result
-     * wins; null means "I don't claim this hit, try the next layer."
-     *
-     * Layers that reach the draw stack some other way — a `Tool.overlay`, an
-     * entry in the `layers` map — are painted but never hit-tested, so defining
-     * `hitTest` on one has no effect. (The kit's own chrome doesn't need it: it
-     * goes through `buildAffordanceAt`.)
-     *
-     * Coordinates are world-space. The `data` arg is the layer's
-     * configured data slot (same as `draw`); `view` and `dims` mirror
-     * `draw`'s arguments.
-     */
-    hitTest?: (worldX: number, worldY: number, data: TData, view: View, dims: Dims, 
-    /** Chrome-caps visibility predicate. When supplied, the layer must
-     *  not return a hit from any chrome element whose id reports
-     *  `false`. Absent → every element is hittable. */
-    isVisible?: (id: string) => boolean) => LayerHit | null;
-    /**
-     * Called on every pointermove when no gesture is currently captured.
-     * Lets layers (e.g. HUD widgets) track hover state without participating
-     * in the drag pipeline. Coords are world-space; the layer is responsible
-     * for any further conversion (e.g. world→screen for screen-space layers)
-     * and for its own throttling.
-     */
-    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
-    /**
-     * Called when the cursor leaves the canvas element. Lets layers clear
-     * any hover state they're holding.
-     */
-    onUncapturedLeave?: () => void;
-}
-/**
- * Walk visible layers and concatenate their emitted DrawCommand arrays into
- * one flat list, ready to feed to `WeaselRenderer.render(commands)`.
- *
- * Visibility resolution order:
- *   1. `alwaysOn` — always drawn, ignores visibility map.
- *   2. Explicit entry in `visibility` map — overrides default.
- *   3. `layer.defaultVisible` — falls back to `true` when absent.
- *
- * Transform composition: world-space layers (the default; `space` unset or
- * `'world'`) have their commands wrapped in a `kind: 'group'` with
- * `viewToMat3(view)` before they reach the renderer. Screen-space layers
- * (`space: 'screen'`) pass through unchanged.
- *
- * A layer whose `draw` throws is dropped for the frame and reported through
- * `onLayerError` — the rest of the frame still paints.
- *
- * `groups` brackets runs of consecutive layers so they composite as one — see
- * `LayerGroup`. A layer named by no group is emitted exactly as it was before
- * groups existed, and a frame that declares none allocates nothing.
- */
-declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[]): DrawCommand[];
-/**
- * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
- * `visibility`, then `defaultVisible`, defaulting to shown.
- */
-declare function isLayerVisible<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>): boolean;
-/**
- * Does this layer reach the screen at all — both gates, in the order
- * `drawLayers` applies them.
- *
- * **A listed `order` is the whole list**, so omission from it drops a layer
- * that `visibility` would have shown, and `alwaysOn` does not rescue it.
- * Hit-testing asks this, not `isLayerVisible`: a layer that is not painted
- * but still claims pointer events is a pointer landing on nothing the user
- * can see.
- */
-declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: string[] | undefined): boolean;
-/**
- * Draw one layer and put its commands in the space its `space` declares:
- * world-space output wrapped in a `viewToMat3(view)` group, screen-space
- * output passed through.
- *
- * Anything rendering layers through a view — the canvas itself, a viewport
- * node's inner pass — goes through here. A second copy of this rule that
- * forgets the wrap draws world content at raw world coords, which looks
- * plausible at the identity view and wrong everywhere else.
- *
- * A `draw` that throws yields no commands, and `onLayerError` is told which
- * layer it was. The layer's cache entry goes with it, so the next frame is a
- * real re-attempt rather than a stale tree served under fresh deps.
- */
-declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
-
 /**
  * Grid overlay — a reusable render layer that draws a world-space grid with
  * optional finer subdivisions and accent lines every N cells.
@@ -1497,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.
  *
@@ -1624,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. */
@@ -1959,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.
  *
@@ -2015,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
  *
@@ -2082,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).
@@ -2333,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
@@ -2581,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.
  */
 
@@ -2907,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[];
@@ -3050,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. */
@@ -3104,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.
      *
@@ -3151,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. */
@@ -3193,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> {
@@ -3226,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
@@ -3390,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.
@@ -3409,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`. */
@@ -3429,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.
@@ -3523,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.
@@ -3584,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";
@@ -3918,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;
@@ -5292,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>`). */
@@ -5308,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.
@@ -5372,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
@@ -5439,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;
@@ -5763,44 +5352,6 @@ 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;
@@ -5831,6 +5382,34 @@ interface SurfaceContribution extends Contribution {
  */
 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.
  *
@@ -5838,7 +5417,7 @@ declare function mergeContributions<T extends SurfaceContribution>(...bundles: r
  * 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
@@ -5859,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: {
@@ -6100,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
@@ -6144,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). */
@@ -6307,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
@@ -6358,53 +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 entries to register alongside the internal default select:
-     *  tools, and features written as a `SurfaceContribution` — whose views,
-     *  deps, overlay, bindings, actions and `attach` all install from this one
-     *  list, and uninstall when the entry leaves it. If you supply your own
-     *  `tools` prop, this is ignored — wire `ambient` through your own
-     *  `useTools` call instead. */
-    ambient?: readonly (AnyTool | SurfaceContribution)[];
-    /** 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;
@@ -6506,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
@@ -6524,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
@@ -6660,11 +6256,12 @@ declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: Sc
  * 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).
@@ -7917,8 +7514,7 @@ declare function PointerProviderIfRoot({ children }: {
     children: ReactNode;
 }): 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.Element;
@@ -8011,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`.
@@ -8683,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 {
@@ -8882,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
@@ -9127,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.
  *
@@ -9574,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
@@ -9781,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
@@ -9809,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`.
@@ -10069,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).
  *
- * 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).
+ * 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` 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
@@ -10468,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.
@@ -10493,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`.
  *
@@ -10505,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. */
@@ -10564,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;
@@ -10587,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): {
@@ -10642,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.
  *
@@ -10868,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?: {
@@ -11341,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
@@ -12334,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, 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, type ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, 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, 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, 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 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, 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, type SurfaceContribution, 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, ViewApi, 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, 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, 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, mergeContributions, meshBounds, meshGradientXml, minimapCenterAction, minimapPanAction, 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, 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 };