@weasel-js/core 1.5.0 → 1.5.2

package/dist/index.d.ts

@@ -1,40 +1,43 @@
 import * as React$1 from 'react';
-import React__default, { RefObject, ReactNode, Ref, MouseEvent, ComponentType, MutableRefObject } from 'react';
-import { a as UnitValue, b as UnitSystem, c as Unit, U as UseMoveOptions, O as OriginProjection } from './grid-BrIa38gG.js';
-export { A as ANGLE_RADIANS, I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-BrIa38gG.js';
-import { View, NodeId, Bounds, ModifierState, PointerSessionCancelReason, DeviceProfile, Action, SelectionMode, SelectionExtendKey, SelectionApi, DepSchema, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1, ViewportToolDef as ViewportToolDef$1, HitShape, HandleKind, DebugSink, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, IngestItem, OngoingOverlay, ActionsProp, OverlayRole, ResizeAnchor } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionPresentation, ActionsProp, ActionsRegistry, AffordanceHit, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DebugSink, DepName, DepSchema, DetectedDeviceFacts, DeviceProfile, Dispatcher, DispatcherContext, DragSample, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, MatchResult, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OverlayPosition, OverlayRole, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, ToolCtx, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, UiOngoingControl, View, actionBindings, buildRuleCtx, clientToCanvas, createDispatcher, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, mergeContributions, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
-import { FillStyle, Stroke, TextureHandle, TilePatternSpec, GradientKind, GradStop, GradientFill, GradientUnits, MarkerKey, MarkerRef } from '@weasel-js/paint';
-export { FillStyle, GradStop, GradientFill, GradientKind, GradientUnits, KitMarkerKey, MarkerKey, MarkerRef, Region, STROKE_DASH_RATIOS, Stroke, StrokeAlign, StrokeDashStyle, TextureHandle, TilePatternSpec, alignedStrokeRect, dashForStrokeStyle, strokeDashStyleOf } from '@weasel-js/paint';
-import { D as DrawCommand, E as Effect, u as Scene, w as RectPose, x as InertiaConfig, y as ViewAnimationOptions, N as Node$1, z as PoseComposition, A as SliceDep, B as VertexColorChannel, f as ShaderProgramHandle, C as InsertExtras, F as SerializedScene, H as GeometryProjection, J as ContentHandlerEntry, K as SvgIngestOptions, L as PanBounds, O as Animator, Q as ColorOverrideRegistry, U as UseSceneOptions, X as SceneRegistry, Y as RegisteredOp, Z as PoseOverrides, _ as DerivedDep, $ as ViewportDims, P as PathDrawCommand, T as TextDrawCommand, a0 as ShaderProgram, c as Mat3$1, a1 as BooleansAdapter, a2 as UseAnimatorOptions, a3 as SpringPresetName, a4 as EasingSpec, a5 as AnimationHandle, a6 as SampledTrack } from './depSchema-nMqj_qTM.js';
-export { a7 as AddLayerSpec, a8 as AddNodeSpec, a9 as AnimateToBoundsOptions, aa as AreaSelectDep, ab as BezierEasing, ac as BooleanOp, ad as BooleanOpResult, ae as ClipboardDep, af as ClipboardIngestCtx, ag as ColorOverride, ah as ColorOverrideFn, ai as ContainerNode, aj as DecayLoopConfig, ak as DecayOptions, al as EASINGS, am as EasingFn, an as EasingName, ao as EditAnchorsDep, ap as EventBooking, aq as EventBookingHandle, ar as EventTrack, as as FitViewToBoundsOptions, G as GroupDrawCommand, at as IDENTITY_POSE_COMPOSITION, a as ImageDrawCommand, b as ImageMinification, au as IngestCtx, av as IngestionDep, aw as InsertDep, ax as Interpolate, ay as InterpolatorFactory, az as Keyframe, aA as LassoSelectDep, aB as LayerRecord, aC as LayoutDep, aD as LeafNode, aE as LoopFactory, aF as LoopOptions, aG as NestedTimeline, aH as NodeAtPointDep, aI as PhysicsHandle, aJ as PhysicsOptions, aK as PointerContextProvider, aL as PointerContextValue, aM as PointerWorldPos, aN as PoseAdapter, aO as PoseClosure, aP as PoseOverride, aQ as RECT_POSE_COMPOSITION, aR as RIGID_POSE_COMPOSITION, R as RenderTarget, aS as ResizePolicy, aT as SPRING_PRESETS, S as SPRITE_STRIDE, aU as SerializedNode, e as ShaderDrawCommand, g as ShaderUniform, aV as SnapDep, aW as SpringOptions, aX as SpringPreset, i as SpriteSheet, j as SpritesDrawCommand, aY as StaggerBuilder, aZ as StaggerDelay, a_ as StaggerFactory, a$ as StaggerOptions, b0 as StaggerPerItem, b1 as StaggerSpringPoseOptions, b2 as StaggerTweenOptions, b3 as SvgUnpacker, b4 as SystemLayerRecord, b5 as SystemLayerSpec, b6 as TextEditDep, b7 as TimelineClock, b8 as TimelineEvent, b9 as TimelineHandle, ba as TimelineOptions, bb as TimelineTrack, bc as Track, bd as TweenLoopOptions, be as TweenOptions, bf as UserLayerRecord, bg as VIEW_ANIMATION_KEY, bh as ViewAnimationApi, bi as ViewApi, bj as ViewChannel, bk as applyBooleanOp, bl as asNodeId, m as blur, bm as composeRectPose, bn as composeRigidPose, bo as composeWorldPose, bp as cubicBezierEasing, bq as decomposeRectPose, br as decomposeRigidPose, bs as easeIn, bt as easeInBack, bu as easeInBounce, bv as easeInCirc, bw as easeInCubic, bx as easeInElastic, by as easeInExpo, bz as easeInOut, bA as easeInOutBack, bB as easeInOutBounce, bC as easeInOutCirc, bD as easeInOutCubic, bE as easeInOutElastic, bF as easeInOutExpo, bG as easeInOutQuad, bH as easeInOutQuart, bI as easeInOutQuint, bJ as easeInOutSine, bK as easeInQuad, bL as easeInQuart, bM as easeInQuint, bN as easeInSine, bO as easeOut, bP as easeOutBack, bQ as easeOutBounce, bR as easeOutCirc, bS as easeOutCubic, bT as easeOutElastic, bU as easeOutExpo, bV as easeOutQuad, bW as easeOutQuart, bX as easeOutQuint, bY as easeOutSine, bZ as fitViewToBounds, o as frameRect, b_ as linear, p as mat3, b$ as rebaseLocalPose, c0 as registerContentHandler, r as registerEffect, c1 as resolveEasing, c2 as resolveStrokeWidth, c3 as translateRectPose, c4 as useDecayLoop, c5 as usePointerContext, c6 as useViewAnimation, v as viewToMat3, s as vignette, c7 as worldPoseLookup } from './depSchema-nMqj_qTM.js';
+import 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 { 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';
 import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1 } from '@weasel-js/routing/react';
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, DepRegistry, DepRegistryProvider, UseGestureDispatcherOptions, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, R as RotateBehavior, S as SnapStrategy, M as MoveBehavior, I as InsertBehavior } from './types-DMyo7dnM.js';
-export { A as ActionBehavior, b as AreaSelectOverlay, c as BehaviorMoveResult, d as BehaviorResult, C as CloneBehavior, e as CloneLayer, f as ClonePose, G as GestureContext, g as GroupTransform, h as InsertMoveResult, i as InsertOverlay, j as InsertPoint, k as InsertProposed, l as LassoSelectMoveResult, m as LassoSelectOverlay, n as LassoSelectPose, o as LassoSelectProposed, p as PointSnapContext, a as PointSnapFrame, q as PointSnapResult, r as PointerState, s as ResizeMoveResult, t as ResizeOverlay, u as ResizeProposed, v as RotateMoveResult, w as RotateOverlay, x as RotateProposed } from './types-DMyo7dnM.js';
-import { P as PoseDescriptor, c as PolygonPath, a as Path, d as RotatedPose, e as PathFillRule, f as RectPath } from './poseDescriptor-CGOgIgf8.js';
-export { R as RECT_POSE_DESCRIPTOR, b as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-CGOgIgf8.js';
-import { U as UseResizeOptions } from './autoPoseDescriptor-CvjflWJK.js';
-export { A as AUTO_POSE_DESCRIPTOR, C as CORNER_ANCHORS, a as CornerAnchor, g as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, i as isPathLike, e as isRectPose, p as pointSnapToGrid } from './autoPoseDescriptor-CvjflWJK.js';
-import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, b as LassoHitMode, c as LassoSelectAdapter, d as ResizeAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, a as SceneAdapter, f as LayoutSnap } from './types-DtjCJA5r.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DtjCJA5r.js';
+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';
 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, TextPaint, TextVerticalAlign } from '@weasel-js/text';
+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';
 import { G as Guide } from './types-D2tTKEU0.js';
-export { U as UseInsertOptions } from './options-BDyCnrp8.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 { UseClipboardOpsOptions, UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './clipboard.js';
 export { cloneByAltDrag } from './clone.js';
