@weasel-js/core 1.5.2 → 1.6.1

package/dist/index.d.ts

@@ -1,44 +1,224 @@
-import * as React$1 from 'react';
-import React__default, { RefObject, ReactNode, Ref, MutableRefObject, MouseEvent, ComponentType } from 'react';
-import { a as UnitValue, b as UnitSystem, c as UnitEntry, d as Unit, U as UseMoveOptions, O as OriginProjection } from './grid-CuxXjaQV.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-CuxXjaQV.js';
-import { View, NodeId, Bounds, ModifierState, PointerSessionCancelReason, DeviceProfile, Action, SelectionMode, SelectionExtendKey, SelectionApi, DepSchema, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1, ViewportToolDef as ViewportToolDef$1, HitShape, HandleKind, DebugSink, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, IngestItem, OngoingOverlay, ActionsProp, OverlayRole, ResizeAnchor, Point2 } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionPresentation, ActionsProp, ActionsRegistry, AffordanceHit, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DebugSink, DepName, DepSchema, DetectedDeviceFacts, DeviceProfile, Dispatcher, DispatcherContext, DragSample, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, MatchResult, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OverlayPosition, OverlayRole, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, ToolCtx, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, UiOngoingControl, Point2 as Vec2, View, actionBindings, buildRuleCtx, clientToCanvas, createDispatcher, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, mergeContributions, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
-import { FillStyle, Stroke, TextureHandle, GradientUnits, ColorSpace, TilePatternSpec, GradientKind, GradStop, GradientFill, MarkerKey, MarkerRef } from '@weasel-js/paint';
-export { ColorSpace, FillStyle, GradStop, GradientFill, GradientKind, GradientUnits, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Region, STROKE_DASH_RATIOS, ScreenLength, Stroke, StrokeAlign, StrokeDashStyle, TextureHandle, TilePatternSpec, alignedStrokeRect, dashForStrokeStyle, hexToOklchDeg, lerpColorArray, lerpOklab, lerpOklch, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, resolveScreenLength, srgbFloatToOklab, srgbU8ToOklab, strokeDashStyleOf } from '@weasel-js/paint';
-import { D as DrawCommand, E as Effect, w as Scene, x as RectPose, y as InertiaConfig, V as ViewAnimationOptions, N as Node$1, z as PoseComposition, A as SliceDep, B as VertexColorChannel, f as ShaderProgramHandle, F as InsertExtras, H as SerializedScene, J as GeometryProjection, K as ContentHandlerEntry, L as SvgIngestOptions, O as PanBounds, Q as Animator, U as ColorOverrideRegistry, X as UseSceneOptions, Y as SceneRegistry, Z as RegisteredOp, _ as PoseOverrides, $ as DerivedDep, a0 as ViewportDims, P as PathDrawCommand, T as TextDrawCommand, a1 as ShaderProgram, G as GlMat3, a2 as BooleansAdapter, a3 as UseAnimatorOptions, a4 as SpringPresetName, a5 as EasingSpec, a6 as AnimationHandle, a7 as SampledTrack } from './depSchema-FKQBEfg7.js';
-export { a8 as AddLayerSpec, a9 as AddNodeSpec, aa as AnimateToBoundsOptions, ab as AreaSelectDep, ac as BezierEasing, ad as BooleanOp, ae as BooleanOpResult, af as ClipboardDep, ag as ClipboardIngestCtx, ah as ColorOverride, ai as ColorOverrideFn, aj as ContainerNode, C as CullRect, ak as DecayLoopConfig, al as DecayOptions, am as EASINGS, an as EasingFn, ao as EasingName, ap as EditAnchorsDep, aq as EventBooking, ar as EventBookingHandle, as as EventTrack, at as FitViewToBoundsOptions, a as GroupDrawCommand, au as IDENTITY_POSE_COMPOSITION, b as ImageDrawCommand, c as ImageMinification, av as IngestCtx, aw as IngestionDep, ax as InsertDep, ay as Interpolate, az as InterpolatorFactory, aA as Keyframe, aB as LassoSelectDep, aC as LayerRecord, aD as LayoutDep, aE as LeafNode, aF as LoopFactory, aG as LoopOptions, aH as NestedTimeline, aI as NodeAtPointDep, aJ as PhysicsHandle, aK as PhysicsOptions, aL as PoseAdapter, aM as PoseClosure, aN as PoseOverride, aO as RECT_POSE_COMPOSITION, aP as RIGID_POSE_COMPOSITION, R as RenderTarget, aQ as ResizePolicy, aR as SPRING_PRESETS, S as SPRITE_STRIDE, aS as SerializedNode, e as ShaderDrawCommand, g as ShaderUniform, aT as SnapDep, aU as SpringOptions, aV as SpringPreset, i as SpriteSheet, j as SpritesDrawCommand, aW as StaggerBuilder, aX as StaggerDelay, aY as StaggerFactory, aZ as StaggerOptions, a_ as StaggerPerItem, a$ as StaggerSpringPoseOptions, b0 as StaggerTweenOptions, b1 as SvgUnpacker, b2 as SystemLayerRecord, b3 as SystemLayerSpec, b4 as TextEditDep, b5 as TimelineClock, b6 as TimelineEvent, b7 as TimelineHandle, b8 as TimelineOptions, b9 as TimelineTrack, ba as Track, bb as TweenLoopOptions, bc as TweenOptions, bd as UserLayerRecord, be as VIEW_ANIMATION_KEY, bf as ViewAnimationApi, bg as ViewApi, bh as ViewChannel, bi as applyBooleanOp, bj as asNodeId, m as blur, bk as composeRectPose, bl as composeRigidPose, bm as composeWorldPose, bn as cubicBezierEasing, o as cullDrawCommands, bo as decomposeRectPose, bp as decomposeRigidPose, bq as easeIn, br as easeInBack, bs as easeInBounce, bt as easeInCirc, bu as easeInCubic, bv as easeInElastic, bw as easeInExpo, bx as easeInOut, by as easeInOutBack, bz as easeInOutBounce, bA as easeInOutCirc, bB as easeInOutCubic, bC as easeInOutElastic, bD as easeInOutExpo, bE as easeInOutQuad, bF as easeInOutQuart, bG as easeInOutQuint, bH as easeInOutSine, bI as easeInQuad, bJ as easeInQuart, bK as easeInQuint, bL as easeInSine, bM as easeOut, bN as easeOutBack, bO as easeOutBounce, bP as easeOutCirc, bQ as easeOutCubic, bR as easeOutElastic, bS as easeOutExpo, bT as easeOutQuad, bU as easeOutQuart, bV as easeOutQuint, bW as easeOutSine, bX as fitViewToBounds, p as frameRect, bY as linear, q as mat3, bZ as rebaseLocalPose, b_ as registerContentHandler, r as registerEffect, b$ as resolveEasing, c0 as resolveStrokeWidth, c1 as translateRectPose, c2 as useDecayLoop, c3 as useViewAnimation, c4 as useViewAnimationOn, v as viewToMat3, u as vignette, c5 as worldPoseLookup } from './depSchema-FKQBEfg7.js';
+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';
+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, TargetSpec, WheelSpec } from '@weasel-js/gestures';
-import { S as SimulationNode, U as UseSimulationOptions, a as Simulation, P as PathBuilder } from './math-CeGmGPy8.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-CeGmGPy8.js';
+export { ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetSpec, WheelSpec } from '@weasel-js/gestures';
+import { S as SimulationNode, U as UseSimulationOptions, a as Simulation, P as PathBuilder } from './math-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, UseGestureDispatcherOptions, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, R as RotateBehavior, S as SnapStrategy, M as MoveBehavior, I as InsertBehavior } from './types-BHGdrOcu.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-BHGdrOcu.js';
-import { P as PoseDescriptor, c as PolygonPath, a as Path, d as RotatedPose, e as RectPath } from './poseDescriptor-PgfVKfa0.js';
-export { f as PathFillRule, R as RECT_POSE_DESCRIPTOR, b as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-PgfVKfa0.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-CgcK2R_I.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-CgcK2R_I.js';
-import { M as MoveAdapter, A as AreaSelectAdapter, b as LassoHitMode, c as LassoSelectAdapter, R as ResizeAdapter, d as RotateAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, a as SceneAdapter, f as LayoutSnap } from './types-BdaK9PcP.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-BdaK9PcP.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+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 { 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 { a as PolygonPath, P as Path, R as RectPath } from './path-JEV2c5If.js';
+export { b as PathFillRule } from './path-JEV2c5If.js';
 import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
 import { PlacementAlign, Rect, Mat3 } from '@weasel-js/geom';
 export { 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, SCRIPT_METRICS, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextPaint, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextVerticalAlign, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, layoutTextPose, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, textPoseLayoutInput, toRuns, verticalAlignOffset } from '@weasel-js/text';
+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 { G as Guide } from './types-D2tTKEU0.js';
-export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-Dr6CwNZK.js';
-export { U as UseInsertOptions } from './options-BPcmwYk7.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';
 
+/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
+interface ViewTransform {
+    panX: number;
+    panY: number;
+    zoom: {
+        x: number;
+        y: number;
+    };
+}
+/** Project a world-space point to screen-space pixels through a `ViewTransform`. */
+declare function worldToScreen(worldX: number, worldY: number, view: ViewTransform): [number, number];
+/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */
+declare function screenToWorld(screenX: number, screenY: number, view: ViewTransform): [number, number];
+
+/**
+ * Input convenience for zoom primitives. A `number` is treated as a
+ * uniform factor applied to both axes; a `{x, y}` vector applies
+ * per-axis factors.
+ */
+type ZoomFactor = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Input convenience for zoom-clamp ranges. A `number` is applied as the
+ * same bound on both axes; a `{x, y}` vector applies per-axis bounds.
+ */
+type ZoomBound = number | {
+    x: number;
+    y: number;
+};
+/**
+ * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep
+ * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`
+ * use opposite sign conventions for the translation half (`view.x` is
+ * camera position; `panX` is canvas translation), so the adapter flips
+ * the sign and multiplies by per-axis scale.
+ */
+declare function viewToTransform(view: View): ViewTransform;
+/**
+ * How far `view` is zoomed in, as one number — the geometric mean of its two
+ * axes, so a uniform view reports its own scale and a stretched one reports
+ * the scale that covers the same area.
+ *
+ * What a `RuleCtx` carries, because the only rule that asks about the
+ * viewport asks for a threshold rather than a camera.
+ */
+declare function viewZoom(view: View): number;
+/**
+ * `view` inside the invariant {@link View} documents: a zero or non-finite
+ * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a
+ * non-finite translation becomes 0. Returns `view` itself when it already
+ * holds, so a valid view keeps its identity.
+ */
+declare function normalizeView(view: View): View;
+
+/**
+ * `DebugSink`, `HitShape` and `HandleKind` are declared in
+ * `@weasel-js/routing` — `ToolCtx.debug` carries a sink, so routing has to
+ * name the type. Re-exported here, beside the overlay that reads one.
+ */
+
+/** One bit per debug feature; absent keys are off. */
+interface DebugConfig {
+    hitboxes?: boolean;
+    handles?: boolean;
+    bounds?: boolean;
+    origins?: boolean;
+    snap?: boolean;
+    layers?: boolean;
+    /** Render each tracked node's id as a label at the top-left of its
+     *  bounds. Pulls from the same `recordBounds` stream `bounds` uses, so
+     *  no extra sink calls are required to enable. */
+    ids?: boolean;
+    /** Rolling FPS counter rendered in the top-left corner of the canvas.
+     *  Tracks the rate at which the debug overlay's draw callback runs;
+     *  this matches the canvas's effective repaint rate. */
+    fps?: boolean;
+    /** Optional per-feature color overrides; falls back to the default theme. */
+    theme?: Partial<DebugTheme>;
+    /** Optional per-feature line-width / dash overrides; falls back to
+     *  {@link DEFAULT_DEBUG_STROKES}. */
+    strokes?: Partial<DebugStrokes>;
+}
+/** The name of one debug-overlay feature — the keys of {@link DebugConfig}
+ *  that toggle a visualization. */
+type DebugFeature = 'hitboxes' | 'handles' | 'bounds' | 'origins' | 'snap' | 'layers' | 'ids' | 'fps';
+/** Colors the debug overlay draws with, one entry per feature. */
+interface DebugTheme {
+    hitboxFill: string;
+    hitboxStroke: string;
+    handle: string;
+    bounds: string;
+    origin: string;
+    snap: string;
+    layerText: string;
+    layerTextBg: string;
+    /** Color for the per-node id label rendered when `config.ids` is on. */
+    idText: string;
+    /** Foreground / background for the FPS panel. */
+    fpsText: string;
+    fpsTextBg: string;
+}
+/** Line width and dash pattern for one stroked debug feature. An empty (or
+ *  omitted) `dash` is a solid line. */
+interface DebugStroke {
+    width: number;
+    dash?: readonly number[];
+}
+/** The stroked half of the debug overlay's appearance, split from
+ *  {@link DebugTheme} because only some features draw a line at all — text
+ *  panels and filled origin dots take color and nothing else. */
+interface DebugStrokes {
+    hitbox: DebugStroke;
+    bounds: DebugStroke;
+    handle: DebugStroke;
+    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
+    snap: DebugStroke;
+}
+/** A hit region tested during the current frame. */
+interface RecordedHitbox {
+    id: string;
+    kind: 'body' | 'handle' | 'rotation' | 'anchor';
+    shape: HitShape;
+}
+/** A handle drawn during the current frame, and where. */
+interface RecordedHandle {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    kind: HandleKind;
+}
+/** A node's bounds as computed during the current frame. */
+interface RecordedBounds {
+    id: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** A node's transform origin as used during the current frame. */
+interface RecordedOrigin {
+    id: string;
+    point: {
+        x: number;
+        y: number;
+    };
+}
+/** A snap candidate considered during the current gesture, and whether it
+ *  won. Unlike the other records these survive across frames, until the
+ *  gesture ends. */
+interface RecordedSnap {
+    point: {
+        x: number;
+        y: number;
+    };
+    accepted: boolean;
+}
+/** A render layer that drew during the current frame. */
+interface RecordedLayer {
+    id: string;
+    label: string;
+    space: 'world' | 'screen';
+    index: number;
+}
+/** Everything the sink collected, ready for the overlay to draw. */
+interface DebugSnapshot {
+    hitboxes: RecordedHitbox[];
+    handles: RecordedHandle[];
+    bounds: RecordedBounds[];
+    origins: RecordedOrigin[];
+    snap: RecordedSnap[];
+    layers: RecordedLayer[];
+}
+
 /**
  * The kit version a build was compiled from, so an app can report what it is
  * running. Substituted at build time — by `tsup.config.ts` for the published
@@ -62,20 +242,6 @@ declare const VERSION: string;
 /** Round `value` to the nearest multiple of `cellSize`. Returns 0 when the result would be -0. */
 declare function roundToCell(value: number, cellSize: number): number;
 
-/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
-interface ViewTransform {
-    panX: number;
-    panY: number;
-    zoom: {
-        x: number;
-        y: number;
-    };
-}
-/** Project a world-space point to screen-space pixels through a `ViewTransform`. */
-declare function worldToScreen(worldX: number, worldY: number, view: ViewTransform): [number, number];
-/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */
-declare function screenToWorld(screenX: number, screenY: number, view: ViewTransform): [number, number];
-
 /**
  * Pointer-tracking glue that turns hover position into a grid cell, suitable
  * for dropping straight into `createCellHighlightLayer({ getCell })`. Pairs
@@ -134,48 +300,6 @@ interface UseGridCellHoverReturn {
 /** Track which grid cell the pointer is over; pairs with `createCellHighlightLayer`. */
 declare function useGridCellHover(opts: UseGridCellHoverOptions): UseGridCellHoverReturn;
 
-/**
- * Input convenience for zoom primitives. A `number` is treated as a
- * uniform factor applied to both axes; a `{x, y}` vector applies
- * per-axis factors.
- */
-type ZoomFactor = number | {
-    x: number;
-    y: number;
-};
-/**
- * Input convenience for zoom-clamp ranges. A `number` is applied as the
- * same bound on both axes; a `{x, y}` vector applies per-axis bounds.
- */
-type ZoomBound = number | {
-    x: number;
-    y: number;
-};
-/**
- * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep
- * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`
- * use opposite sign conventions for the translation half (`view.x` is
- * camera position; `panX` is canvas translation), so the adapter flips
- * the sign and multiplies by per-axis scale.
- */
-declare function viewToTransform(view: View): ViewTransform;
-/**
- * How far `view` is zoomed in, as one number — the geometric mean of its two
- * axes, so a uniform view reports its own scale and a stretched one reports
- * the scale that covers the same area.
- *
- * What a `RuleCtx` carries, because the only rule that asks about the
- * viewport asks for a threshold rather than a camera.
- */
-declare function viewZoom(view: View): number;
-/**
- * `view` inside the invariant {@link View} documents: a zero or non-finite
- * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a
- * non-finite translation becomes 0. Returns `view` itself when it already
- * holds, so a valid view keeps its identity.
- */
-declare function normalizeView(view: View): View;
-
 interface ChromeState {
     /** Currently selected ids. Live; reflects useSelection's React state. */
     readonly selection: readonly NodeId[];
@@ -1608,7 +1732,7 @@ interface DeviceProfileProviderProps {
  * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so
  * overlays, affordances, and consumer chrome all read the same object.
  */
-declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): React$1.FunctionComponentElement<React$1.ProviderProps<DeviceProfile | null>>;
+declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): react.FunctionComponentElement<react.ProviderProps<DeviceProfile | null>>;
 
 /**
  * Compute the largest uniform zoom (px per content-unit) that fits a content
@@ -1820,8 +1944,11 @@ declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
  * Every keyboard shortcut an action answers to, in declaration order.
  * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
  * identical are emitted once; an action bound only to those returns empty.
+ *
+ * With `params` — an `ActionItem`'s — only the bindings that pass those same
+ * values count, so each variant of `flip` gets its own key.
  */
-declare function actionShortcuts(action: Action): readonly ActionShortcut[];
+declare function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
 
 /**
  * `moveAction` — first `ongoing`-timing Action descriptor.
@@ -2263,17 +2390,23 @@ declare const viewportDragPanAction: Action & {
  *   Browsers synthesize a trackpad pinch as ctrl+wheel. On a Mac that is a
  *   *different* event from the `mod` binding above (`mod` is metaKey there), so
  *   pinch needs its own binding or nothing claims it and the page zooms instead.
+ * - `{ kind: 'pinch' }` → Safari trackpad pinch (WebKit `gesturechange`),
+ *   params: `{ kind: 'pinch' }`. Safari may send the same pinch as ctrl+wheel
+ *   as well; the dispatcher swallows that copy while a claimed gesture is live,
+ *   so only one of the two bindings fires per pinch.
  * - `{ kind: 'key', key: '=' }` → zoom in, params: `{ kind: 'in' }`
  * - `{ kind: 'key', key: '-' }` → zoom out, params: `{ kind: 'out' }`
  * - `{ kind: 'key', key: '0' }` → reset zoom, params: `{ kind: 'reset' }`
  *
  * ## Design notes
  * The invoker switches on `params.kind`:
- * - `'wheel'`: defers to `wheelZoom` (`core/viewport/wheelHandler`), the kit's
- *   one statement of the wheel convention, anchored at (clientX, clientY).
- *   The dispatcher merges wheel event data into params at dispatch time, and
- *   converts the wheel event's client coords to canvas-local (subtracting the
- *   canvas's bounding rect) before merging — `zoomAt` expects canvas-local.
+ * - `'wheel'` and `'pinch'`: both reduce to a scale factor about a focal
+ *   point and share one `zoomAt` call. A wheel sample's factor is
+ *   `wheelZoomFactor(deltaY)`, the kit's one statement of the wheel
+ *   convention; a pinch sample carries its factor as `scale`. The dispatcher
+ *   merges event data into params and converts client coords to canvas-local
+ *   (subtracting the canvas's bounding rect) before merging — `zoomAt`
+ *   expects canvas-local.
  * - `'in'`/`'out'`: step zoom by ×1.25 / ×0.8, anchored at the host center
  *   when the `view` dep wires `hostSize()` (SceneCanvas does), falling back
  *   to the canvas top-left origin for consumers that don't.
@@ -2283,7 +2416,7 @@ declare const viewportDragPanAction: Action & {
  * The three discrete branches glide instead of jumping when the `animate`
  * option is configured and the `view` dep implements `animate` — they hand the
  * action a target and nothing in between, which is the whole condition for
- * tweening. `'wheel'` always jumps per sample.
+ * tweening. `'wheel'` and `'pinch'` always jump per sample.
  *
  * ## Key binding modifier notes
  * The key bindings (`=`, `-`, `0`) require `mod: true` (Cmd on Mac, Ctrl elsewhere).
@@ -2576,6 +2709,16 @@ declare const clipboardCopyAction: Action & {
 declare const clipboardCutAction: Action & {
     requires: string[];
 };
+/**
+ * @experimental
+ * Static descriptor for the `clipboard.paste` Action — what a Paste button or
+ * menu item triggers. It has no key binding: Cmd/Ctrl+V already arrives as a
+ * DOM `paste` event, which the dispatcher routes to `ingest`, and a binding
+ * here would fire alongside it and paste twice.
+ */
+declare const clipboardPasteAction: Action & {
+    requires: string[];
+};
 
 /**
  * `enterTextEditAction` — immediate Action descriptor for entering in-place
@@ -2739,8 +2882,12 @@ declare function useStandardActions(opts: UseStandardActionsOptions): void;
 /** Build the adapter the default actions commit through when the consumer
  *  supplies no `applyOps` hook of its own — it applies ops straight to the
  *  scene. Path and text ops are not covered; those surfaces belong to their
- *  own owners. */
-declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose>): {
+ *  own owners.
+ *
+ *  Pass `selection` (a `SelectionApi`'s `adapterMethods`) and selection reads
+ *  and writes go through it rather than the scene, so a canvas that gates its
+ *  selection — `selectionMode="none"` — gates what these batches select too. */
+declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose>, selection?: SelectionApi['adapterMethods']): {
     getNode: (id: string) => Node$1<unknown, string, TPose> | undefined;
     getNodes: () => Node$1<unknown, string, TPose>[];
     getPose: (id: string) => TPose;
@@ -3191,129 +3338,6 @@ interface ToolPrefGroup {
     children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
 }
 
-/**
- * `DebugSink`, `HitShape` and `HandleKind` are declared in
- * `@weasel-js/routing` — `ToolCtx.debug` carries a sink, so routing has to
- * name the type. Re-exported here, beside the overlay that reads one.
- */
-
-/** One bit per debug feature; absent keys are off. */
-interface DebugConfig {
-    hitboxes?: boolean;
-    handles?: boolean;
-    bounds?: boolean;
-    origins?: boolean;
-    snap?: boolean;
-    layers?: boolean;
-    /** Render each tracked node's id as a label at the top-left of its
-     *  bounds. Pulls from the same `recordBounds` stream `bounds` uses, so
-     *  no extra sink calls are required to enable. */
-    ids?: boolean;
-    /** Rolling FPS counter rendered in the top-left corner of the canvas.
-     *  Tracks the rate at which the debug overlay's draw callback runs;
-     *  this matches the canvas's effective repaint rate. */
-    fps?: boolean;
-    /** Optional per-feature color overrides; falls back to the default theme. */
-    theme?: Partial<DebugTheme>;
-    /** Optional per-feature line-width / dash overrides; falls back to
-     *  {@link DEFAULT_DEBUG_STROKES}. */
-    strokes?: Partial<DebugStrokes>;
-}
-/** The name of one debug-overlay feature — the keys of {@link DebugConfig}
- *  that toggle a visualization. */
-type DebugFeature = 'hitboxes' | 'handles' | 'bounds' | 'origins' | 'snap' | 'layers' | 'ids' | 'fps';
-/** Colors the debug overlay draws with, one entry per feature. */
-interface DebugTheme {
-    hitboxFill: string;
-    hitboxStroke: string;
-    handle: string;
-    bounds: string;
-    origin: string;
-    snap: string;
-    layerText: string;
-    layerTextBg: string;
-    /** Color for the per-node id label rendered when `config.ids` is on. */
-    idText: string;
-    /** Foreground / background for the FPS panel. */
-    fpsText: string;
-    fpsTextBg: string;
-}
-/** Line width and dash pattern for one stroked debug feature. An empty (or
- *  omitted) `dash` is a solid line. */
-interface DebugStroke {
-    width: number;
-    dash?: readonly number[];
-}
-/** The stroked half of the debug overlay's appearance, split from
- *  {@link DebugTheme} because only some features draw a line at all — text
- *  panels and filled origin dots take color and nothing else. */
-interface DebugStrokes {
-    hitbox: DebugStroke;
-    bounds: DebugStroke;
-    handle: DebugStroke;
-    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
-    snap: DebugStroke;
-}
-/** A hit region tested during the current frame. */
-interface RecordedHitbox {
-    id: string;
-    kind: 'body' | 'handle' | 'rotation' | 'anchor';
-    shape: HitShape;
-}
-/** A handle drawn during the current frame, and where. */
-interface RecordedHandle {
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    kind: HandleKind;
-}
-/** A node's bounds as computed during the current frame. */
-interface RecordedBounds {
-    id: string;
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-/** A node's transform origin as used during the current frame. */
-interface RecordedOrigin {
-    id: string;
-    point: {
-        x: number;
-        y: number;
-    };
-}
-/** A snap candidate considered during the current gesture, and whether it
- *  won. Unlike the other records these survive across frames, until the
- *  gesture ends. */
-interface RecordedSnap {
-    point: {
-        x: number;
-        y: number;
-    };
-    accepted: boolean;
-}
-/** A render layer that drew during the current frame. */
-interface RecordedLayer {
-    id: string;
-    label: string;
-    space: 'world' | 'screen';
-    index: number;
-}
-/** Everything the sink collected, ready for the overlay to draw. */
-interface DebugSnapshot {
-    hitboxes: RecordedHitbox[];
-    handles: RecordedHandle[];
-    bounds: RecordedBounds[];
-    origins: RecordedOrigin[];
-    snap: RecordedSnap[];
-    layers: RecordedLayer[];
-}
-
 /** Options for `useSelectTool`: how a point resolves to nodes, how a click
  *  chooses among them, and the appearance of the marquee. */
 interface UseSelectToolOptions<TPose> {
@@ -3565,6 +3589,18 @@ declare namespace useTextTool {
                 description: string;
                 default: undefined;
             };
+            textTransform: {
+                kind: "enum";
+                name: string;
+                description: string;
+                control: "toggle";
+                default: string;
+                options: {
+                    value: string;
+                    label: string;
+                    short: string;
+                }[];
+            };
             fontFamily: {
                 kind: string;
                 name: string;
@@ -3625,10 +3661,9 @@ declare namespace useTextTool {
 }
 
 /**
- * In-progress pen anchor. `outHandle` is set when the anchor was placed via
- * click-drag (smooth anchor); undefined for click-placed corners.
- * `inHandle` is mirrored from the previous anchor's outHandle on segment
- * emission unless `altBroken` is set on that previous anchor.
+ * In-progress pen anchor. A click places a corner, with no handles. A drag
+ * sets `outHandle` to the drag point and `inHandle` to its mirror through
+ * the anchor, which shapes the segment coming into it.
  */
 interface PenAnchor$1 {
     x: number;
@@ -3641,8 +3676,9 @@ interface PenAnchor$1 {
         x: number;
         y: number;
     };
-    /** True when Alt was held during the outgoing-handle drag — the next
-     *  anchor's incoming handle is NOT mirrored from this one. */
+    /** True once Alt is held during the placement drag: from then on the
+     *  in-handle stays where it is, and an anchor dragged with Alt down from
+     *  the start gets none. */
     altBroken?: boolean;
 }
 /** One in-progress subpath of the pen tool: its anchors so far, and whether
@@ -3712,6 +3748,13 @@ interface UsePenToolOptions<TPose> {
     adapter: {
         addNode: (pose: TPose) => string;
         setSelection: (ids: string[]) => void;
+        /** Build, without inserting, the node `addNode` would insert for `pose`,
+         *  so the pen can put it in a larger op batch — a new path finished on
+         *  another open path's endpoint is inserted and the other path deleted
+         *  in one undo step. Without it, that click only places an anchor. */
+        makeNode?: (pose: TPose) => {
+            id: string;
+        };
     };
     /** Auto-select the new object after commit. Default `true`. */
     autoSelect?: boolean;
@@ -4754,6 +4797,13 @@ interface CanvasSurfaceHelpers {
  *  are split so a per-view set can be built independently of the surface's,
  *  not to make layers ask for one. */
 interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {
+    /**
+     * The view this draw is for: a `<CanvasView>` id, or `null` for the
+     * surface's own camera. One layer array paints every view, so a layer that
+     * belongs in some views and not others — a minimap's indicator — declines
+     * the rest by this id.
+     */
+    readonly viewId: string | null;
 }
 
 /**
@@ -4803,6 +4853,11 @@ interface NodePaintCtx {
      *  paints the deterministic grey placeholder outline (never the ambient
      *  load-status error variant). */
     resolveImage?: (node: Node$1<unknown, string, unknown>) => ImageBitmap | undefined;
+    /** Device pixels per world unit where this paint will land — the view's
+     *  scale times the device-pixel ratio. `defaultDrawOne` fills it from its
+     *  view when absent. Lets a painter size resolution-dependent work, such as
+     *  re-rasterizing an SVG image; one that has no such work ignores it. */
+    pixelScale?: number;
     /** The node's derived path, resolved by the scene-aware `drawOne` wrapper
      *  before painting: `paint` has no scene handle, and deriving needs the
      *  dependencies' poses. **Absent** for a node that derives from nothing —
@@ -5256,13 +5311,21 @@ type LayersMap<TNode extends {
     [customKey: string]: LayerSlotValue<TNode, TPose> | undefined;
 };
 /**
- * High-level selection semantics. Kept as a public type for `<SceneCanvas>`
- * consumers — Canvas itself no longer accepts a `selectionMode` prop.
+ * What `<SceneCanvas selectionMode>` lets the canvas do to the selection.
+ *
+ *   - `'single'` (default) — a click replaces the selection with the clicked
+ *     node, modifiers or not. It sets click policy, not a limit: a marquee,
+ *     lasso, select-all or paste can still select several nodes.
+ *   - `'multi'` — a click with the extend key (shift by default) toggles the
+ *     node in or out of the selection.
+ *   - `'none'` — nothing the canvas does writes the selection: no click,
+ *     marquee, lasso, action or tool, and no op committed through the adapter
+ *     it hands its tools. The consumer's own `SelectionApi` — the `selection`
+ *     prop, or `useSelection({ scene })` — still writes, and the canvas draws
+ *     what it holds. Undo and redo still restore the selection each history
+ *     entry recorded.
  *
- *   - `'single'` (default) — click replaces the selection with one id.
- *   - `'multi'` — shift-click extends/toggles. Multi-selected objects draw a
- *     union AABB with corner handles.
- *   - `'none'` — canvas interactions never update selection state.
+ * Several selected nodes draw one union box with corner handles in every mode.
  */
 type CanvasSelectionMode = 'single' | 'multi' | 'none';
 /**
@@ -5392,14 +5455,14 @@ interface CanvasProps<TNode extends {
      */
     inputElement?: HTMLElement | null;
     className?: string;
-    style?: React__default.CSSProperties;
+    style?: react__default.CSSProperties;
     tabIndex?: number;
     /** Fired when the canvas element gains focus. The canvas is focusable by
      *  default (`tabIndex` 0), so consumers driving focus-dependent chrome —
      *  a focus ring, a "keyboard shortcuts active" hint — need to observe it. */
-    onFocus?: React__default.FocusEventHandler<HTMLCanvasElement>;
+    onFocus?: react__default.FocusEventHandler<HTMLCanvasElement>;
     /** Fired when the canvas element loses focus. */
-    onBlur?: React__default.FocusEventHandler<HTMLCanvasElement>;
+    onBlur?: react__default.FocusEventHandler<HTMLCanvasElement>;
     /**
      * When `true` (default), the canvas element receives focus on `pointerdown`
      * so keyboard events (tool hotkeys, undo/redo) are captured without a
@@ -5449,7 +5512,7 @@ interface CanvasProps<TNode extends {
      * Useful for custom layers that render scene content outside of the standard
      * slot system and need to stay in sync with gesture previews.
      */
-    helpersRef?: React__default.MutableRefObject<CanvasHelpers<TPose> | null>;
+    helpersRef?: react__default.MutableRefObject<CanvasHelpers<TPose> | null>;
     /**
      * Debug overlay configuration.
      *  - `undefined` (default): read `?debug=…` from the URL.
@@ -5463,7 +5526,7 @@ interface CanvasProps<TNode extends {
     debug?: DebugConfig | false;
     /** Test-only escape hatch: writes the live debug sink to this ref so tests
      *  can call `snapshot()` after a render. No effect when debug is off. */
-    debugSinkRef?: React__default.MutableRefObject<(DebugSink & {
+    debugSinkRef?: react__default.MutableRefObject<(DebugSink & {
         snapshot(): DebugSnapshot;
     }) | null>;
     /**
@@ -5623,6 +5686,9 @@ type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node$
     /** The node's pose with every ancestor's frame folded in. Equal to
      *  `getPose` unless a `poseComposition` is configured. */
     getWorldPose(id: string): TPose;
+    /** Whether `id`'s pose is a frame its children are expressed in — see
+     *  `definesFrame`. */
+    definesFrame(id: string): boolean;
     /** Present only when a composing strategy is configured; the render
      *  walk feature-detects it. */
     composePose?(parent: TPose, child: TPose): TPose;
@@ -5692,14 +5758,8 @@ interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
  *  undoable. */
 declare function sceneToAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
 /**
- * React-hook wrapper around `sceneToAdapter`. Memoizes on `scene`,
- * `options.selection`, `options.commitInsert`, `options.insertLayer`, and
- * `options.layouts` so the adapter identity is stable across renders unless
- * one of those changes.
- *
- * Saves the per-demo `useMemo(() => sceneToAdapter(scene, { selection }),
- * [scene, selection])` boilerplate every consumer that wires custom tools
- * would otherwise repeat.
+ * React-hook wrapper around `sceneToAdapter`. Memoizes on every option, so
+ * the adapter keeps its identity across renders unless one of them changes.
  */
 declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
 
@@ -5741,6 +5801,36 @@ interface UseRotateOptions<TPose> {
     pivot?: 'each' | 'union';
 }
 
+/** Reads the surface's deps from inside `SurfaceContribution.attach`. */
+interface ContributionDepReader {
+    get<K extends DepName>(name: K): DepSchema[K] | undefined;
+}
+/**
+ * A feature a surface installs in one step. Every role is optional: `bindings`,
+ * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus
+ * the two below. Installing it installs every role it declares, and removing
+ * it removes them.
+ */
+interface SurfaceContribution extends Contribution {
+    /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */
+    views?: readonly CanvasViewProps[];
+    /**
+     * Runs once the surface mounts; returns its teardown. For what the roles
+     * above cannot say — a registered (hit-testable) layer, a subscription.
+     *
+     * Keyed by the function's identity, so a contribution built once (in a
+     * `useMemo`, or at module scope) attaches once however often the host
+     * re-renders.
+     */
+    attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;
+}
+/**
+ * Concatenate contribution bundles into one registry, preserving order. Throws
+ * on a duplicate entry id, dep name or view id — two features answering for
+ * the same name is a bug in whichever was added second.
+ */
+declare function mergeContributions<T extends SurfaceContribution>(...bundles: readonly (readonly T[])[]): T[];
+
 /**
  * The kit's built-in shape kinds — one table, every other spelling derived.
  *
@@ -5813,6 +5903,8 @@ declare const SHAPE_KINDS: {
         readonly insertPreview: true;
     };
 };
+/** Every kind in the table, tool or not. */
+type ShapeKind = keyof typeof SHAPE_KINDS;
 /** The keys of a shape-kind table whose descriptor sets `F` to `true`. */
 type ShapeKindsWhere<T, F extends keyof ShapeKindDescriptor> = {
     [K in keyof T]: T[K] extends Record<F, true> ? K : never;
@@ -5997,7 +6089,7 @@ declare function rotateAroundAABBCenter(x: number, y: number, width: number, hei
 /** Paint one node the way the kit does by default: dispatch to the first
  *  registered node-shape painter that matches, then draw its `data.label` on
  *  top when it has one. Consumers replace or wrap this via `drawOne`. */
-declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$1<TData, TLayer, TPose>, pose: TPose, _view?: View, ctx?: NodePaintCtx): DrawCommand[];
+declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$1<TData, TLayer, TPose>, pose: TPose, view?: View, ctx?: NodePaintCtx): DrawCommand[];
 
 /** Default size in CSS pixels for selection corner-handles AND their
  *  hit-test radius, at `targetScale = 1`. Used by the SceneCanvas defaults;
@@ -6060,6 +6152,11 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      *  to `sceneToAdapter` so `useMove`'s layout pass runs on configured
      *  containers (reflow on enter, reparent + reflow on commit). */
     layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];
+    /** Which layout container a drag lands in when several contain the drop
+     *  point — the innermost (default), the topmost in paint order, or only
+     *  containers whose strategy declares a `dropRegion`. Decides both the
+     *  drag-time reflow preview and the commit. */
+    layoutDropTarget?: LayoutDropTargetMode;
     /** How a child's stored pose folds into its parent's frame. Omit for the
      *  absolute-pose model, where a container groups its children but imposes
      *  no transform. Pass `RIGID_POSE_COMPOSITION` to make a container's pose
@@ -6206,12 +6303,8 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
     selection?: SelectionApi;
     selectionOptions?: UseSelectionOptions;
     /**
-     * High-level selection semantics. Controls whether canvas interactions
-     * mutate selection and whether multi-select chrome (union AABB) activates.
-     *   - `'single'` (default) — click selects one id.
-     *   - `'multi'` — shift-click extends/toggles.
-     *   - `'none'` — canvas interactions never update selection.
-     * See {@link CanvasSelectionMode}.
+     * What the canvas may do to the selection. See {@link CanvasSelectionMode}.
+     * Default `'single'`.
      */
     selectionMode?: CanvasSelectionMode;
     /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.
@@ -6290,11 +6383,13 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      *  lasso demo starts with `initialActiveTool="lasso"`. Ignored when the
      *  consumer supplies their own `tools` prop. */
     initialActiveTool?: string;
-    /** Always-on tools to register alongside the internal default select.
-     *  Use this for wheel/keyboard zoom + pan tools that should run alongside
-     *  the default select. If you supply your own `tools` prop, this is
-     *  ignored — wire `ambient` through your own `useTools` call instead. */
-    ambient?: AnyTool[];
+    /** 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.
      *
      *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or
@@ -6560,7 +6655,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      */
     onDoubleClick?: (hit: SceneCanvasHit | null) => void;
 };
-declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose>, ref: React__default.ForwardedRef<SceneCanvasApi>): react_jsx_runtime.JSX.Element;
+declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose>, ref: react__default.ForwardedRef<SceneCanvasApi>): react__default.JSX.Element;
 /**
  * The canvas component: renders a `Scene` and wires the interaction stack
  * around it.
@@ -6575,7 +6670,7 @@ declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: Sc
  * fit a prop (view control, hit queries, redraw requests).
  */
 declare const SceneCanvas: <TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose> & {
-    ref?: React__default.Ref<SceneCanvasApi>;
+    ref?: react__default.Ref<SceneCanvasApi>;
 }) => ReturnType<typeof SceneCanvasInner>;
 
 /** Which of the host's edges the panel is held against, per axis. */
@@ -6673,7 +6768,7 @@ interface CursorCoordsHudProps {
 }
 /** Debug overlay showing the pointer's client and world coordinates and the
  *  current frame rate, pinned to the canvas's top-right corner. */
-declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }: CursorCoordsHudProps): react_jsx_runtime.JSX.Element | null;
+declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }: CursorCoordsHudProps): react.JSX.Element | null;
 
 /** Props for `<PickHud>`. */
 interface PickHudProps {
@@ -6697,7 +6792,7 @@ interface PickHudProps {
 }
 /** Debug overlay listing every node under the pointer, with the one a click
  *  would actually select shown in bold. */
-declare function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps): react_jsx_runtime.JSX.Element | null;
+declare function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }: PickHudProps): react.JSX.Element | null;
 
 /**
  * imageCache — the kit's per-`src` image loader + cache.
@@ -6721,14 +6816,42 @@ interface ImageNodeData {
     image: {
         src: string;
         opacity?: number;
+        /** The part of the bitmap drawn into the pose rect, as fractions of the
+         *  bitmap's width and height from its top-left. Omitted draws the whole
+         *  bitmap. Fractions, so the data means the same thing before the bitmap
+         *  has decoded and after `src` is swapped for another resolution. */
+        source?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        /** Mirror the drawn region within the pose rect. The rect does not move. */
+        flipX?: boolean;
+        flipY?: boolean;
     };
 }
 /** Where an image is in its load: never requested, in flight, decoded, or
  *  failed. Renderers paint a placeholder for anything but `'ready'`. */
 type ImageStatus = 'idle' | 'loading' | 'ready' | 'error';