-export { FontVariant, LocalFontOutlinesResult, OutlineFontStyle, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
+export { FontStyle, FontVariant, LocalFontOutlinesResult, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
 
 /**
  * The kit version a build was compiled from, so an app can report what it is
@@ -464,7 +467,15 @@ interface LayerDrawFailure {
 interface LayerGroup {
     /** Names the group in warnings; not a layer id and never drawn. */
     id: string;
-    /** Member layer ids. Order here is ignored — the render order decides. */
+    /**
+     * Member layer ids. Order here is ignored — the render order decides.
+     *
+     * A name claims that layer and every layer under it in the `:` namespace, so
+     * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers
+     * draws as — the same set `before`/`after: 'scene'` anchors against. The
+     * separator is required: `'scene'` does not reach `scenery`. A name matching
+     * no layer being drawn is warned about rather than ignored.
+     */
     layers: readonly string[];
     /**
      * Passes over the group's combined pixels, in order. A thunk is re-read on
@@ -989,128 +1000,87 @@ interface CreateParallaxLayerOpts<TData> extends ParallaxOpts {
 declare function createParallaxLayer<TData>(opts: CreateParallaxLayerOpts<TData>): RenderLayer<TData>;
 
 /**
- * Minimal node interface for the simulation primitive. Matches d3-force's
- * node shape exactly so d3-force's bundled forces work without translation.
+ * Which copies of a periodic lattice a visible range touches.
+ *
+ * A tiled layer's content is authored once, in the cell `[0, period)`, and the
+ * lattice repeats it at every multiple of `period`. This answers the only
+ * question drawing it needs: the integer copies `k` whose cell overlaps
+ * `[visStart, visEnd]`. Copy `k` draws the authored content shifted by
+ * `k * period`.
  *
- * Consumers extend this with arbitrary additional fields (id, label, etc.).
+ * `bleed` is how far the content reaches outside its own cell, in world
+ * units — the printing term, and the same idea. Content that overhangs by
+ * more than it declares pops in at the edge of the view instead of scrolling
+ * in.
  */
-interface SimulationNode {
-    x: number;
-    y: number;
-    vx?: number;
-    vy?: number;
-    /** Pin x to this value when non-null. The integrator skips x/vx for the node. */
-    fx?: number | null;
-    fy?: number | null;
-    /** Array index, written by `initialize`. Some forces (e.g. forceLink) rely on it. */
-    index?: number;
+interface TileRange {
+    /** First copy index, inclusive. */
+    from: number;
+    /** Last copy index, inclusive. `to < from` means nothing is visible. */
+    to: number;
 }
+declare function tiledProject(visStart: number, visEnd: number, period: number, bleed?: number): TileRange;
+
 /**
- * Force protocol — contract-compatible with d3-force. A force is a function
- * called once per tick with the current alpha; it mutates `vx`/`vy` on nodes.
- * Optional `initialize` lets the force compute setup (link indices, etc.).
+ * How far apart the copies sit, in world units. A bare number wraps the x
+ * axis only — the side-scrolling backdrop this is usually reached for.
+ * `{ x, y }` wraps both; naming one key wraps that axis alone.
+ *
+ * The period names the axes, so there is no separate `axis` option: two ways
+ * to say which axes wrap is one way for them to disagree.
  */
-interface SimulationForce<TNode extends SimulationNode = SimulationNode> {
-    (alpha: number): void;
-    initialize?(nodes: TNode[], random?: () => number): void;
-}
-/** Options for `useSimulation`: everything {@link SimulationOptions} carries,
- *  plus the loop's own callbacks and clock. */
-interface UseSimulationOptions<TNode extends SimulationNode> extends SimulationOptions<TNode> {
-    /** Fired after each integration step. */
-    onTick?: (nodes: TNode[]) => void;
-    /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */
-    onEnd?: () => void;
-    /** Optional rAF injection. Defaults to window.requestAnimationFrame. */
-    requestFrame?: (cb: (t: number) => void) => number;
-    cancelFrame?: (handle: number) => void;
+type TilePeriod = number | {
+    x?: number;
+    y?: number;
+};
+/** How far the content reaches outside its own cell, in world units. */
+type TileBleed = number | {
+    x?: number;
+    y?: number;
+};
+/** Options for {@link createTiledLayer}. */
+interface CreateTiledLayerOpts<TData> {
+    id: string;
+    label: string;
+    /** Layers redrawn once per visible copy. */
+    source: RenderLayer<TData>[];
+    /**
+     * The lattice. A function is read per draw, so the period can follow the
+     * camera or the canvas — "one screen wide" is a period, not a constant.
+     */
+    period: TilePeriod | ((view: View, dims: Dims) => TilePeriod);
+    /**
+     * How far the source's content reaches outside the cell `[0, period)`, in
+     * world units. Content that overhangs by more than it declares pops in at
+     * the edge of the view instead of scrolling in. Default 0.
+     */
+    bleed?: TileBleed;
 }
 /**
- * A force simulation over a set of nodes, with no clock of its own.
- *
- * Each tick applies every force and then integrates velocities, scaled by
- * `alpha` — a temperature that decays toward `alphaTarget` so the layout
- * settles instead of jittering forever. Raise `alphaTarget` to reheat it,
- * which is what a drag does.
- *
- * Nodes are mutated in place; the simulation holds the array, not a copy.
- *
- * Nothing here advances time. {@link Simulation} adds the frame loop; a caller
- * that wants the whole relaxation at once — a layout pass, a pre-warm, a test
- * — drives {@link SimulationCore.tick} itself.
- */
-interface SimulationCore<TNode extends SimulationNode> {
-    readonly nodes: TNode[];
-    setNodes(nodes: TNode[]): this;
-    setForces(forces: SimulationForce<TNode>[]): this;
-    alpha(): number;
-    alpha(value: number): this;
-    alphaTarget(): number;
-    alphaTarget(value: number): this;
-    alphaDecay(): number;
-    alphaDecay(value: number): this;
-    alphaMin(): number;
-    alphaMin(value: number): this;
-    velocityDecay(): number;
-    velocityDecay(value: number): this;
-    /**
-     * Run the tick body synchronously `iterations` times. Does NOT fire
-     * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.
-     */
-    tick(iterations?: number): this;
-    isSettled(): boolean;
-}
-/** A {@link SimulationCore} running on a frame loop. */
-interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {
-    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
-    restart(): this;
-    /** Cancel the RAF loop. Does not change alpha. */
-    stop(): this;
-}
-/** What {@link SimulationCore} needs: the nodes, the forces acting on them,
- *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */
-interface SimulationOptions<TNode extends SimulationNode> {
-    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
-    nodes: TNode[];
-    /** Forces applied per tick. Each may implement `initialize` for setup. */
-    forces?: SimulationForce<TNode>[];
-    /** Initial alpha. Default 1. */
-    alpha?: number;
-    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
-    alphaMin?: number;
-    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
-    alphaDecay?: number;
-    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
-    alphaTarget?: number;
-    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
-    velocityDecay?: number;
-    /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded
-     *  source to make a run reproducible. */
-    random?: () => number;
-}
-/** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */
-declare const DEFAULT_ALPHA_DECAY: number;
-/** Alpha below which a cooling simulation is considered settled. */
-declare const DEFAULT_ALPHA_MIN = 0.001;
-/** Fraction of velocity shed each tick — friction. Higher settles sooner and
- *  overshoots less. */
-declare const DEFAULT_VELOCITY_DECAY = 0.4;
-
-/**
- * The integrator, with no clock attached.
- *
- * Velocity-Verlet over a pluggable force list, contract-compatible with
- * d3-force so d3's own bundled forces drop in untranslated. Nothing here
- * advances time: `tick()` is the only thing that moves a node, and the caller
- * decides how often to call it. `useSimulation` calls it once a frame; a
- * layout pass calls it a few hundred times in one go and reads the result.
- *
- * Splitting it out is what lets a *pure* function run a relaxation — a React
- * hook cannot, and the alternative was a second integrator drifting away from
- * this one.
+ * Wrap source RenderLayers in a periodic lattice: the content is authored
+ * once, in the cell `[0, period)`, and every copy of it the view can see is
+ * drawn. Panning in either direction keeps producing copies, so the content
+ * loops seamlessly with no state and no wrap-around bookkeeping.
+ *
+ * Each copy draws the source through a view shifted by `-k * period`, so a
+ * source that culls against the view it is handed culls per copy and never
+ * learns it is being tiled. The copy's commands are then translated by
+ * `+k * period` in world space.
+ *
+ * The lattice is per layer, not per shape. Content on two different periods
+ * is two tiled layers stacked, which keeps each source ignorant of the other
+ * — a per-shape period would move the lattice into the source and make the
+ * wrapper unable to cull.
+ *
+ * The plane is `space: 'world'`, which is what lets it be a `source` of
+ * `createParallaxLayer`: the parallax plane hands it the derived inner view,
+ * the lattice resolves against that, and the copies ride the plane.
+ *
+ * **A `space: 'screen'` source is drawn once, untiled** — it ignores the view
+ * by definition, so every copy would land on top of the last. Same constraint
+ * `createParallaxLayer` carries.
  */
-
-declare function createSimulation<TNode extends SimulationNode>(opts: SimulationOptions<TNode>): SimulationCore<TNode>;
+declare function createTiledLayer<TData>(opts: CreateTiledLayerOpts<TData>): RenderLayer<TData>;
 
 /**
  * Continuous N-body simulation primitive: `createSimulation`'s integrator on a
@@ -1753,6 +1723,66 @@ declare function computeFitViewport(viewportW: number, viewportH: number, conten
  */
 declare function useAutoCenter(width: number, height: number, contentW: number, contentH: number, setZoom: (z: number) => void, setPan: (x: number, y: number) => void): void;
 
+/**
+ * Which physical keys are down right now — the poll a game loop or character
+ * controller reads each step. This is raw input state, not routing: it sees
+ * every key whether or not a binding claims it, and a binding claiming a key
+ * does not hide it from here.
+ */
+interface KeyModifiers {
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+}
+interface KeyStateAttachOptions {
+    /** Ignore presses whose target is an input, textarea or contenteditable
+     *  element. Their releases are always taken. Default `true`. */
+    skipInEditable?: boolean;
+    /** `KeyboardEvent.code`s whose keydown and keyup have their default
+     *  prevented — the keys a game owns, so Space and the arrows stop scrolling
+     *  the page. */
+    preventDefault?: readonly string[];
+}
+interface KeyState {
+    /** Whether any of these physical keys, by `KeyboardEvent.code`
+     *  (`'KeyA'`, `'Space'`, `'ArrowLeft'`), is down. Codes name positions, so
+     *  WASD stays in place on any layout. */
+    isDown(code: string | readonly string[]): boolean;
+    /** Whether a key down produced any of these `KeyboardEvent.key` values when
+     *  it was pressed. Single characters compare case-insensitively. */
+    isKeyDown(key: string | readonly string[]): boolean;
+    /** Whether any of these codes was freshly pressed since it was last taken;
+     *  clears them. Autorepeat is not a press. A press is taken once, so two
+     *  readers of the same code see it once between them. */
+    take(code: string | readonly string[]): boolean;
+    /** Every code down. The set is live — copy it to keep it. */
+    codes(): ReadonlySet<string>;
+    modifiers(): KeyModifiers;
+    /** Called on every change of what is down. Returns the unsubscribe. */
+    subscribe(listener: () => void): () => void;
+    /** Mark everything up and drop untaken presses. */
+    release(): void;
+    /**
+     * Listen on `target` — `window`, or an element whose subtree has focus.
+     * Everything is released when the keyups can no longer arrive: the window
+     * blurs, the document hides, focus leaves an element target, or Meta is
+     * released (macOS delivers no keyup for a key released while Cmd is held).
+     * Returns the detach, which also releases.
+     */
+    attach(target: Window | HTMLElement, options?: KeyStateAttachOptions): () => void;
+}
+declare function createKeyState(): KeyState;
+
+interface UseKeyStateOptions extends KeyStateAttachOptions {
+    /** Scope the poll to keys typed while focus is inside this element — a
+     *  canvas host, say. Omit it to poll the whole window. */
+    target?: RefObject<HTMLElement | null>;
+}
+/** A {@link KeyState} attached for the component's lifetime. Its identity is
+ *  stable; read it from a frame loop rather than rendering from it. */
+declare function useKeyState(options?: UseKeyStateOptions): KeyState;
+
 /**
  * Project an action's keyboard bindings into the shape a shortcut chip
  * renders from (`formatShortcut` / `formatShortcutParts` in
@@ -2678,8 +2708,6 @@ interface UseStandardActionsOptions {
     scene?: DepSchema['scene'];
     /** Undo/redo history bound to the current scene. */
     history?: DepSchema['history'];
-    /** Canvas pointer position in world space. */
-    pointer?: DepSchema['pointer'];
     /** Currently active tool id + hotkey-hold stack. */
     activeTool?: DepSchema['activeTool'];
     /**
@@ -2929,7 +2957,7 @@ interface UseKeybindingsOptions {
     /**
      * Gate for keyboard tool activation: return false to refuse a tool the
      * active mode doesn't allow. `<SceneCanvas>` wires this from
-     * `getActiveMode` + each tool's `capabilities`, using the same predicate
+     * `getActiveMode` + each tool's `eligibility.capabilities`, using the same predicate
      * `ToolPalette` uses to grey a button out — so the grey-out becomes a
      * guarantee rather than a hint.
      *
@@ -2969,6 +2997,10 @@ interface ToolPrefBase<K extends string, Value> {
      *  on one row labeled with the `pair` string (e.g. `'Position'` for
      *  `pose.x` / `pose.y`). Purely presentational. */
     pair?: string;
+    /** The label a surface with no room for `name` shows instead — a strip of
+     *  controls on one line, or a segment in a `pair`ed row. `name` stays the
+     *  accessible name, so this abbreviates without costing anything. */
+    short?: string;
 }
 /** How a schema-driven UI should present a number pref. */
 type ToolPrefNumberControl = 'input' | 'slider';
@@ -2989,10 +3021,13 @@ interface ToolPrefNumberUnit {
     fromDisplay: (display: number) => number;
     /** Shown after the input, e.g. `'°'`. */
     suffix?: string;
-    /** Suffixes a person may type, each mapped to the factor that turns a
+    /** Suffixes a person may type, each mapped to the scale that turns a
      *  number in that unit into a display number: `{ mm: 0.1, cm: 1 }` for a
-     *  field showing centimeters. */
-    accepts?: Readonly<Record<string, number>>;
+     *  field showing centimeters. A unit that disagrees with the display unit
+     *  about zero carries an `offset` as well. */
+    accepts?: Readonly<Record<string, UnitEntry>>;
+    /** The stored value as display text, suffix included. */
+    format?: (stored: number) => string;
 }
 /**
  * A display unit built from a {@link UnitSystem}: values are stored in the
@@ -3017,9 +3052,6 @@ interface ToolPrefNumber extends ToolPrefBase<'number', number> {
 /** An on/off pref. */
 interface ToolPrefBoolean extends ToolPrefBase<'boolean', boolean> {
     control?: ToolPrefBooleanControl;
-    /** The label a `toggle` shows, since a `pair`ed row is named by the pair
-     *  rather than by the leaf. `name` stays the accessible name. */
-    short?: string;
 }
 /** A free-text pref. */
 interface ToolPrefString extends ToolPrefBase<'string', string> {
@@ -3365,7 +3397,7 @@ interface UseSelectToolOptions<TPose> {
     reparentOnDrop?: 'off' | 'top' | 'above';
 }
 /** Intersection of the move + area-select adapter interfaces.
- *  Resize / rotate adapters moved to `useResizeTool` / `useRotateTool`. */
+ *  Resize and rotate run through `resizeAction` / `rotateAction`. */
 type SelectAdapter<TNode extends {
     id: string;
 }, TPose> = MoveAdapter<TNode, TPose> & AreaSelectAdapter;
@@ -3384,53 +3416,6 @@ declare function useSelectTool<TNode extends {
     id: string;
 }, TPose>(adapter: SelectAdapter<TNode, TPose>, options: UseSelectToolOptions<TPose>): Tool<null>;
 
-/** Options for `useRotateTool` — mostly the placement of the rotation
- *  handle's hover band. */
-interface UseRotateToolOptions<TNode extends {
-    id: string;
-}, _TPose> {
-    /** Legacy `useRotate` options surface. Ignored now —
-     *  rotation flows through `rotateAction`, whose option surface is
-     *  configured at the action-registration level. Kept on the type for
-     *  backwards-compat with consumers (notably `SceneCanvas`'s
-     *  `rotateOptions`) that still pass a value. */
-    rotate?: unknown;
-    /** Minimum thickness of the rotate band outside the selection AABB, in
-     *  screen px. Defaults to {@link ROTATION_HANDLE_BASE_PX}; `<SceneCanvas>`
-     *  passes the device-scaled value. */
-    rotationHandleDistance?: number;
-    /** World-space bounds lookup. Required for the rotation affordance hit-test
-     *  in consumers that wire a `boundsOf` source separately from the
-     *  ChromeState-driven affordance pipeline. Retained for parity with
-     *  `useResizeTool`; the rotation affordance itself reads bounds via the
-     *  dispatcher-supplied ChromeState. */
-    boundsOf?: (id: string) => Bounds | null;
-    /** Live selection ids — retained for parity with `useResizeTool` /
-     *  `useSelectTool` option surfaces. The dispatcher-path `rotateAction`
-     *  reads selection from its own `InvocationCtx`, so this tool no longer
-     *  forwards selection into the rotation gesture itself. */
-    getSelection?: () => string[];
-    /** Node lookup — retained for parity with `useSelectTool` and for future
-     *  ghost-render wiring. The rotation affordance does not need it directly. */
-    getNode?: (id: string) => TNode | null;
-}
-/** Rotate-only Tool. Owns the rotation-handle affordance render layer; the
- *  gesture itself flows through `rotateAction` (declarative binding in
- *  `useSelectTool.bindings` keyed on the `rotate-handle` affordance hit
- *  kind) → dispatcher → preview surface → scene commit.
- *
- *  The legacy `useRotate` hook is removed — the affordance no
- *  longer wraps each region's drag channel; the unwrapped affordance is
- *  used purely for the paint + hit-test surface. The dispatcher's
- *  `affordanceAt` pipeline produces `rotate-handle` hits independently
- *  (see `src/canvas/affordanceAt.ts`), which the `useSelectTool` rotate
- *  binding then routes to `rotateAction`. */
-declare function useRotateTool<TNode extends {
-    id: string;
-}, _TPose>(adapter: RotateAdapter<TNode, _TPose>, options: UseRotateToolOptions<TNode, _TPose>): Tool<unknown> & {
-    overlay: RenderLayer<unknown>;
-};
-
 /**
  * Pick the topmost id from a body-hit list, using whatever signal the
  * adapter exposes.
@@ -3524,6 +3509,120 @@ declare function useHandTool(opts?: UseHandToolOptions): Tool<HandScratch | null
  *  `src/interactions/actions/defaults/enterTextEdit.ts`). Custom node
  *  factories and hit gating belong on those deps, not on the tool. */
 declare function useTextTool(): Tool<undefined>;
+declare namespace useTextTool {
+    var options: {
+        name: string;
+        description: string;
+        children: {
+            bold: {
+                readonly kind: "boolean";
+                readonly name: string;
+                readonly description: `${string} for the characters in the range.`;
+                readonly icon: string;
+                readonly control: "toggle";
+                readonly pair: "Character style";
+                readonly default: false;
+            };
+            italic: {
+                readonly kind: "boolean";
+                readonly name: string;
+                readonly description: `${string} for the characters in the range.`;
+                readonly icon: string;
+                readonly control: "toggle";
+                readonly pair: "Character style";
+                readonly default: false;
+            };
+            underline: {
+                readonly kind: "boolean";
+                readonly name: string;
+                readonly description: `${string} for the characters in the range.`;
+                readonly icon: string;
+                readonly control: "toggle";
+                readonly pair: "Character style";
+                readonly default: false;
+            };
+            strikethrough: {
+                readonly kind: "boolean";
+                readonly name: string;
+                readonly description: `${string} for the characters in the range.`;
+                readonly icon: string;
+                readonly control: "toggle";
+                readonly pair: "Character style";
+                readonly default: false;
+            };
+            overline: {
+                readonly kind: "boolean";
+                readonly name: string;
+                readonly description: `${string} for the characters in the range.`;
+                readonly icon: string;
+                readonly control: "toggle";
+                readonly pair: "Character style";
+                readonly default: false;
+            };
+            script: {
+                kind: string;
+                name: string;
+                description: string;
+                default: undefined;
+            };
+            fontFamily: {
+                kind: string;
+                name: string;
+                description: string;
+                default: undefined;
+            };
+            fontSize: {
+                kind: "number";
+                name: string;
+                description: string;
+                min: number;
+                step: number;
+                default: number;
+            };
+            letterSpacing: {
+                kind: "number";
+                name: string;
+                short: string;
+                description: string;
+                step: number;
+                default: number;
+            };
+            baselineShift: {
+                kind: "number";
+                name: string;
+                short: string;
+                description: string;
+                step: number;
+                unit: {
+                    toDisplay: (v: number) => number;
+                    fromDisplay: (v: number) => number;
+                    suffix: string;
+                };
+                default: number;
+            };
+            fontScale: {
+                kind: "number";
+                name: string;
+                description: string;
+                min: number;
+                step: number;
+                unit: {
+                    toDisplay: (v: number) => number;
+                    fromDisplay: (v: number) => number;
+                    suffix: string;
+                };
+                default: number;
+            };
+            fill: {
+                kind: "color";
+                name: string;
+                description: string;
+                alpha: true;
+                default: string;
+            };
+        };
+    };
+}
 
 /**
  * In-progress pen anchor. `outHandle` is set when the anchor was placed via
@@ -3558,9 +3657,11 @@ interface PenSubpath {
  * so click-by-click state survives gesture boundaries and the preview layer
  * can read the same object.
  *
- * ## The pen creates paths and nothing else
+ * ## The pen draws paths; it does not reshape them
  *
- * Reshaping an existing path is anchor editing: double-click a path to
+ * It draws new nodes, and extends an existing node's open subpath from one
+ * of its ends (see `continuing`). Reshaping an existing path is anchor
+ * editing: double-click a path to
  * enter edit mode, then use the `editAnchors` / `insertPathAnchor` /
  * `nudgeAnchors` / `deleteAnchors` / `marqueeAnchors` / `cutPathAtAnchor`
  * Actions.
@@ -3583,6 +3684,22 @@ interface PenScratch {
     } | null;
     draggingHandleAt: number | null;
     closeHintActive: boolean;
+    /** Set while the pen is extending an existing node's open subpath rather
+     *  than drawing a new node. `current` then starts as that subpath (turned
+     *  around when it was picked up by its first anchor), and the commit
+     *  writes back into the node. */
+    continuing: PenContinuation | null;
+}
+/** Which existing subpath the pen picked up, and the node's path as it was. */
+interface PenContinuation {
+    id: string;
+    /** Index of the picked-up subpath within `original`. */
+    sub: number;
+    /** True when it was picked up by its first anchor, so `current` runs
+     *  backwards and is turned around again on commit. */
+    reversed: boolean;
+    /** The node's path in world coords at pick-up. */
+    original: PolygonPath;
 }
 /** Options for `usePenTool`: how a finished path becomes a pose, where it is
  *  inserted, and when a closed subpath commits. */
@@ -3608,6 +3725,10 @@ interface UsePenToolOptions<TPose> {
      *  Measured as a screen-space circle, so it stays round under non-uniform
      *  zoom; aligns with `useSelectTool.handleHitRadius`. */
     closeHitRadius?: number;
+    /** Screen-px radius within which a placed anchor lands exactly on an
+     *  existing path's anchor. Default `8`; `0` turns it off. Takes precedence
+     *  over `snapPoint`, which applies only when no anchor is in range. */
+    anchorSnapRadius?: number;
     /** Optional point snapper applied to every world-space coordinate the
      *  pen records or previews — anchor positions (corner clicks, smooth-
      *  drag base point), the rubber-band cursor, and the outgoing-handle
@@ -3874,7 +3995,7 @@ declare function useStarTool<TNode extends {
  *  array to `insertAction`, which forwards it as the `pencil` insert
  *  extras' `samples`. A consumer that wants pressure-driven
  *  `Stroke.vertexWidths` reads it off the samples in its own `insert` dep
- *  (`useDepSource('insert', …)`) — see `apps/site/demos/VertexWidthsDemo.tsx`.
+ *  (`useDepSource('insert', …)`) — see `apps/site/demos/StrokeAndFillDemo.tsx`.
  */
 interface PencilPoint {
     x: number;
@@ -4102,8 +4223,8 @@ declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: C
  * Sources are passed as plain getters / values rather than the live
  * objects they come from. This keeps `chrome-caps` from depending on
  * React, the dispatcher's concrete type, or `ChromeState`'s bounds
- * machinery — the same builder works from a test harness, a Storybook
- * fixture, or `<SceneCanvas>`.
+ * machinery — the same builder works from a test harness, a forge
+ * story, or `<SceneCanvas>`.
  */
 
 /** The pieces of live canvas state a `ChromeCtx` is assembled from. */
@@ -5085,6 +5206,18 @@ interface SceneSlotConfig<TNode extends {
      * The move-overlay ghost (drag preview) is not post-processed.
      */
     postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];
+    /**
+     * Drop commands that cannot reach the view before they reach the renderer,
+     * so an off-screen node costs its painter and nothing after. Applied last,
+     * after `postProcess`, to the `dims` rectangle under `view`; see
+     * `cullDrawCommands` for what it can and cannot bound.
+     *
+     * Off by default because it makes the layer's world-space output depend on
+     * the view: anything that draws this layer once and shows the result under
+     * another view — a cache keyed without `view`, a consumer re-wrapping the
+     * commands — would show the first view's cull.
+     */
+    cull?: boolean;
 }
 /** Selection-overlay slot config — passed through to `createSelectionOverlayLayer`,
  *  minus the `getSelection`/`getPose` Canvas wires automatically. */
@@ -5156,6 +5289,12 @@ interface CanvasProps<TNode extends {
      *  same contract the headless `renderSceneToPixels` path follows (that
      *  path never reads ambient density at all). */
     dpr?: number;
+    /** Flatness tolerance for curve tessellation, in world units. Forwarded to
+     *  `WeaselRendererOptions.flattenTolerance`. Leave unset for the cached
+     *  default (`DEFAULT_FLATTEN_TOLERANCE`, 0.5); a scene whose world unit is
+     *  not a pixel — feet, inches, millimetres — needs a value scaled to its
+     *  unit or sub-unit curves flatten to a handful of vertices. */
+    flattenTolerance?: number;
     /** The version of whatever content this canvas draws, sampled at paint time
      *  and reported by {@link CanvasExtensionApi.getPaintedVersion}.
      *  `<SceneCanvas>` wires this to `scene.getVersion`. Chrome that must not
@@ -5491,6 +5630,8 @@ type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node$
     setSelection(ids: string[]): void;
     insertNode(node: Node$1<TData, TLayer, TPose>, index?: number): void;
     removeNode(id: string): void;
+    /** Replace a node's `data` — what a `setData` op writes through. */
+    setData(id: string, data: TData): void;
     getRemovalClosure(ids: readonly string[]): string[];
     applyOps(ops: Op[], label?: string): void;
     snapshotSelection(ids: string[]): ClipboardSnapshot;
@@ -5869,7 +6010,7 @@ declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node$
 declare const DEFAULT_HANDLE_SIZE: 8;
 /** Built-in tool ids that aren't shape tools — the ones with no entry in
  *  the `core/shapeKinds` table. */
-declare const NON_SHAPE_BUILTIN_TOOLS: readonly ["select", "rotate", "hand"];
+declare const NON_SHAPE_BUILTIN_TOOLS: readonly ["select", "hand"];
 /** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop
  *  is supplied. Pass a subset via `defaultTools` to slim the registered set. */
 type BuiltinToolId = (typeof NON_SHAPE_BUILTIN_TOOLS)[number] | BuiltinShapeToolId;
@@ -6079,7 +6220,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      *  into the built-in registry on top of whatever `defaultTools` /
      *  `toolBundle` already selected.
      *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,
-     *      `'rotate'`, …) even when it's outside the active tier — useful
+     *      `'hand'`, …) even when it's outside the active tier — useful
      *      for `toolBundle: 'minimal'` + `tools={{ pen: true }}`. Unknown
      *      built-in ids warn in dev and are ignored.
      *    - `AnyTool` adds a new id or replaces an existing one
@@ -6125,8 +6266,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
     onToolsCreated?: (tools: ToolsApi) => void;
     /**
      * Named preset for the built-in tool set: `'minimal'` (select + hand),
-     * `'standard'` (select + rotate + hand + rect + ellipse +
-     * line + pencil), or `'exhaustive'` (every built-in including polygon,
+     * `'standard'` (select + hand + rect + ellipse + line), or `'exhaustive'` (every built-in including polygon,
      * star, lasso, text, clone). When set, defines the starting set;
      * `defaultTools` (if also passed) overrides it. Ignored when the
      * consumer supplies their own `tools` prop.
@@ -6134,7 +6274,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
     toolBundle?: ToolBundle;
     /**
      * Which built-in tools SceneCanvas registers in its internal `useTools`.
-     * Default: `['select', 'rotate']` (plus `'hand'` when the
+     * Default: `['select']` (plus `'hand'` when the
      * `viewport` feature is on). Pass a smaller array to slim — e.g.
      * `['select']` for move-only. Wins over `toolBundle` when both are
      * passed. Ignored when the consumer supplies their own `tools` prop.
@@ -6326,6 +6466,12 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * to `<Canvas shaders={...} />`. See `CanvasProps.shaders` for details.
      */
     shaders?: ShaderProgramHandle[];
+    /**
+     * Flatness tolerance for curve tessellation, in world units. Forwarded
+     * directly to `<Canvas flattenTolerance={...} />`. See
+     * `CanvasProps.flattenTolerance` for details.
+     */
+    flattenTolerance?: number;
     /**
      * FillStyle applied to the full canvas behind the scene. Accepts the kit's
      * `FillStyle` union (solid / pattern / linear-gradient / radial-gradient /
@@ -7173,12 +7319,15 @@ declare function derivedPose<TPose>(source: PoseSource<TPose>, node: PosedNode<T
 declare function derivedDepOf<TPose>(source: PoseSource<TPose>, id: NodeId): DerivedDep<TPose> | undefined;
 /**
  * The pose the *document* says `node` is at: derived when it derives, else
- * authored. `effectivePose` minus the override step.
+ * authored. `effectivePose` minus the override step, at every link of the
+ * dependency chain — a derived node's document pose holds still while
+ * something it derives from is being dragged.
  *
  * For a reader that must not see an in-flight gesture — an action capturing
- * the `from` of a transform op, a placement computed against a sibling. A
- * derived pose belongs here and an override does not: derivation is what the
- * document means, an override is what one gesture is currently showing.
+ * the `from` of a transform op, a placement computed against a sibling, the
+ * minimap's framing. A derived pose belongs here and an override does not:
+ * derivation is what the document means, an override is what one gesture is
+ * currently showing.
  */
 declare function documentPose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
 /**
@@ -7520,6 +7669,58 @@ 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;
@@ -8189,6 +8390,12 @@ interface TextEditScreenPose {
     fontSize: number;
     /** Effective on-screen line height multiplier (defaults to style.lineHeight). */
     lineHeight?: number;
+    /**
+     * Where the text sits within `height`, as the canvas places it. `'center'`
+     * and `'bottom'` size the overlay to its own content and offset it by the
+     * slack, re-measured as typing changes the line count. Default `'top'`.
+     */
+    verticalAlign?: TextVerticalAlign;
     /**
      * CSS scale applied to the overlay (`transform: scale(zoom)`, anchored at
      * its top-left). Every other size on this pose, and every typographic
@@ -8500,6 +8707,20 @@ interface UseSceneTextEditReturn extends UseTextEditReturn {
  *  over the node being edited and writes the result back as an undoable op. */
 declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends string, TPose extends RectPose = RectPose>(scene: Scene<TData, TLayer, TPose>, container: HTMLElement | null, options?: UseSceneTextEditOptions<TData>): UseSceneTextEditReturn;
 
+/**
+ * What is actually rendering across a range: `range` (from `styleAtRange`,
+ * or `useTextEdit`'s `rangeStyle`) resolved against the node's own `style`
+ * and `paint`, as the canvas resolves runs. `null` reads the node alone.
+ *
+ * Flags are additive — a run can turn one on, never off — so a node flag
+ * makes the flag `true` across the range, `MIXED` runs included. Every other
+ * key is the run's value where the range sets one, otherwise the node's.
+ * The node level is resolved first, so the result has a value for every
+ * key but the run-only ones, and for `fill` unless the node is unfilled.
+ * A node's weight reads as bold at 600 and above, as `nodeHasFlag` does.
+ */
+declare function effectiveRangeStyle(range: RangeStyle | null, style: TextStyle | undefined, paint?: TextPaint): RangeStyle;
+
 /**
  * Build a `TextDrawCommand`. `textCommandFromPose` is the command for a text
  * node — what `kit:text` and `createTextLayer` both emit. `textCommand` takes
@@ -8512,20 +8733,25 @@ declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends
  *
  * `paint` is the node's `data.fill` / `data.stroke`. A caller with no node —
  * a HUD widget, a debug overlay — states its color on the run instead.
+ *
+ * `scale` is the view scale a `{ px }` `fontSize` or `letterSpacing` resolves
+ * against — for a world-space layer, the mean of `view.scale.x` and
+ * `view.scale.y`. It has to be applied here and not at draw time, because a
+ * screen-pixel size moves the glyph advances and so the wrap points.
  */
 
-declare function textCommandFromRuns(x: number, y: number, runs: readonly StyledRun[], style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number): DrawCommand;
+declare function textCommandFromRuns(x: number, y: number, runs: readonly StyledRun[], style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number, scale?: number): DrawCommand;
 /** Build a draw command for a single unstyled string. Text is laid out with
  *  the registered font's metrics, wrapped at `maxWidth`, aligned across
  *  `width` (default `maxWidth`) and within `height` when `verticalAlign` is
  *  given. */
-declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number): DrawCommand;
+declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign, paint?: TextPaint, width?: number, scale?: number): DrawCommand;
 /**
  * The draw command for a text pose. Its wrap width, alignment box and runs
  * come from `textPoseLayoutInput`, so the renderer lays it out into exactly
  * the lines `layoutTextPose` reports for the same pose.
  */
-declare function textCommandFromPose(pose: TextPose): TextDrawCommand;
+declare function textCommandFromPose(pose: TextPose, scale?: number): TextDrawCommand;
 
 /**
  * Pure DOM ↔ `StyledRun[]` serializers for the contenteditable overlay
@@ -8594,6 +8820,178 @@ interface TilePatternOpts {
  */
 declare function createTilePattern(opts: TilePatternOpts): TextureHandle | null;
 
+/**
+ * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as
+ * pure geometry.
+ *
+ * A patch is a curved quadrilateral: four cubic Bézier edges and a color at
+ * each corner. The interior is what the edges imply — a Coons patch reads it
+ * off the boundary alone; a tensor patch adds four interior control points
+ * that pull it around. Both evaluate at a `(u, v)` in the unit square, which
+ * is what lets the renderer subdivide a patch into as many triangles as it
+ * wants without the patch knowing.
+ *
+ * Nothing here touches GL, a color string, or a scene. `evalPatch` is the
+ * whole contract.
+ */
+/** A point in the patch's own space. */
+interface MeshPoint {
+    x: number;
+    y: number;
+}
+/**
+ * One patch.
+ *
+ * `points` walks the boundary: corner 0, the two control points of the edge
+ * leaving it, corner 1, its two, and so on — twelve points, ending with the
+ * two controls that return to corner 0. A tensor patch appends its four
+ * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the
+ * bicubic control net, which is PDF's own order.
+ *
+ * Twelve points is a Coons patch and sixteen is a tensor patch; there is no
+ * flag, because the count already says which it is.
+ *
+ * `colors` are the corner colors in the same walk order, as whatever color
+ * form the caller resolves — the renderer hands premultiplied RGBA in, the
+ * serializer hands CSS strings.
+ */
+interface MeshPatch<TColor = string> {
+    points: readonly MeshPoint[];
+    colors: readonly [TColor, TColor, TColor, TColor];
+}
+/** Corner `i` of the boundary walk. */
+declare function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint;
+/** `true` when the patch carries the four interior points a tensor patch adds. */
+declare function isTensorPatch(patch: MeshPatch<unknown>): boolean;
+/** A patch is twelve boundary points, or sixteen with the interior. Anything
+ *  else cannot be evaluated, and saying so here beats painting nonsense. */
+declare function isValidPatch(patch: MeshPatch<unknown>): boolean;
+/**
+ * The patch surface at `(u, v)`, both in `0..1`.
+ *
+ * `u` runs along the edge leaving corner 0 and `v` along the edge leaving
+ * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and
+ * `(0,1)` corner 3 — the same walk `colors` is in.
+ */
+declare function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint;
+/**
+ * The four corner weights at `(u, v)` — bilinear, in the corner walk order.
+ *
+ * Color is separate from position on purpose: it interpolates in whatever
+ * space the caller chose, which is not a thing the surface can do for it.
+ */
+declare function cornerWeights(u: number, v: number): [number, number, number, number];
+/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone
+ *  bound a Bézier but not tightly, and a mesh paint is baked into a texture
+ *  sized from this — a loose box wastes texels on every side. */
+declare function patchBounds(patch: MeshPatch<unknown>, steps?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+/**
+ * The `mesh-gradient` paint kind — PDF's shading types 6 and 7 as a registered
+ * paint.
+ *
+ * A mesh gradient is a set of curved quadrilateral patches, each with a color
+ * at every corner. It is the paint SVG tried to standardize as
+ * `<meshgradient>` and abandoned, and the one PDF has had since 1993; what it
+ * buys over the three gradients is a color field that bends, so a highlight
+ * can follow a form instead of running straight across it.
+ *
+ * This is a registered kind rather than a sixth branch in the renderer, and
+ * deliberately: it uses only the slots `registerPaintKind` gives a consumer, so
+ * whatever it can do, a consumer's own kind can do too. Its one concession is
+ * living in this package, because that is where the shader registry is.
+ *
+ * `docs/proposals/2026-09-17-paint-kinds-beyond-svg.md` is the design.
+ */
+
+/**
+ * A mesh gradient paint.
+ *
+ * `patches` are in the space `units` names, the same way a gradient's
+ * geometry is — under `'bounds'` every point is a fraction of the painted
+ * node's box, which is what lets the paint survive a resize.
+ *
+ * `interpolate` is the space corner colors blend through, matching the three
+ * gradients. It is more visible here than there: a mesh blends in two
+ * directions at once, so an sRGB blend's muddy middle covers area rather than
+ * a line.
+ */
+interface MeshGradientFill {
+    fill: 'mesh-gradient';
+    patches: MeshPatch[];
+    units?: GradientUnits;
+    interpolate?: ColorSpace;
+    opacity?: number;
+}
+/** The kind's id, as `FillStyle['fill']` carries it. */
+declare const MESH_GRADIENT_KIND = "mesh-gradient";
+/** A mesh paint, narrowed. */
+declare function isMeshGradientFill(fill: FillStyle | null | undefined): fill is FillStyle & MeshGradientFill;
+/** A one-patch square covering the unit box, its four corners four readings of
+ *  `color` — a mesh seeded from a solid has to show *something* curved, or
+ *  switching kind looks like nothing happened. */
+declare function seedMeshPatch(color: string): MeshGradientFill;
+/**
+ * The `<defs>` entry for a mesh paint, in weasel's own namespace.
+ *
+ * Not SVG's abandoned `<meshgradient>`: that vocabulary only reaches Coons
+ * patches, shares patch edges implicitly — a reader that gets the sharing
+ * wrong tears the surface rather than failing outright — and has exactly one
+ * implementation in the world. Ours writes every patch's points in full.
+ * `@weasel-js/svg` puts the paint fallback color beside the reference, so a
+ * foreign renderer paints flat instead of nothing.
+ */
+declare function meshGradientXml(id: string, mesh: MeshGradientFill): string;
+
+/**
+ * A mesh paint baked into one RGBA bitmap.
+ *
+ * A patch is a surface over `(u, v)`, but a paint has to answer "what color is
+ * this fragment", which is the inverse question — and inverting a bicubic is
+ * Newton iteration per fragment. Every renderer that draws these instead
+ * subdivides the patch into small quads and rasterizes them forward, which is
+ * what this does, once per paint, into a texture the shader then samples. The
+ * cost is a texture and a resolution; the gain is that the paint composes with
+ * every fill the renderer already knows how to draw, clipping included.
+ *
+ * The bitmap is straight (non-premultiplied) RGBA, matching the ramp atlas;
+ * the fragment shader premultiplies.
+ */
+
+/** Texels on a side of a baked mesh. A mesh gradient is smooth by
+ *  construction, so this is about how large it is drawn, not how detailed it
+ *  is; 256 covers a paint at typical shape sizes without a visible step. */
+declare const MESH_BAKE_SIZE = 256;
+/** The box a bake covers, in the paint's own space. */
+interface MeshBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface BakedMesh {
+    /** `MESH_BAKE_SIZE` square, straight RGBA. */
+    pixels: Uint8ClampedArray;
+    size: number;
+    /** Where the bitmap sits in paint space, which is what the shader maps a
+     *  fragment through. */
+    box: MeshBox;
+}
+/** The union of every patch's bounds, or `null` when nothing is drawable. */
+declare function meshBounds(patches: readonly MeshPatch[]): MeshBox | null;
+/**
+ * Rasterize `patches` into a square bitmap covering their union.
+ *
+ * Returns `null` when no patch is drawable, which is the caller's cue to paint
+ * nothing rather than a blank square.
+ */
+declare function bakeMesh(patches: readonly MeshPatch[], space?: ColorSpace, size?: number): BakedMesh | null;
+
 /**
  * `TilePatternSpec` → `TextureHandle`. The bridge between the serializable
  * half of a pattern paint and the GL texture that paints it.
@@ -8640,7 +9038,7 @@ declare function isGradientFill(fill: FillStyle | null | undefined): fill is Gra
  *
  * Returns transparent black for an empty list.
  */
-declare function sampleGradientStops(stops: readonly GradStop[], t: number): string;
+declare function sampleGradientStops(stops: readonly GradStop[], t: number, space?: ColorSpace): string;
 /**
  * Retarget a gradient to a different kind, preserving stops, `units` and
  * `opacity`, and carrying the geometry across as faithfully as the kinds
@@ -9064,86 +9462,38 @@ type DerivePose<TPose> = (node: {
 declare function unionOfChildrenVia<TPose>(descriptor: PoseDescriptor<TPose>): DerivePose<TPose>;
 
 /**
- * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
- * encoding behind move/line/curve/close calls and a final `build()`. Use
- * this to construct paths in tests and demos; production callers that need
- * to mutate large paths in place should reach for the raw arrays directly.
+ * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.
  *
- * Numeric capacity grows by doubling — typical for amortized O(1) push.
+ * These don't expand the `DrawCommand` union — they all return `PolygonPath`,
+ * which `PathDrawCommand.path` already accepts. The wins are:
+ *   - One place owns the math (`circlePath`'s segment loop, `squarePath`'s
+ *     corner unrolling), so consumers don't reinvent it.
+ *   - Default segment counts can be tuned in one place if "circles look
+ *     facety" feedback ever surfaces.
  *
- * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common
- * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.
+ * Not appropriate for *user-drawn* shapes (those have a pose and live in the
+ * scene). Use these for selection chrome, anchor markers, rubber-band rects,
+ * and similar transient/decorative geometry.
  */
 
-/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */
-declare class PathBuilder {
-    private cmds;
-    private xs;
-    private fillRule;
-    /** Seed a builder with an existing `PolygonPath`. Useful for extending
-     *  an in-flight path with another segment (e.g. appending a cubic to
-     *  the end of a curve in response to a user action) without hand-
-     *  reaching into the `commands` / `coords` typed arrays.
-     *
-     *  ```ts
-     *  const next = PathBuilder.fromPath(current).curveTo(...).build();
-     *  ```
-     */
-    static fromPath(path: PolygonPath): PathBuilder;
-    setFillRule(rule: PathFillRule): this;
-    moveTo(x: number, y: number): this;
-    lineTo(x: number, y: number): this;
-    /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
-    curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
-    /** Quadratic bezier to (x, y) with control point (x1, y1). */
-    quadTo(x1: number, y1: number, x: number, y: number): this;
-    close(): this;
-    build(): PolygonPath;
-}
-/** Construct a `RectPath` (the fast-path subtype). */
-declare function rectPath(x: number, y: number, width: number, height: number): RectPath;
-/** Build an open polyline from a flat list of points — the same geometry as
- *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a
- *  measurement line want this; a region wants the closed one. */
-declare function polylineFromPoints(points: readonly {
-    x: number;
-    y: number;
-}[]): PolygonPath | RectPath;
-/** Build a closed polygon from a flat list of points. */
-declare function polygonFromPoints(points: readonly {
-    x: number;
-    y: number;
-}[], opts?: {
-    fillRule?: PathFillRule;
-}): PolygonPath;
-/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.
- *  Matches the geometry `useEllipseTool`'s overlay paints. */
-declare function ellipsePath(bounds: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}): PolygonPath;
-/** Closed regular n-gon centered at `center`, circumscribed by `radius`.
- *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */
-declare function regularPolygonPath(center: {
-    x: number;
-    y: number;
-}, radius: number, sides: number, rotation?: number): PolygonPath;
-/** Closed n-pointed star centered at `center`, alternating `outerRadius` and
- *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */
-declare function starPath(center: {
-    x: number;
-    y: number;
-}, outerRadius: number, points?: number, innerRadius?: number, rotation?: number): PolygonPath;
-/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */
-declare function linePath(a: {
-    x: number;
-    y: number;
-}, b: {
-    x: number;
-    y: number;
-}): PolygonPath;
+/**
+ * N-segment polygon approximation of a circle. Default 32 segments → max
+ * radial deviation of ≈0.005·r (≈0.05 px at r=10). Bump higher for large
+ * filled circles where the facets become visible; the default is fine for
+ * the handle-dot / anchor-dot scale we use everywhere.
+ */
+declare function circlePath(cx: number, cy: number, r: number, segments?: number): PolygonPath;
+/** Axis-aligned square centred at (cx, cy) with side length `size`. */
+declare function squarePath(cx: number, cy: number, size: number): PolygonPath;
+/** Axis-aligned rectangle. Top-left at (x, y), width/height as given. */
+declare function rectMarkerPath(x: number, y: number, width: number, height: number): PolygonPath;
+/**
+ * Axis-aligned rounded rectangle. Top-left at (x, y); `r` is clamped to half
+ * the shorter side. Each corner is `cornerSamples` line segments, matching
+ * `circlePath`'s polygonal approximation — the default 8 gives the same
+ * angular resolution as `circlePath`'s 32.
+ */
+declare function roundRectPath(x: number, y: number, width: number, height: number, r: number, cornerSamples?: number): PolygonPath;
 
 /**
  * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the
@@ -9239,21 +9589,6 @@ interface PointInPathOptions {
 /** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
 declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
 
-/**
- * Polygon-vs-axis-aligned-rect tests. Pure functions; no React/kit deps.
- *
- * `polygon` is a closed polyline given as an ordered vertex array; the
- * closing edge from `polygon[N-1]` to `polygon[0]` is implicit. Even-odd fill
- * rule, and one contour only — a path with holes or curves goes through
- * `pathHitTest`, which reads its `fillRule`.
- */
-
-/** A 2D point or vector. */
-interface Vec2 {
-    x: number;
-    y: number;
-}
-
 /**
  * Path-vs-geometry hit-test helpers. Five pure functions covering all
  * combinations of path-vs-point, path-vs-rect, and path-vs-polygon.
@@ -9272,9 +9607,9 @@ declare function pathContainsRect(path: Path, rect: Rect, opts?: PointInPathOpti
 /** Returns true if `rect` overlaps (intersects or contains) `path`. */
 declare function pathIntersectsRect(path: Path, rect: Rect, opts?: PointInPathOptions): boolean;
 /** Returns true if every vertex of `polygon` lies inside `path`. */
-declare function pathContainsPolygon(path: Path, polygon: readonly Vec2[], opts?: PointInPathOptions): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Point2[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[], opts?: PointInPathOptions): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Point2[], opts?: PointInPathOptions): boolean;
 
 /**
  * Pure-geometry distance from a point to a path's boundary (stroke), with
@@ -9298,35 +9633,6 @@ declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[], opt
  *  combine with `pathContainsPoint` at the call site. */
 declare function pathDistanceToPoint(path: Path, px: number, py: number): number;
 