+/** A size in device pixels. */
+interface ImageRasterSize {
+    width: number;
+    height: number;
+}
+/** True when `src` names SVG — a `data:image/svg+xml` URI, or a URL whose path
+ *  ends in `.svg`/`.svgz`. Such sources re-rasterize at the size they are drawn
+ *  at; everything else decodes once. A `blob:` URL carries no type and counts
+ *  as raster. */
+declare function isVectorImageSrc(src: string): boolean;
 /** Synchronous read. Returns the decoded bitmap when ready; otherwise returns
- *  `undefined` and lazily starts a de-duped async load for `src`. */
-declare function getImageBitmap(src: string): ImageBitmap | undefined;
+ *  `undefined` and lazily starts a de-duped async load for `src`.
+ *
+ *  `drawnAt` is the size in device pixels the image is about to cover. A
+ *  vector source ({@link isVectorImageSrc}) uses it to re-rasterize in
+ *  power-of-two steps — the current raster is returned until the sharper one
+ *  is ready. Raster sources ignore it. */
+declare function getImageBitmap(src: string, drawnAt?: ImageRasterSize): ImageBitmap | undefined;
 /** Current load status for `src` (`'idle'` if never requested). */
 declare function imageStatus(src: string): ImageStatus;
 /** Subscribe to load-resolution events (fires after any `src` resolves or
@@ -7037,9 +7160,7 @@ declare function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOv
  * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,
  * a `View`, and a per-node `drawOne`, render one frame.
  *
- * Step 1 of the detached-minimap spec
- * (`docs/superpowers/specs/2026-05-31-detached-minimap-design.md`). The full
- * `<SceneCanvas>` render pipeline does much more than this (slots, layer
+ * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer
  * ordering, debug sinks, tool overlays). The helper deliberately re-implements
  * the small subset needed for a non-interactive scene view rather than
  * refactoring `<SceneCanvas>` to share code — the spec calls for that
@@ -7194,7 +7315,7 @@ interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {
      *  pointer listeners or call `toBlob` for snapshots through this. */
     canvasRef?: Ref<HTMLCanvasElement>;
 }
-declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
+declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react.JSX.Element;
 /**
  * Pointer-inert read-only scene view. See `SceneViewCanvasProps` for the
  * full surface and the module docstring for the rendering model.
@@ -7337,6 +7458,20 @@ declare function documentPose<TPose>(source: PoseSource<TPose>, node: PosedNode<
  * walks, the pick walk, the adapters tools and actions commit through.
  */
 declare function effectivePose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
+/**
+ * Whether `node`'s pose is a frame its children are expressed in, under a
+ * composing strategy.
+ *
+ * A container that derives its pose from its children cannot be one: moving
+ * the frame to cover the children would move the children, and a `RectPose`
+ * frame's origin is its corner, so no envelope leaves them in place. Such a
+ * container is an envelope instead — its children are stored in its own
+ * frame — and the composition fold passes over it.
+ */
+declare function definesFrame(node: {
+    dependsOn?: unknown;
+    derivePose?: unknown;
+}): boolean;
 
 /** A node and the pose a renderer should draw it at. `node.pose` beside it is
  *  still the committed pose, so a host has both without a second channel. */
@@ -7365,6 +7500,10 @@ declare const UNION_OF_CHILDREN = "kit:unionOfChildren";
  * box. Paired with `dependsOn: 'children'`, this is what makes a group's
  * bounds track its members instead of freezing at the moment it was made.
  *