-/**
- * A station along a path: where it is at a fraction of its length, and which
- * way it is heading there.
- *
- * For anything positioned *along* geometry rather than beside it — a label on a
- * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
- * flattened first, so the fraction is arc length along the drawn shape rather
- * than a curve parameter, which is what makes 0.5 look like the middle.
- */
-
-interface PathStation {
-    point: Vec2;
-    /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Vec2;
-}
-interface PointAlongPathOptions {
-    /** Curve flattening tolerance, in world units. Default 0.5. */
-    flattenTolerance?: number;
-}
-/**
- * Where `path` is at `t` of its total length, and its heading there.
- *
- * `t` is clamped to 0..1. Subpaths are measured in order and treated as one
- * run, the way a browser measures a whole `<path>`. Returns `null` for a path
- * with no points at all; a path of zero length answers at its single point,
- * heading along +X.
- */
-declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
-
 /**
  * In-place and copy-out path transforms. Translation is the most common —
  * called every pointermove during a drag — so the polygon variant mutates
@@ -9343,12 +9649,6 @@ declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOpti
  * predictable. Polygon coords are copied into a fresh `Float32Array`.
  */
 declare function translatePath(path: Path, dx: number, dy: number): Path;
-/**
- * Translate a polygon path's coords *in place*. Returns the same
- * `PolygonPath` reference. Use only for transient overlay buffers — never
- * for committed scene state, which must remain immutable for React.
- */
-declare function translatePolygonInPlace(path: PolygonPath, dx: number, dy: number): PolygonPath;
 /**
  * Scale a path's coords so its current AABB maps to `target`. Resize
  * interactions use this to make a polygon follow a corner-handle drag.
@@ -9941,14 +10241,18 @@ interface PaintBindContext {
      * an axis. Nothing the paint draws there means anything, so `bind` should
      * return `null` and draw nothing.
      */