+ * Its members and its result share one frame: a container deriving its pose
+ * from its children defines none of its own (see `definesFrame`), so the same
+ * union is right under any composition strategy.
+ *
  * Returns `null` for an emptied container, which falls back to its authored
  * pose — the group stays where the last member left it rather than collapsing
  * to a zero box at the origin.
@@ -7497,17 +7636,121 @@ interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
     className?: string;
     /** Forwarded ref to the underlying `<canvas>`. */
     canvasRef?: Ref<HTMLCanvasElement>;
+    /** The view id this minimap publishes its pointer under. Default
+     *  `'minimap'`. */
+    id?: string;
 }
-declare function MinimapCanvasInner<TData, TLayer extends string, TPose>(props: MinimapCanvasProps<TData, TLayer, TPose>): react_jsx_runtime.JSX.Element;
 /**
  * Opinionated minimap. See `MinimapCanvasProps` for the full surface and
- * the module docstring for the rendering / pointer model.
+ * the module docstring for the rendering / input model.
+ *
+ * Its dispatcher, actions and deps are its own, so it never competes with
+ * the main canvas for input. The pointer store is shared when one is in scope.
  *
  * `forwardRef` is not used because the component is generic over
  * `<TData, TLayer, TPose>` and React's `forwardRef` erases generics. The
  * `canvasRef` prop is the plain-prop equivalent.
  */