-    spaceInverse(units: GradientUnits | undefined): Mat3$1 | null;
+    spaceInverse(units: GradientUnits | undefined): GlMat3 | null;
     /**
      * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
      * unit, and return the `v` the ramp's own row sits at — every ramp in a
      * frame shares one texture, so a paint must sample at the returned `v` and
      * not at a constant.
+     *
+     * `space` is the blend the stops are baked through, defaulting to `'rgb'`.
+     * It is part of the atlas key, so the same stops under two spaces take two
+     * rows rather than colliding.
      */
-    bindRamp(stops: GradStop[], unit: number): number;
+    bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;
 }
 /**
  * One paint kind.
@@ -9987,7 +10291,15 @@ interface PaintKindEntry {
     inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
     /** The inverse. Required whenever `inPoseFrame` is supplied. */
     toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
-    /** The `<defs>` entry backing a `url(#id)` reference. */
+    /**
+     * The `<defs>` entry backing a `url(#id)` reference.
+     *
+     * SVG has paint servers for two gradients and a pattern and nothing else, so
+     * a kind beyond those has no element to target: write a foreign-namespaced
+     * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever
+     * a document holds such a paint. That package emits the fallback color
+     * beside the reference on its own, from `colorOf`.
+     */
     toSvg?(id: string, fill: FillStyle): string;
 }
 /**
@@ -10559,32 +10871,6 @@ declare function alignInsertBehavior<TPose>(args: AlignmentBehaviorBase): Insert
  *  candidates. The pinned (anchor) edge stays fixed. Publishes the line(s). */
 declare function alignResizeBehavior<TPose extends Bounds>(args: AlignmentBehaviorBase): BoundsConstraint<TPose>;
 
-/** AABB center of an unrotated rect — the canonical rotation pivot. */
-declare function aabbCenter(bounds: Bounds): {
-    x: number;
-    y: number;
-};
-/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */
-declare function rotatePoint(px: number, py: number, cx: number, cy: number, angle: number): {
-    x: number;
-    y: number;
-};
-/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */
-declare function rectCorners(bounds: Bounds): {
-    x: number;
-    y: number;
-}[];
-/** Four corners of a rotated rect (rotation around AABB center), in
- *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */
-declare function rotatedRectCorners(pose: RotatedPose): {
-    x: number;
-    y: number;
-}[];
-/** Hit-test a world point against a rotated rect (rotation around AABB
- *  center). Standard pattern: invert the rotation and AABB-test in the
- *  rect's local frame. */
-declare function pointInRotatedRect(pose: RotatedPose, worldX: number, worldY: number): boolean;
-
 /** Default world-space distance from the rect's top edge to the rotation
  *  handle's center. Matches the demo's visual default; consumers can
  *  override per-call. Unscaled — kit-internal use sites multiply by
@@ -11232,35 +11518,34 @@ interface MomentumOptions {
  */
 declare function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose>;
 
-/** Convert an 8-bit sRGB triple to OKLab. */
-declare function srgbU8ToOklab(r: number, g: number, b: number): [number, number, number];
-/** Convert OKLab back to an 8-bit sRGB triple, clamped into gamut. */
-declare function oklabToSrgbU8(L: number, A: number, B: number): [number, number, number];
-/** Blend two 8-bit sRGB colors through OKLab. Perceptually even, and it does
- *  not pass through the muddy midpoints an sRGB blend produces between
- *  complementary hues. */
-declare function lerpOklab(from: readonly [number, number, number], to: readonly [number, number, number], t: number): [number, number, number];
-/** Convert OKLab (L, a, b) to OKLCh (L, C, h). h is in radians, range [-π, π]. */
-declare function oklabToOklch(L: number, A: number, B: number): [number, number, number];
-/** Convert OKLCh (L, C, h) to OKLab (L, a, b). h is in radians. */
-declare function oklchToOklab(L: number, C: number, h: number): [number, number, number];
-/** Lerp OKLCh values with shortest-arc hue interpolation. Lightness and
- *  chroma lerp linearly. When chroma is near zero on either endpoint, hue
- *  is taken from the other endpoint (avoids hue snap-from-undefined).
- *  h inputs are in radians. */
-declare function lerpOklch(from: readonly [number, number, number], to: readonly [number, number, number], t: number): [number, number, number];
-/** Which space a color blend is computed in. `'rgb'` is cheapest; `'oklab'`
- *  is perceptually even; `'oklch'` additionally travels around the hue wheel
- *  rather than through it. */
-type ColorSpace = 'rgb' | 'oklab' | 'oklch';
-/** Lerp a flat RGBA color array `from` toward `to`. Inputs are 0..1
- *  floats (the renderer's color space); outputs are 0..1 floats too.
- *  Alpha is always linearly lerped; RGB channels are lerped in the
- *  requested color space. OKLab / OKLCh paths bounce through u8 because
- *  the gamma-correction LUT and gamut-clip routines are byte-keyed —
- *  the round-trip is lossy at <1% per channel, well under the visible
- *  threshold for these animations. */
-declare function lerpColorArray(from: readonly number[], to: readonly number[], t: number, space?: ColorSpace): number[];
+/** Most a slewed value may change per second, in its own units, in each
+ *  direction. A direction left out is unlimited: the value jumps to a target
+ *  on that side. `0` holds the value where it is. */
+interface SlewRates {
+    rise?: number;
+    fall?: number;
+}
+/**
+ * One step of a slew limiter: `value` moved toward `target` by at most the
+ * rate for that direction times `dt` seconds, landing on `target` rather than
+ * passing it. A fast `rise` with a slow `fall` is an attack/release envelope.
+ */
+declare function slewToward(value: number, target: number, dt: number, rates: SlewRates): number;
+/** A value that follows `target` at limited rates. Both fields are writable:
+ *  set `target` to steer it, or write `value` to jump it and let it slew on
+ *  from there. Nothing moves until `step` is called. */
+interface Slew {
+    value: number;
+    target: number;
+    /** Advance `dt` seconds and return the new value. */
+    step(dt: number): number;
+}
+/** A stateful {@link slewToward}. `target` defaults to `value`, so a new slew
+ *  is at rest. */
+declare function createSlew(options?: SlewRates & {
+    value?: number;
+    target?: number;
+}): Slew;
 
 /**
  * Color interpolator: receives two flat RGBA float arrays (values in
@@ -11434,6 +11719,77 @@ declare const IDENTITY_JOINT: JointTransform;
  */
 declare function blendPoses(poses: Pose[], weights: number[]): Pose;
 