-declare const MinimapCanvas: typeof MinimapCanvasInner;
+declare function MinimapCanvas<TData, TLayer extends string, TPose>(props: MinimapCanvasProps<TData, TLayer, TPose>): react.JSX.Element;
+
+/**
+ * A minimap over a `<SceneCanvas>`, written as one `SurfaceContribution`: a
+ * view through a fit camera, the pan that moves the main camera from inside
+ * it, the visible-rect indicator, and a linked crosshair.
+ */
+
+/** Options for {@link createLinkedCursorContribution}. */
+interface LinkedCursorOptions {
+    /** Entry id. Default `'linked-cursor'`. */
+    id?: string;
+    /** Views on this surface the crosshair may paint in. Default `[null]`, the
+     *  surface's own camera — the main canvas beside a detached minimap. */
+    views?: readonly (string | null)[];
+}
+/**
+ * The linked crosshair alone: this surface paints the pointer's position
+ * whenever the pointer is over some other view — another surface under the
+ * same `<PointerContextProvider>`, such as a detached `<MinimapCanvas>`.
+ *
+ * A surface carrying `createMinimapContribution` already has one, in both its
+ * views; this is for a surface without.
+ */
+declare function createLinkedCursorContribution(opts?: LinkedCursorOptions): SurfaceContribution;
+/** Options for {@link createMinimapContribution}. */
+interface MinimapContributionOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {
+    /** View and entry id. Default `'minimap'`. */
+    id?: string;
+    /** Where the minimap paints, in CSS pixels from the canvas top-left. A
+     *  function is re-read every frame, so it can follow the canvas's size. */
+    rect: ViewRect | ((outer: View, dims: Dims) => ViewRect);
+    /** What the minimap frames. Default `'scene'`, the union of leaf poses. */
+    fit?: MinimapFit<TData, TLayer, TPose>;
+    /** The surface layers the minimap paints. Default: all of them. */
+    layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];
+    /** Ground painted before the minimap's layers, so the main canvas does not
+     *  show through. */
+    background?: string;
+    /** The visible-rect indicator's stroke. */
+    indicatorStyle?: IndicatorStyle;
+}
+/**
+ * A minimap inside a `<SceneCanvas>`, installed with one entry:
+ *
+ * ```tsx
+ * const minimap = useMemo(() => createMinimapContribution({ rect: { x: 8, y: 8, w: 160, h: 110 } }), []);
+ * <SceneCanvas ambient={[minimap]} … />
+ * ```
+ *
+ * Press in it to center the main camera on that point, drag to keep it there.
+ * It shows the main camera's visible rect, and a crosshair where the pointer is
+ * over the other view. Build it once — each instance keeps the live state its
+ * layers read.
+ */
+declare function createMinimapContribution<TData = unknown, TLayer extends string = string, TPose = unknown>(opts: MinimapContributionOptions<TData, TLayer, TPose>): SurfaceContribution;
+
+/**
+ * The minimap's input: press to recenter the main camera on a world point,
+ * drag to keep it there. Both read `rootView` — never `view`, which inside the
+ * minimap's own view answers the minimap's camera.
+ */
+
+declare const MINIMAP_CENTER = "minimap.center";
+declare const MINIMAP_PAN = "minimap.pan";
+/** Move `root` so world point (`x`, `y`) sits at the center of its host,
+ *  keeping its scale. A no-op while the host is unmeasured. */
+declare function centerRootOn(root: ViewApi, x: number, y: number): void;
+/** Recenter the main camera on the pressed world point. */
+declare function minimapCenterAction(): Action;
+/** Keep the main camera centered on the pointer's world point while dragging.
+ *  Pair it with `minimap.center` on `pointerDown`, which handles the press.
+ *  A recenter lands the moment it is computed, so there is nothing to commit
+ *  and a cancel ends where a release does. */
+declare function minimapPanAction(): Action;
+
+/**
+ * The minimap's chrome: the main camera's visible rect, drawn in the minimap,
+ * and the linked crosshair, drawn in every view the pointer is not over.
+ */
+
+/** The halo's color: dark enough to separate the accent from any content. */
+declare const CROSSHAIR_HALO = "rgba(0, 0, 0, 0.6)";
+/** An axis-aligned rect, `{ x, y, w, h }`. */
+interface CrosshairRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * The linked crosshair at (`x`, `y`) as rects in the caller's units, where one
+ * screen pixel is `unitsPerPx` of them: four halo rects to paint first, then
+ * four bars. A painter with no weasel renderer — a 2D canvas — draws the same
+ * crosshair from these.
+ */
+declare function crosshairRects(x: number, y: number, unitsPerPx: number): {
+    halo: CrosshairRect[];
+    bars: CrosshairRect[];
+};
 
 /** Plain RGBA raster — structurally `ImageData`-compatible ({ width, height,
  *  data }), deliberately free of printer/dpi/physical-unit concepts. */