+/** The part of a scene a rig writes to. */
+interface RigScene<TPose> {
+    get(id: NodeId): {
+        pose: TPose;
+    } | undefined;
+    readonly overrides: PoseOverrides<TPose>;
+    setPose(id: NodeId, pose: TPose): void;
+    batch<T>(label: string, fn: () => T): T;
+}
+interface RigApplyContext<TPose> {
+    joint: string;
+    node: NodeId;
+    /** The node's document pose when the rig was bound — where it sits at the
+     *  bind pose. */
+    rest: TPose;
+    /** The joint's world transform at the bind pose. */
+    restWorld: GlMat3;
+    /** `world * inverse(restWorld)`: the motion since the bind pose, in world
+     *  space. Carrying `rest` by it is what welding the node to the joint means. */
+    fromRest: GlMat3;
+}
+/** Turns a joint's world transform into a pose for one bound node. The only
+ *  part of a rig that knows the scene's pose shape. */
+type RigApply<TPose> = (world: GlMat3, ctx: RigApplyContext<TPose>) => TPose;
+interface BindRigOptions<TPose> {
+    scene: RigScene<TPose>;
+    skeleton: Skeleton;
+    /** Joint name → the node or nodes that ride it. Each node keeps the offset
+     *  from its joint that it has at the bind pose. */
+    bindings: Readonly<Record<string, NodeId | readonly NodeId[]>>;
+    /** Default: {@link rigidRigApply} over `descriptor`. */
+    apply?: RigApply<TPose>;
+    /** The descriptor the default `apply` reads and writes poses through.
+     *  Default `AUTO_POSE_DESCRIPTOR`. */
+    descriptor?: PoseDescriptor<TPose>;
+}
+interface Rig {
+    readonly skeleton: Skeleton;
+    /**
+     * Resolve `pose` and move every bound node to it, through the scene's pose
+     * overrides — no history entry, no document write, no version bump — then
+     * commit them. The per-frame write. `root` places the rig in the world, and
+     * may mirror it.
+     */
+    pose(pose: Pose, root?: GlMat3): void;
+    /** The joint world transforms the last `pose` resolved, root applied. */
+    world(): ReadonlyMap<string, GlMat3>;
+    /** Write the current frame into the bound nodes' document poses as one
+     *  undo entry, and drop the overrides. Later frames stay relative to the
+     *  bind-time rest, so baking does not compound. */
+    bake(label?: string): void;
+    /** Drop the overrides; the nodes show their document poses again until the
+     *  next `pose`. */
+    release(): void;
+}
+/**
+ * Carries a node rigidly with its joint: the rest pose's center moves by
+ * `fromRest`, and its rotation turns with the rest pose's x-axis. Scale in the
+ * joint chain moves positions but not sizes — the pose model holds no shear,
+ * and a sized pose under anisotropic scale would need one. Write an `apply`
+ * that reads `world` to size nodes from joint scale.
+ */
+declare function rigidRigApply<TPose>(descriptor: PoseDescriptor<TPose>): RigApply<TPose>;
+/**
+ * Bind a skeleton's joints to scene nodes. Nodes are written in world space
+ * and the rig resolves its own hierarchy, so bound nodes are best left
+ * unparented, or under containers whose pose does not compose into theirs;
+ * the scene's tree stays free to order and group them for drawing.
+ */
+declare function bindRig<TPose>(options: BindRigOptions<TPose>): Rig;
+
 /**
  * Resolve every joint's world transform by walking the skeleton once and
  * composing each joint onto its already-resolved parent.
@@ -11443,7 +11799,14 @@ declare function blendPoses(poses: Pose[], weights: number[]): Pose;
  * because that failure is otherwise invisible until a limb renders in the wrong
  * place.
  */
-declare function resolveSkeleton(skeleton: Skeleton, pose: Pose): Map<string, Mat3$1>;
+declare function resolveSkeleton(skeleton: Skeleton, pose: Pose): Map<string, GlMat3>;
+
+/**
+ * A {@link Rig} bound for the component's lifetime, its overrides dropped on
+ * unmount. Rebinds — re-reading every node's rest pose — whenever an option's
+ * identity changes, so hoist or memoize `skeleton` and `bindings`.
+ */
+declare function useRig<TPose>(options: BindRigOptions<TPose>): Rig;
 
 /** Snap policy that never picks a target — every drop is rejected, which is
  *  what a free-form container wants. */
@@ -11505,10 +11868,24 @@ interface TileGridOptions<TPose> {
         width: number;
         height: number;
     }, dragged: TPose): TPose;
+    /** Optional: the point that decides which cell a child occupies — a child
+     *  occupies the cell containing it. Default reads `x`/`y` plus half of
+     *  `width`/`height` when the pose has them, which is the center of a
+     *  `RectPose` and the point itself for a point pose. */
+    centerOf?(pose: TPose): {
+        x: number;
+        y: number;
+    };
 }
-/** Layout strategy that arranges children into a fixed grid of cells, one
- *  child per cell. A drag reflows the others to make room, and the container
- *  holds at most `cols × rows` children. */
+/**
+ * Layout strategy that arranges children into a fixed grid of cells, one
+ * child per cell, and the container holds at most `cols × rows` children.
+ *
+ * A child occupies the cell its pose sits in (see `centerOf`). A drag from
+ * inside the container swaps with the child in the cell it lands on; a drop
+ * from outside is offered only the free cells, so it lands in the nearest
+ * free one and a full grid rejects it.
+ */
 declare function tileGrid<TPose>(opts: TileGridOptions<TPose>): LayoutStrategy<TPose>;
 
 /** Which points within a container a child can snap to. */