@@ -7669,74 +7912,22 @@ declare function SelectionContextProviderIfRoot({ children, }: {
  */
 declare function usePublishSelection(ids: readonly NodeId[], kinds?: readonly (string | undefined)[]): void;
 
-/**
- * @experimental
- * PointerContext — a tiny ambient context that publishes the world-space
- * position of the canvas pointer, refreshed on every `pointermove` over
- * the canvas. Cleared (set to `null`) on `pointerleave`.
- *
- * Why ref-based and not state-based: cursor moves fire dozens of times per
- * second; routing those through React state would re-render every consumer
- * in the tree. The context exposes a stable `pointerRef` whose `.current`
- * is mutated directly by the publisher, plus a thunk `getDropPoint()` that
- * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk
- * inside their callbacks — no subscription, no re-render.
- *
- * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when
- * the caller didn't pass an explicit `getDropPoint` option. Other future
- * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse
- * the same context.
- */
-
-/** @experimental World-space pointer position, or `null` when the pointer
- *  isn't over the publishing canvas. */
-type PointerWorldPos = {
-    worldX: number;
-    worldY: number;
-} | null;
-/** @experimental */
-interface PointerContextValue {
-    /** Live ref — mutate to publish, read for the latest snapshot. The
-     *  identity is stable for the lifetime of the provider. */
-    readonly pointerRef: MutableRefObject<PointerWorldPos>;
-    /** Convenience thunk equivalent to `() => pointerRef.current`. Stable
-     *  identity for the lifetime of the provider; safe to pass to hooks. */
-    readonly getDropPoint: () => PointerWorldPos;
-}
-/**
- * @experimental
- * Wrap the part of the React tree that should share a pointer-position
- * context. Usually placed at the demo / app root, alongside
- * `<ActionsProvider>` and `<SelectionContextProvider>`.
- *
- * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts
- * an internal provider when no parent provider is in scope, so child hooks
- * (`useClipboard` without an explicit `getDropPoint`) read the canvas's
- * tracked pointer for free.
- */
-declare function PointerContextProvider({ children }: {
-    children: ReactNode;
-}): ReactNode;
-/** @experimental Read the surrounding pointer-context value, or `null` when
- *  no provider is in scope. */
-declare function usePointerContext(): PointerContextValue | null;
-
 /** Mount a `<PointerContextProvider>` only when none is already in scope. */
 declare function PointerProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 /** Mount an `<ActionsProvider>` only when none is already in scope, so
  *  nesting canvases share one action registry instead of shadowing it. */
 declare function ActionsProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 /** Mount a `<DepRegistryProvider>` only when none is already in scope, so a
  *  consumer's dep sources are not shadowed by a nested canvas. */
 declare function DepRegistryProviderIfRoot({ children }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 interface WeaselProviderProps {
     children: ReactNode;
@@ -7761,7 +7952,7 @@ interface WeaselProviderProps {
  * state has to be shared by things outside a canvas: a toolbar, a property
  * panel, or two canvases that should agree on the selection.
  */
-declare function WeaselProvider({ children, isolate }: WeaselProviderProps): react_jsx_runtime.JSX.Element;
+declare function WeaselProvider({ children, isolate }: WeaselProviderProps): react.JSX.Element;
 
 /** Options for `useCanvasFocus`. */
 interface UseCanvasFocusOptions {
@@ -10518,7 +10709,11 @@ declare const DEFAULT_FILL_COLOR = "#ffffffff";
 declare const DEFAULT_STROKE_COLOR = "#000000ff";
 /** Default fill palette cycled through for auto-generated shape nodes
  *  (the kit's built-in shape tools and the `insert` action). */
-declare const DEFAULT_PALETTE: readonly string[];
+declare const DEFAULT_PALETTE: Palette;
+/** The `seq`th color of `palette`'s entries as hex, wrapping past the end.
+ *  An entry that resolves to nothing, or to a space with no hex form, gives
+ *  `fallback`. */
+declare function cycleFill(seq: number, palette?: Palette, fallback?: string): string;
 /** Preview / "ghost" stroke color used by drag-to-draw tool overlays and the
  *  selected-anchor highlight. Derived from the first palette entry so the
  *  preview chrome matches the default insert color. */
@@ -11968,32 +12163,32 @@ interface IconProps {
 /** Classic cursor-arrow shape — filled silhouette pointing top-left to
  *  bottom-right with the diagonal "tail" along the lower edge. Used for
  *  `useSelectTool`. */
-declare function SelectIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function SelectIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Freeform marquee — outlined irregular loop with a short tail
  *  suggesting "the lasso closed where you released the pointer." Used
  *  for `useLassoTool`. */
-declare function LassoIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function LassoIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined rectangle with a small crosshair at the upper-left corner,
  *  signaling "this is a drawing tool, not just a shape." Used for the
  *  rectangle insertion tool (`useInsertTool` today, future `useRectTool`). */
-declare function RectIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function RectIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined ellipse. Used for the ellipse insertion tool. */
-declare function EllipseIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function EllipseIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Framed picture with a sun and mountain — the conventional "image" glyph.
  *  Used for the image insertion tool (`useImageTool`). */
-declare function ImageIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ImageIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Eyedropper — diagonal stem running from upper-right (bulb) to
  *  lower-left (tip), with a small squared bulb cap at the top. Used
  *  for the eyedropper / color-picker tool. */
-declare function EyedropperIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function EyedropperIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Diagonal line. Used for the line insertion tool. */
-declare function LineIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function LineIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** `LineIcon`'s diagonal with a filled head, so the two read as one tool with
  *  and without the marker. Used for the arrow insertion tool.
@@ -12002,47 +12197,115 @@ declare function LineIcon({ className, size }: IconProps): react_jsx_runtime.JSX
  *  under antialiasing and the notch disappears, leaving a blob. Its base
  *  corners are `tip ∓ 5.6·d ± 2.1·d⊥` — computed, and the shaft stops half a
  *  unit inside the base so its round cap hides under the fill. */
-declare function ArrowIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function ArrowIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined hexagon. Used for the polygon insertion tool. */
-declare function PolygonIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PolygonIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Outlined five-point star. Used for the star insertion tool. */
-declare function StarIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function StarIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Slanted pencil pointing toward the upper-right corner. Used for the
  *  freehand pencil insertion tool. */
-declare function PencilIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PencilIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Serif "T" — top bar + stem + small bottom serif. Used for
  *  `useTextTool`. Visually consistent with the layer-list text icon. */
-declare function TextIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function TextIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Pen nib — angled filled body with a pointed tip and a small ink dot
  *  at the very tip, plus a short "control" handle extending out the
  *  back. Used for `usePenTool`. */
-declare function PenIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PenIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Open hand — rounded palm with four upward fingers (variable length)
  *  and a thumb stub. Used for `useHandTool` (viewport pan). */
-declare function HandIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function HandIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Placeholder for tools without `presentation.icon`. A circle with "?"
  *  inside — readable, debuggable, not hidden. */
-declare function UnknownIcon({ className, size }: IconProps): react_jsx_runtime.JSX.Element;
+declare function UnknownIcon({ className, size }: IconProps): react.JSX.Element;
 
 /** Icon for the union operation: two overlapping circles merged into one filled shape. */
-declare function UnionIcon(): react_jsx_runtime.JSX.Element;
+declare function UnionIcon(): react.JSX.Element;
 /** Icon for the intersect operation: only the overlap of two circles filled. */
-declare function IntersectIcon(): react_jsx_runtime.JSX.Element;
+declare function IntersectIcon(): react.JSX.Element;
 /** Icon for the subtract operation: the front circle removed from the back one. */
-declare function SubtractIcon(): react_jsx_runtime.JSX.Element;
+declare function SubtractIcon(): react.JSX.Element;
 /** Icon for the exclude operation: both circles filled except their overlap. */
-declare function ExcludeIcon(): react_jsx_runtime.JSX.Element;
+declare function ExcludeIcon(): react.JSX.Element;
 /** Icon for the divide operation: two circles split into their separate regions. */
-declare function DivideIcon(): react_jsx_runtime.JSX.Element;
+declare function DivideIcon(): react.JSX.Element;
 /** Icon for the crop operation: the back shape clipped to the front one. */
-declare function CropIcon(): react_jsx_runtime.JSX.Element;
+declare function CropIcon(): react.JSX.Element;
+
+/** Cut: scissors. */
+declare function CutIcon(): react.JSX.Element;
+/** Copy: a document peeking out behind another. */
+declare function CopyIcon(): react.JSX.Element;
+/** Paste: a clipboard with a filled clip. */
+declare function PasteIcon(): react.JSX.Element;
+/** Duplicate: the source outlined, the copy filled. */
+declare function DuplicateIcon(): react.JSX.Element;
+/** Group: corner brackets framing two filled rects. */
+declare function GroupIcon(): react.JSX.Element;
+/** Ungroup: two filled rects escaping a frame broken to two dashed corners. */
+declare function UngroupIcon(): react.JSX.Element;
+/** Bring forward: two stacked rects, the front one filled. */
+declare function BringForwardIcon(): react.JSX.Element;
+/** Bring to front: three stacked rects, the frontmost filled. */
+declare function BringToFrontIcon(): react.JSX.Element;
+/** Send backward: two stacked rects, the rear one filled. */
+declare function SendBackwardIcon(): react.JSX.Element;
+/** Send to back: three stacked rects, the rearmost filled. */
+declare function SendToBackIcon(): react.JSX.Element;
+/** Flip horizontal: an outlined and a filled chevron either side of a dashed vertical axis. */
+declare function FlipXIcon(): react.JSX.Element;
+/** Flip vertical: an outlined and a filled chevron either side of a dashed horizontal axis. */
+declare function FlipYIcon(): react.JSX.Element;
+
+declare function AlignLeftIcon(): react.JSX.Element;
+declare function AlignRightIcon(): react.JSX.Element;
+declare function AlignTopIcon(): react.JSX.Element;
+declare function AlignBottomIcon(): react.JSX.Element;
+declare function AlignCenterXIcon(): react.JSX.Element;
+declare function AlignCenterYIcon(): react.JSX.Element;
+
+declare function DistributeHorizontalIcon(): react.JSX.Element;
+declare function DistributeVerticalIcon(): react.JSX.Element;
+
+/**
+ * @experimental
+ * Props for the undo, redo and delete glyphs — the same shape as
+ * `@weasel-js/ui`'s `IconProps`, which re-exports these components.
+ */
+interface ActionGlyphProps extends IconProps {
+    /** Accessible name. Omit inside a button that already labels itself; the
+     *  glyph is then `aria-hidden`. */
+    label?: string;
+    /** Accepted for parity with the rest of the ui icon set; none of these
+     *  glyphs encloses a region, so it draws nothing. */
+    filled?: boolean;
+    fillOpacity?: number;
+}
+/** @experimental Undo: a straight run returning in a half circle, arrowhead on the run. */
+declare function UndoIcon(p: ActionGlyphProps): react.JSX.Element;
+/** @experimental Redo: the undo glyph mirrored. */
+declare function RedoIcon(p: ActionGlyphProps): react.JSX.Element;
+/** @experimental Delete: a lidded trash can. */
+declare function DeleteIcon(p: ActionGlyphProps): react.JSX.Element;
+
+/**
+ * @experimental
+ * SVG bodies of the glyphs the undo, redo and delete actions ship as their
+ * icons: 20x20 viewBox, stroked in currentColor at stroke-width 1.5 with round
+ * caps and joins. `<Icon name="undo" />` in `@weasel-js/ui` draws the same one.
+ */
+declare const ACTION_GLYPHS: {
+    readonly delete: "<path d=\"M3.6 5.8h12.8M8 5.8V4.5A1.1 1.1 0 0 1 9.1 3.4h1.8A1.1 1.1 0 0 1 12 4.5v1.3\"/><path d=\"M5.2 5.8v9.6A1.6 1.6 0 0 0 6.8 17h6.4a1.6 1.6 0 0 0 1.6-1.6V5.8\"/><path d=\"M8.4 8.8v5.2M11.6 8.8v5.2\" stroke-width=\"1\"/>";
+    readonly undo: "<path d=\"M4.4 8.4h6.8a3.6 3.6 0 0 1 0 7.2H8.6\"/><path d=\"M6.47 10.14 4.4 8.4 6.47 6.66\"/>";
+    readonly redo: "<path d=\"M15.6 8.4H8.8a3.6 3.6 0 0 0 0 7.2H11.4\"/><path d=\"M13.53 6.66 15.6 8.4 13.53 10.14\"/>";
+};
 
 /**
  * The painted tier: draws a cursor glyph into the scene when it is too big,
@@ -12071,4 +12334,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ANCHOR_HIT_BASE_PX, type ActionShortcut, ActionsProviderIfRoot, type Affordance, type AffordanceBinding, type AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, type AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, type BakedMesh, type BindRigOptions, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CellHighlightLayerOpts, type ChromeCtx, type ChromeId, type ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateTiledLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CustomPaintContext, 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, DepRegistryProviderIfRoot, type DeriveAlignmentGuidesOptions, DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type Discriminator, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EasingSpec, Effect, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FeedDelta, type FeedNode, type FillPoseBox, type FitTextPoseOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, GlMat3, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, IntersectIcon, type Joint, type JointTransform, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, type KeyModifiers, type KeyState, type KeyStateAttachOptions, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LayerCommandCache, type LayerDrawFailure, LayerEnumerableAdapter, type LayerGroup, type LayerHit, type LayerSlotValue, type LayersMap, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, type MeshGradientFill, type MeshPatch, type MeshPoint, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, type PathInWorldPose, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerContextProvider, type PointerContextValue, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PointerWorldPos, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseComposition, PoseDescriptor, type PoseFeed, PoseOverrides, type PoseRotation, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PosedNode, type PressureToWidthOptions, type PreviewNode, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, RectIcon, RectPath, RectPose, 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, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, Simulation, SimulationNode, type Skeleton, type Slew, type SlewRates, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, TextDrawCommand, type TextEditClipRect, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileBleed, type TileGridOptions, type TilePatternOpts, type TilePeriod, type TileRange, type Tool, type ToolBundle, type ToolDef, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberFormat, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UNION_OF_CHILDREN, UnionIcon, Unit, UnitEntry, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, VERSION, type VelocityTracker, VertexColorChannel, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, ZOOM_FLOOR, type ZoomBound, type ZoomClampOpts, type ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bakeMesh, bezierCubic, bezierQuadratic, bindRig, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, cornerWeights, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createKeyState, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSlew, createTextLayer, createTilePattern, createTiledLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, 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, keySpecShortcut, lassoSelectAction, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, meanScale, mergeAlphaFromPrev, meshBounds, meshGradientXml, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, openFilePicker, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, patchBounds, patchCorner, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInTextPose, poseRotationOf, prefUnit, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectMarkerPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveVisibility, rgbaToHex, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotationDegreesUnit, rotationHandle, roundRectPath, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, seedMeshPatch, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, slewToward, sliceAction, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, squarePath, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, tiledProject, toHex8, transformPath, translatePath, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, unionOfChildren, unionOfChildrenVia, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerContext, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRig, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, worldToScreen, zoomAt, zoomAtLeast };
+export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, 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 };