@@ -11522,15 +11899,10 @@ interface SnapPointOptions<TPose> {
     tolerance?: number;
     snap?: LayoutSnap<TPose>;
 }
-/** A point in world coordinates. */
-type Pt = {
-    x: number;
-    y: number;
-};
 /** Layout strategy that leaves children where they are but offers a fixed set
  *  of points — corners, edge midpoints, center, or a grid — for a dragged
  *  child to land on. */
-declare function snapPoint<TPose extends Pt>(opts: SnapPointOptions<TPose>): LayoutStrategy<TPose>;
+declare function snapPoint<TPose extends Point2>(opts: SnapPointOptions<TPose>): LayoutStrategy<TPose>;
 
 /**
  * Parse a CSS color string into [r, g, b, a] with 0..1 components.
@@ -11699,4 +12071,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, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CellHighlightLayerOpts, type ChromeCtx, type ChromeId, type ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type ColorSpace, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CustomPaintContext, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DefaultTextData, DepRegistryProviderIfRoot, type DeriveAlignmentGuidesOptions, DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type Discriminator, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EasingSpec, Effect, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FeedDelta, type FeedNode, type FillPoseBox, type FitTextPoseOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, IntersectIcon, type Joint, type JointTransform, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LayerCommandCache, type LayerDrawFailure, LayerEnumerableAdapter, type LayerGroup, type LayerHit, type LayerSlotValue, type LayersMap, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, Mat3$1 as Mat3, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PathStation, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PointAlongPathOptions, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseComposition, PoseDescriptor, type PoseFeed, PoseOverrides, type PoseRotation, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PosedNode, type PressureToWidthOptions, type PreviewNode, type Pt, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, type RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, type ResolvableView, type ResolvedOverlay, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RunStylePatch, SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasProps, Node$1 as SceneNode, type SceneNodeClientRectOpts, SceneRegistry, type SceneSlotConfig, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewDrawOne, type SceneViewLayers, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationCore, type SimulationForce, type SimulationNode, type SimulationOptions, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, TextDrawCommand, type TextEditClipRect, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, type Tool, type ToolBundle, type ToolDef, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberFormat, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UNION_OF_CHILDREN, UnionIcon, Unit, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, VERSION, type Vec2, type VelocityTracker, VertexColorChannel, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, ZOOM_FLOOR, type ZoomBound, type ZoomClampOpts, type ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSimulation, createTextLayer, createTilePattern, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, dispatchApplyBatch, dlog, documentPose, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, dwarn, editAnchorsAction, effectivePose, ellipsePath, enterTextEditAction, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenPreviews, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, insertPreviewExtent, interpolateView, isBuiltinToolPref, isDebugEnabled, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, meanScale, mergeAlphaFromPrev, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointAlongPath, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, polylineFromPoints, poseRotationOf, prefUnit, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, unionOfChildren, unionOfChildrenVia, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, worldToScreen, zoomAt, zoomAtLeast };
+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 };