@weasel-js/core 1.11.0 → 1.12.0

package/dist/index.d.ts

@@ -1,44 +1,51 @@
-import { R as RectPose, i as SystemLayerSpec, A as AddNodeSpec, j as RegisteredOp, k as SceneRegistry, l as PoseComposition, L as LayoutFrame, N as Node, D as Dims, m as RenderLayer, n as LayerHit, V as ViewAnimationOptions, a as PathEditExtension, o as PoseAdapter, S as Scene, p as ViewportDims, F as FitViewToBoundsOptions, q as RedrawSource, r as EditAnchorsParams, I as InertiaConfig, E as EditAnchorsDep, G as GestureLifecycleOptions, s as SliceDep, t as StickyStyle, u as PoseOverrides, C as ContentHandlerEntry, v as PoseRemoval, w as PoseWrite, x as ScenePoseReports, y as AnchorMarkerShape, P as PathEditMark, z as ChromeState, B as LayerGroup, b as SnapSource, J as SerializedScene, K as GeometryProjection, M as InsertNodeFactory, O as InsertPaint, Q as SvgIngestOptions, T as SceneCanvasSnap, U as Affordance, W as AffordanceRegion, X as AffordanceBinding, Y as CommonAffordanceScratch, Z as TextOverflow, $ as CreateOutlinesAdapter, a0 as PaintKindEntry, a1 as DerivePoseFn, a2 as DerivePathFn, a3 as DerivedDep, a4 as PathEditTarget, a5 as PathSymmetryDep, H as HandleLocks, a6 as BooleanOpOptions, a7 as BooleansAdapter, a8 as BooleanOp, a9 as PathPaint, aa as BooleanOpResult, ab as BooleanStrokes, ac as SnapMods, ad as SourceCandidate, ae as SnapProbeAt, af as SnapCollect, ag as SnapMark, c as SnapGesture, ah as SnapDep, ai as SnapOutcome } from './depSchema-Cgfu_G9s.js';
-export { aj as AddLayerSpec, ak as AngleCandidate, al as AngleCollect, am as AnimateToBoundsOptions, an as AreaSelectDep, ao as Bivariant, ap as BooleanOpPreview, aq as BooleanPreviewPiece, ar as ClipFromPoseFn, as as ClipboardDep, at as ClipboardIngestCtx, au as ContainerNode, av as CopiesFromPoseFn, aw as CreateOutlinesResult, ax as CustomPaintContext, ay as DEFAULT_LAYER_RETAIN, az as DecayLoopConfig, aA as FinishedEditFrame, aB as FinishedPathEdit, aC as GEOMETRY_BOUND_DATA, aD as HandleLock, aE as HitTestView, aF as IDENTITY_POSE_COMPOSITION, aG as IngestCtx, aH as IngestionDep, aI as InsertDep, aJ as InsertEnds, aK as InsertExtras, aL as InsertIntoDep, aM as InsertLive, aN as LassoSelectDep, aO as LayerCommandCache, aP as LayerDrawFailure, aQ as LayerDrawSpan, aR as LayerRecord, aS as LayerRetainPolicy, aT as LayoutDep, aU as LayoutMove, aV as LeafNode, aW as Locus, aX as MinSize, aY as NodeAtPointDep, aZ as OutlinePathSpec, a_ as PATH_OVERLAY_ROLES, a$ as PaintKind, b0 as PaintKindEditorProps, b1 as PaintKindFamily, b2 as PaintKindLoader, b3 as PanBounds, b4 as PathEditDrag, b5 as PathEditDragStart, b6 as PathEditFinishCtx, b7 as PathEditHandleMove, b8 as PathEditMarksCtx, b9 as PathEditOther, ba as PathEditPart, bb as PathEditStore, bc as PathForm, bd as PathOverlay, be as PathOverlayOptions, bf as PathOverlayStyle, bg as PathRepresentation, bh as PoseClosure, bi as PoseHold, bj as PoseOverride, bk as PoseWriteOrigin, bl as PreviewPathsDep, bm as RemovedNode, bn as ResizePolicy, bo as SCENE_HISTORY_FORM, bp as STICKY_DEFAULTS, bq as SceneArrivalHandler, br as SerializedLayer, bs as SerializedNode, bt as SerializedSceneHistory, bu as SnapBegin, d as SnapConstrain, bv as SnapEdge, bw as SnapEdges, f as SnapGeometry, bx as SnapMarks, g as SnapOutcomeStore, by as SnapReadoutDep, bz as SnapReadoutStyle, e as SnapResizeBox, h as SnapSession, bA as SvgUnpacker, bB as SystemLayerRecord, bC as TextEditDep, bD as TextNodeData, bE as TransientPath, bF as UserLayerRecord, bG as VIEW_ANIMATION_KEY, bH as ViewAnimationApi, bI as ViewApi, bJ as ViewChannel, bK as applyBooleanOp, bL as applyCreateOutlines, bM as asNodeId, bN as asPaint, bO as composeWorldPose, bP as composesFrames, bQ as createPathOverlay, bR as createSnapOutcomeStore, bS as createSnapReadoutLayer, bT as depsUnchanged, bU as drawLayers, bV as drawOneLayer, bW as fitViewToBounds, bX as getPaintKind, bY as isLayerPainted, bZ as isLayerVisible, b_ as listGradientKinds, b$ as listPaintKinds, c0 as minSizeOf, c1 as paintKindOf, c2 as paintKindRegistry, c3 as paintedLayers, c4 as paintsLayer, c5 as paletteInsertPaint, c6 as pathPaintOf, c7 as patternFamily, c8 as previewBooleanOp, c9 as rebaseLocalPose, ca as registerContentHandler, cb as registerPaintKind, cc as registerPaintKindLoader, cd as seedTile, ce as stickyData, cf as stickyNodeFactory, cg as subscribeToSources, ch as switchGradientKind, ci as textBoxOf, cj as useDecayLoop, ck as useViewAnimation, cl as useViewAnimationOn, cm as viewAxes, cn as withoutGeometryBoundData } from './depSchema-Cgfu_G9s.js';
-import { View, Scale2, Path, FramedBox, PolygonPath, Point as Point$3, AnchorField, AnchorSet, GlMat3, PlacementAlign, Rect, Affine, PathSnapKind, PathInWorldPose, AnchorFieldValues, NumberEntry, JoinOptions, SegmentHit, AnchorSymmetry, BlendPathsOptions, BendAlongPathOptions, RepeatAlongPathOptions, PoseLinear } from '@weasel-js/geom';
-export { AnchorField, AnchorFieldValues, AnchorPair, AverageAxis, BendAlongPathOptions, BezierEasing, BlendPathsOptions, FramedBox as Bounds, CONSTRAINT_TOLERANCE, CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, ConstrainedPathEdit, ConstraintPoint, CornerFrame, CornerKeyword, CornerPiece, CornerShape, CornerShapeFrame, CornerSpec, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EasingFn, EasingName, EasingSpec, ExtendToMeetOptions, JoinOptions, MeasurePathOptions, NumberEntry, OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, PathBlend, PathBuilder, PathConstraint, PathConstraintKind, PathCrossing, PathFillRule, PathInWorldPose, PathMeasure, PathSegment, PathSnapHit, PathSnapIndex, PathSnapKind, PathSnapQuery, PathStation, PathStop, PenAnchor, PointAlongPathOptions, PointInPathOptions, PolygonPath, PoseLinear, PoseRotation, Rect, RectPath, RepeatAlongPathOptions, RepeatStation, ResolvedCorners, SPRING_PRESETS, Scale2, SegmentCrossing, SimplifyPathOptions, SmudgePathOptions, SolveConstraintsOptions, SolveConstraintsResult, SpringPreset, SpringPresetName, TrimPathOptions, TrimResult, Point as Vec2, View, ZOOM_FLOOR, asPolygonPath, averageAnchorsAt, bendAlongPath, blendPaths, boundsOfPath, circlePath, composePath, constrainPathEdit, constraintAnchors, cornerAt, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerSpecAt, countPathAnchors, createPathSnapIndex, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, extendToMeet, findPathSnap, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasCorners, hasOpenSubpath, intersectSegments, isCornerShape, joinAnchorsAt, lengthenOpenEnd, linePath, linear, meanScale, measurePath, nextCornerShape, openEndRay, openPathEnds, pathAnchorPoints, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToAnchors, pointAlongPath, pointInPath, polygonFromPoints, polylineFromPoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, remapPerAnchor, repeatAlongPath, resolveCorners, resolveCornersWithSources, resolveEasing, reversePath, rotatePathAround, roundRectPath, scaleDelta, scalePathToBounds, screenAngleOf, simplifyAnchorsAt, simplifyPath, smudgePath, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, starPath, stationsAlongPath, transformPath, translatePath, trimPathAt, unionBoundsPath, unsatisfiedConstraints, withCorner, withinPxBox, withinPxRadius, withoutCorners, worldEditToStorage } from '@weasel-js/geom';
-import { P as PlaneMap, L as LayoutStrategy, M as MoveAdapter, A as AreaSelectAdapter, e as LayerEnumerableAdapter, f as LassoHitMode, d as ReflowTransition, c as LayoutDropTargetMode, b as PasteOmission, g as ResizeAdapter, h as RotateAdapter, i as LassoSelectAdapter, I as InsertAdapter, j as ClipboardSnapshot, k as PasteCtx, O as OrderedAdapter } from './types-CHVXGfYm.js';
-export { C as ContainerBounds, D as DropRegion, l as DropTarget, m as LayoutArrival, n as LayoutChild, o as LayoutContainer, p as LayoutDragged, q as LayoutSnap, a as ParallaxOpts, r as ReflowGlideOptions, R as RegionPickView, s as ScalarOrXY, S as SnapTarget, t as deriveParallaxView, u as fromPlane, v as planeMap, w as planeMatrix, x as planeToPlane, y as rectFromPlane, z as rectToPlane, B as toPlane } from './types-CHVXGfYm.js';
+import { I as InheritedPaint, D as Dims, R as RenderLayer, L as LayerHit, V as ViewAnimationOptions, a as PathEditExtension, h as ViewportDims, F as FitViewToBoundsOptions, i as RedrawSource, j as EditAnchorsParams, k as InertiaConfig, E as EditAnchorsDep, G as GestureLifecycleOptions, l as SliceDep, m as StickyStyle, C as ContentHandlerEntry, A as AnchorMarkerShape, P as PathEditMark, n as ChromeState, o as LayerGroup, S as SnapSource, T as TransformFollower, p as GeometryProjection, q as InsertNodeFactory, r as InsertPaint, s as SvgIngestOptions, t as SceneCanvasSnap, u as Affordance, v as AffordanceRegion, w as AffordanceBinding, x as CommonAffordanceScratch, y as TextOverflow, z as CreateOutlinesAdapter, B as PaintKindEntry, J as PathEditTarget, K as FinishedEditFrame, M as PathSymmetryDep, H as HandleLocks, N as BooleanOpOptions, O as BooleansAdapter, Q as BooleanOp, U as PathPaint, W as BooleanOpResult, X as BooleanStrokes, Y as SnapMods, Z as SourceCandidate, $ as SnapProbeAt, a0 as SnapCollect, a1 as SnapMark, b as SnapGesture, a2 as SnapDep, a3 as SnapOutcome, f as SnapOutcomeStore, a4 as SnapReadoutStyle } from './depSchema-mG19aEdD.js';
+export { a5 as AngleCandidate, a6 as AngleCollect, a7 as AnimateToBoundsOptions, a8 as AreaSelectDep, a9 as BooleanOpPreview, aa as BooleanPreviewPiece, ab as CanDropIntoDep, ac as ClipboardDep, ad as ClipboardIngestCtx, ae as CreateOutlinesResult, af as CustomPaintContext, ag as DEFAULT_LAYER_RETAIN, ah as DecayLoopConfig, ai as FinishedPathEdit, aj as GEOMETRY_BOUND_DATA, ak as HandleLock, al as HitTestView, am as IngestCtx, an as IngestionDep, ao as InsertDep, ap as InsertEnds, aq as InsertExtras, ar as InsertIntoDep, as as InsertLive, at as LassoSelectDep, au as LayerCommandCache, av as LayerDrawFailure, aw as LayerDrawSpan, ax as LayerRetainPolicy, ay as LayoutDep, az as Locus, aA as MinSize, aB as NodeAtPointDep, aC as OutlinePathSpec, aD as PATH_OVERLAY_ROLES, aE as PaintKind, aF as PaintKindEditorProps, aG as PaintKindFamily, aH as PaintKindLoader, aI as PanBounds, aJ as PathEditDrag, aK as PathEditDragStart, aL as PathEditFinishCtx, aM as PathEditHandleMove, aN as PathEditMarksCtx, aO as PathEditOther, aP as PathEditPart, aQ as PathEditStore, aR as PathForm, aS as PathOverlay, aT as PathOverlayOptions, aU as PathOverlayStyle, aV as PathRepresentation, aW as PathTransformFinishCtx, aX as PreviewPathsDep, aY as ResizePolicy, aZ as STICKY_DEFAULTS, a_ as SnapBegin, c as SnapConstrain, a$ as SnapEdge, b0 as SnapEdges, e as SnapGeometry, b1 as SnapMarks, b2 as SnapReadoutDep, d as SnapResizeBox, g as SnapSession, b3 as SvgUnpacker, b4 as TextEditDep, b5 as TextNodeData, b6 as TransformPreviewNode, b7 as TransientPath, b8 as VIEW_ANIMATION_KEY, b9 as ViewAnimationApi, ba as ViewApi, bb as ViewChannel, bc as applyBooleanOp, bd as applyCreateOutlines, be as asPaint, bf as createPathOverlay, bg as createSnapOutcomeStore, bh as depsUnchanged, bi as drawLayers, bj as drawOneLayer, bk as fitViewToBounds, bl as getPaintKind, bm as inheritedPaintOf, bn as inheritsPaint, bo as isLayerPainted, bp as isLayerVisible, bq as listGradientKinds, br as listPaintKinds, bs as minSizeOf, bt as paintKindOf, bu as paintKindRegistry, bv as paintedLayers, bw as paintsLayer, bx as paletteInsertPaint, by as pathPaintOf, bz as patternFamily, bA as previewBooleanOp, bB as registerContentHandler, bC as registerPaintKind, bD as registerPaintKindLoader, bE as seedTile, bF as stickyData, bG as stickyNodeFactory, bH as subscribeToSources, bI as switchGradientKind, bJ as textBoxOf, bK as useDecayLoop, bL as useViewAnimation, bM as useViewAnimationOn, bN as viewAxes, bO as withInheritedPaint, bP as withoutGeometryBoundData } from './depSchema-mG19aEdD.js';
+import { View, Scale2, Path, FramedBox, PolygonPath, GlMat3, Point as Point$3, AnchorField, AnchorSet, PlacementAlign, Rect, Affine, PathSnapKind, PathInWorldPose, AnchorFieldValues, NumberEntry, JoinOptions, SegmentHit, PointOrigin, AnchorSymmetry, BlendPathsOptions, RunAlign, TrackSide, BendAlongPathOptions, RepeatAlongPathOptions, PoseLinear } from '@weasel-js/geom';
+export { AnchorField, AnchorFieldValues, AnchorPair, AverageAxis, BendAlongPathOptions, BezierEasing, BlendPathsOptions, FramedBox as Bounds, CONSTRAINT_TOLERANCE, CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, ConstrainedPathEdit, ConstraintPoint, CornerFrame, CornerKeyword, CornerPiece, CornerShape, CornerShapeFrame, CornerSpec, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EasingFn, EasingName, EasingSpec, ExtendToMeetOptions, JoinOptions, MeasurePathOptions, NumberEntry, OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, PathBlend, PathBuilder, PathConstraint, PathConstraintKind, PathCrossing, PathFillRule, PathInWorldPose, PathMeasure, PathSegment, PathSnapHit, PathSnapIndex, PathSnapKind, PathSnapQuery, PathStation, PathStop, PenAnchor, PointAlongPathOptions, PointInPathOptions, PolygonPath, PoseLinear, PoseRotation, Rect, RectPath, RepeatAlongPathOptions, RepeatStation, ResolvedCorners, SPRING_PRESETS, Scale2, SegmentCrossing, SimplifyPathOptions, SmudgePathOptions, SolveConstraintsOptions, SolveConstraintsResult, SpringPreset, SpringPresetName, TrimPathOptions, TrimResult, Point as Vec2, View, ZOOM_FLOOR, asPolygonPath, averageAnchorsAt, bendAlongPath, blendPaths, boundsOfPath, circlePath, composePath, constrainPathEdit, constraintAnchors, cornerAt, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerSpecAt, countPathAnchors, createPathSnapIndex, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, extendToMeet, findPathSnap, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasCorners, hasOpenSubpath, intersectSegments, isCornerShape, joinAnchorsAt, lengthenOpenEnd, linePath, linear, meanScale, measurePath, nextCornerShape, openEndRay, openPathEnds, pathAnchorPoints, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToAnchors, pathToD, pointAlongPath, pointInPath, polygonFromPoints, polylineFromPoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, remapPerAnchor, repeatAlongPath, resolveCorners, resolveCornersWithSources, resolveEasing, reversePath, rotatePathAround, roundRectPath, scaleDelta, scalePathToBounds, screenAngleOf, simplifyAnchorsAt, simplifyPath, smudgePath, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, starPath, stationsAlongPath, transformPath, translatePath, trimPathAt, unionBoundsPath, unsatisfiedConstraints, withCorner, withinPxBox, withinPxRadius, withoutCorners, worldEditToStorage } from '@weasel-js/geom';
+import { a as PlaneMap, L as LayoutStrategy, R as ReflowTransition, b as LayoutDropTargetMode } from './types-7puAuVD2.js';
+export { C as ContainerBounds, D as DropRegion, c as DropTarget, d as LayoutArrival, e as LayoutChild, f as LayoutContainer, g as LayoutDragged, h as LayoutSnap, P as ParallaxOpts, i as ReflowGlideOptions, S as ScalarOrXY, j as deriveParallaxView, k as fromPlane, p as planeMap, l as planeMatrix, m as planeToPlane, r as rectFromPlane, n as rectToPlane, t as toPlane } from './types-7puAuVD2.js';
 export { DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_VELOCITY_DECAY, Simulation, SimulationCore, SimulationForce, SimulationNode, SimulationOptions, UseSimulationOptions, createSimulation } from '@weasel-js/simulation';
 export { useSimulation } from '@weasel-js/simulation/react';
-import { NodeId, SelectionMode, SelectionExtendKey, SelectionApi, DebugSink, HitShape, HandleKind, ViewportGestureKind, View as View$1, IngestItem, OngoingOverlay, PointerSessionCancelReason, DeviceProfile, Bounds, Tool as Tool$1, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, ToolDef as ToolDef$1, DepName, DepSchema, Action, ActionDeps, GestureBinding, AffordanceHit, ActionDisabledReason, ToolKeybinding, HotkeyTrigger, ModifierState, RuleCtx, Rule, ActionTunings, ActionsProp, OverlayRole, ResizeAnchor, InvocationCtx, OngoingHandle } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDisabledReasonValue, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionParamSchema, ActionParams, ActionPresentation, ActionShortcut, ActionTuning, ActionTunings, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingScope, BindingSource, BoundGesture, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, Carry, CarryCallbacks, CarryPayload, CarryPointer, CarryStage, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepName, DepRegistry, DepSchema, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, GestureKitSettings, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, KeyBinding, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, MenuDef, MenuHit, MenuHost, MenuOpenRequest, MenuSources, ModeShortcutHandlers, ModifierRole, ModifierRoles, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OpenMenu, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, RoleKeys, RoleRebinds, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, TunedBinding, UiOngoingControl, ViewportGestureKind, WalkStep, actionBindings, actionCursor, actionItemTitle, actionItems, actionShortcuts, actionsTagged, activatesFocusedControl, assembleEntries, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDepRegistry, createDispatcher, createLongPressStore, defineTool, deleteScratch, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, isDebugEnabled, isEditableTarget, isInControlWithin, keySpecShortcut, keysHeld, liveScope, matchActionItem, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, overlaysOf, pastDragThreshold, resolveDeviceProfile, resolveParams, resolveSchemaMenu, roleReader, scopeBindings, scratchKey, setScratch, specificity, startCarry, taggedActionItems, tuneAction } from '@weasel-js/routing';
-import * as React$1 from 'react';
-import React__default, { Ref, RefObject, ReactNode, MutableRefObject, MouseEvent } from 'react';
+import { R as RectPose, a as SystemLayerSpec, A as AddNodeSpec, b as RegisteredOp, c as SceneRegistry, P as PoseComposition, L as LayoutFrame, N as Node, d as PoseAdapter, S as Scene, e as PoseRemoval, f as PoseWrite, g as ScenePoseReports, h as PoseOverrides, i as SerializedScene, D as DerivePoseFn, j as DerivePathFn, k as DerivedDep } from './types-CniVctmk.js';
+export { l as AddLayerSpec, B as Bivariant, C as ClipFromPoseFn, m as ContainerNode, n as CopiesFromPoseFn, I as IDENTITY_POSE_COMPOSITION, o as LayerRecord, p as LayoutMove, q as LeafNode, r as PoseClosure, s as PoseHold, t as PoseOverride, u as PoseWriteOrigin, v as RemovedNode, w as SCENE_HISTORY_FORM, x as SceneArrivalHandler, y as SceneBatchOptions, z as SceneDoc, E as SceneDocValues, F as SceneEditPass, G as SceneEditPassOptions, H as SceneEditSummary, J as SerializedDoc, K as SerializedLayer, M as SerializedNode, O as SerializedSceneHistory, Q as SystemLayerRecord, U as UserLayerRecord, T as asNodeId, V as composeWorldPose, W as composesFrames, X as rebaseLocalPose } from './types-CniVctmk.js';
+import { NodeId, SelectionMode, SelectionExtendKey, SelectionApi, IngestItem, OngoingOverlay, PointerSessionCancelReason, DeviceProfile, Bounds, Tool as Tool$1, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, ToolDef as ToolDef$1, DepName, DepSchema, Action, ActionDeps, GestureBinding, AffordanceHit, ActionDisabledReason, ToolKeybinding, HotkeyTrigger, ModifierState, RuleCtx, Rule, ActionTunings, BindingOverrides, ActionsProp, DebugSink, ToolSet, ToolEntry, OverlayRole, ResizeAnchor, InvocationCtx, OngoingHandle } from '@weasel-js/routing';
+export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDisabledReasonValue, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionParamSchema, ActionParams, ActionPresentation, ActionSettings, ActionSettingsState, ActionShortcut, ActionTuning, ActionTunings, ActionUnavailable, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingOverrides, BindingScope, BindingSource, BoundGesture, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, CaptureGestureOptions, CaptureKeyOptions, CaptureKind, CapturedSpec, Carried, Carry, CarryCallbacks, CarryPayload, CarryPointer, CarryStage, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepListing, DepName, DepRegistry, DepSchema, DepSource, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, GestureKitSettings, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, KEYMAP_HOLD, KeyBinding, KeyReach, KeymapDef, KeymapDescription, KeymapRow, KeymapStack, KeymapUnbound, KeymapVerdict, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, MenuDef, MenuHit, MenuHost, MenuOpenRequest, MenuSources, ModeShortcutHandlers, ModifierRole, ModifierRoles, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OpenKeymap, OpenMenu, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedBindingOverrides, ResolvedCandidate, RoleKeys, RoleRebinds, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolEntry, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSet, ToolSlot, TunedBinding, UiOngoingControl, ViewportGestureKind, WalkStep, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, actionShortcuts, actionsTagged, activatesFocusedControl, assembleEntries, bindingId, buildDepsFromRequires, buildRuleCtx, captureGesture, captureKey, clientToCanvas, createDepRegistry, createDispatcher, createKeymapStack, createLongPressStore, defineTool, deleteScratch, describeKeymap, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, isDebugEnabled, isEditableTarget, isInControlWithin, isToolSet, keySpecShortcut, keymapContribution, keymapLeaderBindingId, keymapLeaderId, keymapShortcuts, keysHeld, liveScope, matchActionItem, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, overlaysOf, pastDragThreshold, readActionSettings, resolveBindingOverrides, resolveDeviceProfile, resolveParams, resolveSchemaMenu, roleReader, scopeBindings, scratchKey, setScratch, specificity, startCarry, taggedActionItems, toolIdsOf, toolSet, toolSetHas, tuneAction, withoutTools } from '@weasel-js/routing';
+import * as react from 'react';
+import react__default, { Ref, RefObject, ReactNode, MutableRefObject, MouseEvent } from 'react';
 import { Reflection } from '@weasel-js/registry';
 export { MIXED, Mixed, QueryMatch, Reflectable, ReflectedEntry, Reflection, RegisterOptions, Registrant, createReflectable, isPlainObject } from '@weasel-js/registry';
+export { stableStringify } from './json.js';
+import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-DN2yfnq_.js';
+export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-DN2yfnq_.js';
 import { KitSettingsStore } from '@weasel-js/react';
 export { CanvasFocusReturn, FrameClock, FrameClockOptions, UseCanvasFocusOptions, VisibleRaf, VisibleRafOptions, VisibleRafTarget, useCanvasFocus, useFrameClock, useLatest, useVisibleRaf } from '@weasel-js/react';
 import { PaintedCursorState, CursorSink, CursorSpec } from '@weasel-js/cursor';
 export { BakeOptions, CURSOR_ANGLE_STEPS, CURSOR_MAX_CSS_PX, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSink, CursorSinkTarget, CursorSpec, PaintedCursor, PaintedCursorFrame, PaintedCursorState, ResolvedCursor, bakeCursor, createCursorSink, createPaintedCursorState, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
-import { DrawCommand, FlattenTolerance, ShaderProgramHandle, CommandStroke as CommandStroke$1 } from '@weasel-js/renderer';
+import { DrawCommand, FlattenTolerance, ImageMinification, ShaderProgramHandle, CommandStroke as CommandStroke$1 } from '@weasel-js/renderer';
 export { BlendFactor, BlendFactors, CompositeOp, CullRect, DrawCommand, Effect, FillPoseBox, FlattenTolerance, GlMat3, GroupDrawCommand, ImageDrawCommand, ImageMinification, ImageNodeData, ImageRasterSize, ImageStatus, PaintBindContext, PaintDrawKind, PaintProgram, PaintResources, PathDrawCommand, ProgramSource, RenderTarget, SPRITE_STRIDE, ShaderDrawCommand, ShaderProgram, ShaderProgramHandle, ShaderUniform, SpriteSheet, SpritesDrawCommand, TextDrawCommand, TilePatternOpts, bitmapSrc, blur, commandFill, commandPaint, commandStroke, createTilePattern, cullDrawCommands, fillInPoseFrame, fillToBoundsFrame, frameRect, getImageBitmap, imageStatus, isPaintKindKnown, isVectorImageSrc, mat3, registerEffect, releaseImage, resolveFillPattern, resolvePatternSpec, retryImage, setImageCacheBudget, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, viewToMat3, vignette, warmPaintKinds } from '@weasel-js/renderer';
-import { VertexColorChannel, Target, Animator, ColorOverrideRegistry, Skeleton, Skin, Pose, TargetAxes, ClipBinder, SpringPresetName, StaggerOptions, StaggerDelay, EasingSpec, AnimationHandle } from '@weasel-js/animator';
+import { C as CanvasDebugSink, D as DebugSnapshot, a as DebugConfig, b as DebugStrokes, c as DebugTheme } from './types-BN9hbdMI.js';
+export { d as DEBUG_FEATURES, e as DebugFeature, f as DebugStroke, F as FrameStats, L as LayerFrameStats, R as RecordedBounds, g as RecordedHandle, h as RecordedHitbox, i as RecordedLayer, j as RecordedOrigin, k as RecordedSnap, l as RecordedViewport } from './types-BN9hbdMI.js';
+import { VertexColorChannel, Target, Animator, ColorOverrideRegistry, TargetAxes, Pose, ClipBinder, SpringPresetName, StaggerOptions, StaggerDelay, EasingSpec, AnimationHandle, Skeleton, Skin } from '@weasel-js/animator';
 import { SelectionStore as SelectionStore$1 } from '@weasel-js/select';
-import { Paint, CommandFill, CommandStroke, CommandPaint, Fill, Stroke, Palette, SolidPaint, VertexWidth } from '@weasel-js/paint';
-export { ColorInterpolationSpace, ColorSpace, CommandFill, CommandPaint, CommandPaintUnits, CommandStroke, Fill, GradStop, GradientKind, GradientPaint, HalfWidths, HueInterpolation, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Paint, PaintUnits, PatternPaint, PatternPlacement, PatternTransform, PatternTransformParts, PosedPaint, Region, STROKE_DASH_RATIOS, ScreenLength, SolidPaint, Stroke, StrokeAlign, StrokeDashStyle, StrokeNib, TILE_KINDS, TextureHandle, TexturePaint, TileKind, TilePaint, TilePatternSpec, VertexWidth, VertexWidthSides, alignedStrokeRect, composePatternTransform, contrastLineColor, dashForStrokeStyle, decomposePatternTransform, gradientForBounds, gradientGeometry, hexToOklchDeg, hexToRgbBytes, hexToRgba, hslToSrgb, interpolateSrgb, isGradientPaint, isPatternPaint, isSolidPaint, isTileKind, isTilePaint, lerpColorArray, lerpFill, lerpOklab, lerpOklch, lerpPaint, lerpStroke, linearSrgbToOklab, linearToSrgb, normalizeHex, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, parseColor, parseColorToRgba255, parseHexBytes, patternPlacementOf, resolveColor, resolveScreenLength, rgbaToHex, sampleGradientStops, scaleVertexWidth, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf, tileSpecOf, vertexHalfWidths, vertexWidthFromSides, widestHalfWidth, withGradientKind } from '@weasel-js/paint';
 import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1, PointerContextValue, Yoke } from '@weasel-js/routing/react';
-export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, CommandOptions, DepRegistryProvider, DispatcherChannels, InputScope, OngoingAction, PointerContextProvider, PointerContextValue, PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, SelectionContextValue, UseGestureDispatcherOptions, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useYoke } from '@weasel-js/routing/react';
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, CommandOptions, DepRegistryProvider, DispatcherChannels, InputScope, OngoingAction, PointerContextProvider, PointerContextValue, PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, SelectionContextValue, UseGestureDispatcherOptions, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOngoingAction, useOpenKeymap, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useYoke } from '@weasel-js/routing/react';
+import { Paint, CommandFill, CommandStroke, CommandPaint, Fill, Inherit, Stroke, Palette, SolidPaint, VertexWidth, PaintedFill, PaintedStroke } from '@weasel-js/paint';
+export { ColorInterpolationSpace, ColorSpace, CommandFill, CommandPaint, CommandPaintUnits, CommandStroke, Fill, GradStop, GradientKind, GradientPaint, HalfWidths, HueInterpolation, INHERIT, Inherit, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Paint, PaintUnits, PaintedFill, PaintedStroke, PatternPaint, PatternPlacement, PatternTransform, PatternTransformParts, PosedPaint, Region, STROKE_DASH_RATIOS, ScreenLength, SolidPaint, Stroke, StrokeAlign, StrokeDashStyle, StrokeNib, TILE_KINDS, TextureHandle, TexturePaint, TileKind, TilePaint, TilePatternSpec, VertexWidth, VertexWidthSides, alignedStrokeRect, composePatternTransform, contrastLineColor, contrastRatio, dashForStrokeStyle, decomposePatternTransform, gradientForBounds, gradientGeometry, hexToOklchDeg, hexToRgbBytes, hexToRgba, hslToSrgb, interpolateSrgb, isGradientPaint, isPatternPaint, isSolidPaint, isTileKind, isTilePaint, lerpColorArray, lerpFill, lerpOklab, lerpOklch, lerpPaint, lerpStroke, linearSrgbToOklab, linearToSrgb, normalizeHex, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, parseColor, parseColorToRgba255, parseHexBytes, patternPlacementOf, resolveColor, resolveFill, resolveScreenLength, resolveStroke, rgbaToHex, sampleGradientStops, scaleVertexWidth, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf, tileSpecOf, vertexHalfWidths, vertexWidthFromSides, wcagLevels, widestHalfWidth, withGradientKind } from '@weasel-js/paint';
 import { FontRequest } from '@weasel-js/font';
 export { FaceMetrics, FaceRuleMetrics, FaceScriptMetrics, FontFamilyFaces, FontRequest, FontStyle, FontVariant, LocalFontOutlinesResult, OutlineFaceInfo, OutlineSource, OutlineStatus, OutlineVariant, RegisterFontOptions, canQueryLocalFonts, cssFamilyName, cssFontFamily, cssFontFamilyLoading, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, outlineStatus, refreshCanvasFont, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines, warmFonts } from '@weasel-js/font';
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, CreateHistoryOptions, History, HistorySelection } from '@weasel-js/history';
-export { BeginJournalOptions, CreateHistoryOptions, EvictedEntry, History, HistoryBranch, HistoryEntry, HistoryLogger, HistorySelection, Journal, Op, RecordEntryOptions, SerializedHistory, SerializedHistoryEntry, SerializedOp, SwapArgs, SwapOpOptions, swapOp } from '@weasel-js/history';
-import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-DN2yfnq_.js';
-export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-DN2yfnq_.js';
-import { G as GestureContext, B as BoundsConstraint, R as RotateBehavior, I as InsertBehavior, L as LassoSelectBehavior, M as MoveBehavior } from './clone-DZDrfIlU.js';
-export { A as ActionBehavior, a as AreaSelectOverlay, b as BehaviorEnd, c as BehaviorResult, C as CloneBehavior, d as CloneBehaviorResult, e as GestureFrames, f as GroupTransform, g as InsertMoveResult, h as InsertOverlay, i as InsertPoint, j as InsertProposed, k as LassoSelectMoveResult, l as LassoSelectOverlay, m as LassoSelectPose, n as LassoSelectProposed, o as MoveEnd, P as PointerState, p as ResizeMoveResult, q as ResizeOverlay, r as ResizeProposed, s as RotateMoveResult, t as RotateOverlay, u as RotateProposed } from './clone-DZDrfIlU.js';
-import { d as ResizeHandleLayout, U as UseResizeOptions, T as TargetTransform } from './cornerHandles-Camw_yeu.js';
-export { C as CORNER_ANCHORS, a as CornerAnchor, k as CornerEdge, b as CornerHandle, E as EDGE_HANDLE_MIN_RADII, H as HandleEdge, R as RESIZE_HANDLE_ANCHORS, c as ResizeHandleAnchor, e as cornerPoint, f as cornerResizeHandles, g as fixedCornerOf, h as handlePoint, i as hitCornerHandle, j as isCornerHandle, r as resizeHandlesFor } from './cornerHandles-Camw_yeu.js';
+export { BeginJournalOptions, CreateHistoryOptions, EvictedEntry, History, HistoryBranch, HistoryEntry, HistoryLogger, HistorySelection, HistoryStep, Journal, Op, RecordEntryOptions, SerializedHistory, SerializedHistoryEntry, SerializedOp, SwapArgs, SwapOpOptions, swapOp } from '@weasel-js/history';
+import { G as GestureContext, B as BoundsConstraint, R as RotateBehavior, I as InsertBehavior, L as LassoSelectBehavior, M as MoveBehavior } from './clone-C3e0OTuF.js';
+export { A as ActionBehavior, a as AreaSelectOverlay, b as BehaviorEnd, c as BehaviorResult, C as CloneBehavior, d as CloneBehaviorResult, e as GestureFrames, f as GroupTransform, g as InsertMoveResult, h as InsertOverlay, i as InsertPoint, j as InsertProposed, k as LassoSelectMoveResult, l as LassoSelectOverlay, m as LassoSelectPose, n as LassoSelectProposed, o as MoveEnd, P as PointerState, p as ResizeMoveResult, q as ResizeOverlay, r as ResizeProposed, s as RotateMoveResult, t as RotateOverlay, u as RotateProposed } from './clone-C3e0OTuF.js';
+import { d as ResizeHandleLayout, U as UseResizeOptions, T as TargetTransform } from './cornerHandles-p8fDIAKt.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, k as CornerEdge, b as CornerHandle, E as EDGE_HANDLE_MIN_RADII, H as HandleEdge, R as RESIZE_HANDLE_ANCHORS, c as ResizeHandleAnchor, e as cornerPoint, f as cornerResizeHandles, g as fixedCornerOf, h as handlePoint, i as hitCornerHandle, j as isCornerHandle, r as resizeHandlesFor } from './cornerHandles-p8fDIAKt.js';
 import { ModeRegistry, ModeDecorations } from '@weasel-js/modes';
+import { M as MoveAdapter, A as AreaSelectAdapter, L as LayerEnumerableAdapter, a as LassoHitMode, P as PasteOmission, b as ResizeAdapter, c as RotateAdapter, d as LassoSelectAdapter, I as InsertAdapter, C as ClipboardSnapshot, e as PasteCtx, O as OrderedAdapter } from './types-oFeQ5VjV.js';
+export { R as RegionPickView, S as SnapTarget } from './types-oFeQ5VjV.js';
 import * as _weasel_js_gestures from '@weasel-js/gestures';
-export { CarrySpec, ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetPredicate, TargetSpec, WheelSpec, bodyPredicate, hitPredicate } from '@weasel-js/gestures';
-import { U as UseMoveOptions } from './options-p9GZMXbY.js';
+export { BindingOverrideInput, CarrySpec, ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetPredicate, TargetSpec, WheelSpec, bindingSpec, bodyPredicate, held, hitPredicate, key, keySpecRoute, unbound } from '@weasel-js/gestures';
+import { U as UseMoveOptions } from './options-DBxEryYq.js';
 import { IconRef, IconTable, IconVariantLoader, IconRegistry, IconGlyph, IconEntry, IconVariantState } from '@weasel-js/icons';
 export { IconRef, IconTable, toIconRef } from '@weasel-js/icons';
 import * as _weasel_js_prefs from '@weasel-js/prefs';
@@ -46,20 +53,43 @@ import { PrefSection, PrefNumberUnit } from '@weasel-js/prefs';
 import { UnitScope } from '@weasel-js/quantity';
 export { ANGLE_RADIANS, IMPERIAL_INCHES, METRIC_MM, PIXELS, PerAxis, PlaneUnits, PlaneValue, ScopeTree, Unit, UnitEntry, UnitExpr, UnitExprContext, UnitScale, UnitScope, UnitSystem, UnitValue, axisUnits, formatAxes, formatScoped, formatUnit, fromRoot, parseUnitExpr, resolveAxes, resolveScoped, resolveUnit, resolveUnitExpr, scopesOf, toRoot, unitScale } from '@weasel-js/quantity';
 import { TextPose, TextStyle, StyledRun, TextVerticalAlign, TextPaint, TextOutlinesError } from '@weasel-js/text';
-export { DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_STYLE, DecorationKind, FaceMetricsFn, FitTextPoseOptions, FlagKey, FontVariantCaps, LabelOptions, LaidOutCell, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredSpan, MeasuredText, PaintRunsOpts, PaintedRuns, PlacedGlyph, PointInTextPoseOpts, PositionedRun, RangeStyle, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, RunSourceMap, RunStylePatch, SCRIPT_METRICS, SMALL_CAPS_SCALE, ScriptPreset, SetFlagResult, SmallCapsText, StyleKey, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextNodeSource, TextOutlineSource, TextOutlinesError, TextOutlinesFailure, TextPaint, TextPaintPath, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextToPathOptions, TextTransform, TextVerticalAlign, TransformedRunText, applyStyleToRange, cachedLayoutRuns, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, fontString, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutRuns, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, paragraphDirection, patchRangeStyle, pointInTextPose, rangeWeight, registerBidi, renderLabel, resolveAlign, resolveRunFace, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset } from '@weasel-js/text';
+export { DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, DecorationKind, FaceMetricsFn, FitTextPoseOptions, FlagKey, FontVariantCaps, LabelOptions, LaidOutCell, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredSpan, MeasuredText, PaintRunsOpts, PaintedRuns, PlacedGlyph, PointInTextPoseOpts, PositionedRun, RangeStyle, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, RunSourceMap, RunStylePatch, SCRIPT_METRICS, SMALL_CAPS_SCALE, ScriptPreset, SetFlagResult, SmallCapsText, StyleKey, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextNodeSource, TextOutlineSource, TextOutlinesError, TextOutlinesFailure, TextPaint, TextPaintPath, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextToPathOptions, TextTransform, TextVerticalAlign, TransformedRunText, applyStyleToRange, cachedLayoutRuns, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, fontString, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutRuns, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, paragraphDirection, patchRangeStyle, pointInTextPose, rangeWeight, registerBidi, renderLabel, resolveAlign, resolveRunFace, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset } from '@weasel-js/text';
 import { UseTextEditReturn } from '@weasel-js/text-dom';
 export { StartEditOptions, StyleToggle, TEXT_EDIT_FONT_HOLD, TextEditClipRect, TextEditCommit, TextEditScreenPose, TextEditSelection, UseTextEditOptions, UseTextEditReturn, charOffsetToDomPosition, domPositionToCharOffset, domToRuns, runsToDom, useTextEdit } from '@weasel-js/text-dom';
 export { BUILTIN_MARKERS, MarkerCtx, MarkerEntry, MarkerPaint, MarkerSite, MarkerSiteRequest, OffsetPathOptions, StrokeToPathOptions, getMarker, listMarkers, markerInset, markerKeyOf, markerRegistry, markerSites, offsetPath, registerMarker, resolveMarkerSize, resolveStrokeWidth, strokeInsets, strokeToPath } from '@weasel-js/stroke';
 export { Polyline, trimPolyline } from '@weasel-js/geom/tessellate';
+export { C as CLIP_NOTHING, a as aabbCenter, c as clipNothing, p as pointInRotatedRect, r as rectCorners, b as rotatePoint, d as rotatedRectCorners } from './math-B56zxVs5.js';
 export { SnipAtCrossingsOptions, SplitBySegmentOptions, pathDivide, pathExclude, pathIntersect, pathSubtract, pathUnion, snipPathByPolyline, snipPathsAtCrossings, splitPathByPolyline, splitPathBySegment, trianglesToPath } from '@weasel-js/geom/booleans';
 export { CURVE_REPS, CurveRepKind, CurveRepresentation, Discriminator, SharedAnchor, bezierCubic, bezierQuadratic, nurbs, spiro } from '@weasel-js/geom/curves';
 import { O as OriginProjection } from './originProjection-gY0jb4Wb.js';
 export { A as AUTO_ORIGIN_PROJECTION, R as RECT_ORIGIN_PROJECTION } from './originProjection-gY0jb4Wb.js';
 export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-CZ1eXbzY.js';
-export { a as aabbCenter, p as pointInRotatedRect, r as rectCorners, b as rotatePoint, c as rotatedRectCorners } from './math-CrJULaZI.js';
 export { ClipboardFlavors, UseClipboardOpsOptions, UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './clipboard.js';
 import { Vec, SnapCandidate } from '@weasel-js/geom/nd';
 
+/** One pose write an {@link createArrangeOp} made. */
+interface ArrangedPose {
+    id: string;
+    from: unknown;
+    to: unknown;
+}
+/** Arguments to {@link createArrangeOp}. */
+interface ArrangeArgs {
+    /** The writes to make. Absent until a computed arrangement has run once. */
+    placed?: ArrangedPose[];
+}
+/**
+ * Op: write a set of poses decided when the op first applies, not when it is
+ * built. The scene appends one to an edit that moves nodes into a container,
+ * and `compute` asks the container what to do with them after the rest of
+ * the edit has landed. Every later apply — redo, or a rebuild from a
+ * serialized history — replays the writes it recorded, so the arrangement is
+ * decided once. `write` replaces the adapter's `setPose` for this op and its
+ * inverses — the scene passes its own, since not every adapter an edit is
+ * applied through can write poses.
+ */
+declare function createArrangeOp(args: ArrangeArgs, compute?: () => ArrangedPose[], write?: (id: string, pose: unknown) => void): Op;
+
 /** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */
 interface ViewTransform {
     panX: number;
@@ -109,6 +139,8 @@ declare function normalizeView(view: View): View;
 interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
     systemLayers: readonly SystemLayerSpec<TLayer>[];
     initial?: readonly AddNodeSpec<TData, TLayer, TPose>[];
+    /** The document values the scene starts with, outside history. See `Scene.doc`. */
+    doc?: Readonly<Record<string, unknown>>;
     ops?: Readonly<Record<string, RegisteredOp<unknown>>>;
     historyLimit?: number;
     /** Window (ms) within which consecutive same-shaped mutations merge into
@@ -187,6 +219,10 @@ interface NodePaintCtx {
      *  on `channel`, the colors to paint instead. **Absent** when nothing animates
      *  the node. The kit's path painters apply it; see `withColorOverrides`. */
     vertexColors?: (channel: VertexColorChannel, base: readonly number[] | undefined) => readonly number[] | undefined;
+    /** What the node's `'inherit'` fill and stroke resolve to, looked up from
+     *  its containers by the scene's `drawOne` wrapper. **Absent** for a node
+     *  that inherits nothing. Hand it to `resolveFill` / `resolveStroke`. */
+    inherited?: InheritedPaint;
 }
 /**
  * Per-node draw function — the scene-slot `drawOne` signature shared by
@@ -291,6 +327,12 @@ interface NodeInkCtx {
      *  rotation and `transform`. With it, a `{ px }` length is measured the way
      *  the renderer builds it, exact in every direction; without, at `scale`. */
     screen?: readonly [number, number, number, number];
+    /** The path the node shows in place of its pose's, already where it is
+     *  drawn: its box is measured from this, not from the placeholder pose. */
+    derivedPath?: Path | null;
+    /** As {@link NodePaintCtx.inherited}: a stroke or fill the node inherits
+     *  inks it as its own does. */
+    inherited?: InheritedPaint;
 }
 
 /** What a painter that declares no `ink` is assumed to do. */
@@ -337,6 +379,9 @@ interface ShapeCoversPointOptions {
      *  everywhere, which degrades picking to the caller's AABB: for an edge,
      *  a zero-sized pose. */
     derivedPath?: Path | null;
+    /** See {@link NodeInkCtx.inherited}. Without it an `'inherit'` field is
+     *  read as none. */
+    inherited?: NodeInkCtx['inherited'];
 }
 /**
  * Does the shape `node` actually paints cover the world point? Asks the painter's silhouette,
@@ -408,14 +453,14 @@ interface ViewRect {
     w: number;
     h: number;
 }
-/** Props for `<CanvasView>`. */
-interface CanvasViewProps {
+/** The props every `<CanvasView>` takes, whichever side it holds. */
+interface CanvasViewCommonProps {
     /** Identifies the view to the surface and to input routing. Must be unique
      *  among the views on one canvas. */
     id: string;
     /**
      * The id of a view to nest this one in. `bounds` is then measured from that
-     * view's rect, and a thunked `bounds` or `view` receives that view's camera
+     * view's rect, and a thunked `bounds`, `view` or `aim` receives that view's camera
      * and size as `outer` and `dims`. The view paints after it, cut to what it
      * shows, paints only the layers it paints, and takes input there before it
      * does. While no view has that id, this one neither paints nor takes input.
@@ -424,19 +469,6 @@ interface CanvasViewProps {
     /** Where this view paints, recomputed every frame so the rect can track the
      *  outer camera. A plain rect is accepted for a fixed panel. */
     bounds: ViewRect | ((outer: View, dims: Dims) => ViewRect);
-    /** Camera. Supply this to control it; otherwise the view keeps its own,
-     *  seeded from `defaultView`. `onViewChange` fires either way.
-     *
-     *  A thunk is a camera derived from the canvas's — a loupe following the
-     *  pointer — read fresh at every paint and every event, so the two cannot
-     *  disagree mid-gesture. It is controlled: a pan inside the view reaches
-     *  only `onViewChange`. */
-    view?: View | ((outer: View, dims: Dims) => View);
-    defaultView?: View;
-    onViewChange?: (v: View) => void;
-    /** Pan limits, applied to every camera change the same way `<Canvas>`
-     *  applies its own. */
-    viewBounds?: FramedBox;
     /** Receives this view's camera, to read, drive, and watch from outside it. */
     cameraRef?: Ref<CanvasViewCamera>;
     /** Which of the surface's layers this view paints. Defaults to all of them —
@@ -488,6 +520,40 @@ interface CanvasViewProps {
      *  `selection` is supplied. */
     selectionOptions?: UseSelectionOptions;
 }
+/** A view that holds its camera. */
+interface CameraHeldViewProps {
+    /** Camera. Supply this to control it; otherwise the view keeps its own,
+     *  seeded from `defaultView`. `onViewChange` fires either way.
+     *
+     *  A thunk is a camera derived from the canvas's — a loupe following the
+     *  pointer — read fresh at every paint and every event, so the two cannot
+     *  disagree mid-gesture. It is controlled: a pan inside the view reaches
+     *  only `onViewChange`. */
+    view?: View | ((outer: View, dims: Dims) => View);
+    defaultView?: View;
+    onViewChange?: (v: View) => void;
+    /** Pan limits, applied to every camera change the same way `<Canvas>`
+     *  applies its own. */
+    viewBounds?: FramedBox;
+    aim?: never;
+    onAimChange?: never;
+}
+/** A view that holds its aim, and derives its camera from it. */
+interface AimHeldViewProps {
+    /** What the view shows, as a world rect; its camera fits it to the frame, uniformly and centered.
+     *  A thunk is read at each paint and event, measured like a thunked `view`. */
+    aim: FramedBox | ((outer: View, dims: Dims) => FramedBox);
+    /** A pan or zoom inside the view, or `setAim` on it, reported as the held rect that camera move carries. */
+    onAimChange?: (aim: FramedBox) => void;
+    view?: never;
+    defaultView?: never;
+    onViewChange?: never;
+    viewBounds?: never;
+}
+/** Props for `<CanvasView>`: the common ones, and either a camera or an aim. `Omit` does not distribute over
+ *  the union, and a `Partial` of it does not spread back into `<CanvasView>`, so a wrapper builds its props from
+ *  {@link CanvasViewCommonProps} and one half. */
+type CanvasViewProps = CanvasViewCommonProps & (CameraHeldViewProps | AimHeldViewProps);
 
 /**
  * One view on a shared canvas. Owns a camera, contributes the viewport node
@@ -499,177 +565,71 @@ interface CanvasViewProps {
  */
 declare function CanvasView(props: CanvasViewProps): null;
 
-/**
- * `DebugSink`, `HitShape` and `HandleKind` are declared in
- * `@weasel-js/routing`. Re-exported here, beside the overlay that reads one.
- */
-
-/** One bit per debug feature; absent keys are off. */
-interface DebugConfig {
-    hitboxes?: boolean;
-    handles?: boolean;
-    bounds?: boolean;
-    origins?: boolean;
-    snap?: boolean;
-    layers?: boolean;
-    /** Render each tracked node's id as a label at the top-left of its
-     *  bounds. Pulls from the same `recordBounds` stream `bounds` uses, so
-     *  no extra sink calls are required to enable. */
-    ids?: boolean;
-    /** Frame panel in the top-left corner: repaint rate and interval, the
-     *  CPU cost and GL draw-call count of the last paint, and both again per
-     *  render layer. The rate tracks the overlay's own draw callback, so it is
-     *  the canvas's repaint rate — a canvas that is not repainting shows the
-     *  last numbers, not zero. */
-    fps?: boolean;
-    /** The last viewport change a pan or zoom made: the viewport it started
-     *  from, outlined in the current view, and the world point it held fixed. */
-    viewport?: boolean;
-    /** Optional per-feature color overrides; falls back to the default theme. */
-    theme?: Partial<DebugTheme>;
-    /** Optional per-feature line-width / dash overrides; falls back to
-     *  {@link DEFAULT_DEBUG_STROKES}. */
-    strokes?: Partial<DebugStrokes>;
-}
-/** The name of one debug-overlay feature — the keys of {@link DebugConfig}
- *  that toggle a visualization. */
-type DebugFeature = 'hitboxes' | 'handles' | 'bounds' | 'origins' | 'snap' | 'layers' | 'ids' | 'fps' | 'viewport';
-/** Colors the debug overlay draws with, one entry per feature. */
-interface DebugTheme {
-    hitboxFill: string;
-    hitboxStroke: string;
-    handle: string;
-    bounds: string;
-    origin: string;
-    snap: string;
-    layerText: string;
-    layerTextBg: string;
-    /** Color for the per-node id label rendered when `config.ids` is on. */
-    idText: string;
-    /** Foreground / background for the FPS panel. */
-    fpsText: string;
-    fpsTextBg: string;
-    /** Previous-viewport outline, anchor trail and readout. */
-    viewport: string;
-}
-/** Line width and dash pattern for one stroked debug feature. An empty (or
- *  omitted) `dash` is a solid line. */
-interface DebugStroke {
-    width: number;
-    dash?: readonly number[];
-}
-/** The stroked half of the debug overlay's appearance, split from
- *  {@link DebugTheme} because only some features draw a line at all — text
- *  panels and filled origin dots take color and nothing else. */
-interface DebugStrokes {
-    hitbox: DebugStroke;
-    bounds: DebugStroke;
-    handle: DebugStroke;
-    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
-    snap: DebugStroke;
-    /** The previous-viewport outline and the anchor's trail. */
-    viewport: DebugStroke;
-}
-/** A hit region tested during the current frame. */
-interface RecordedHitbox {
-    id: string;
-    kind: 'body' | 'handle' | 'rotation' | 'anchor';
-    shape: HitShape;
-}
-/** A handle drawn during the current frame, and where. */
-interface RecordedHandle {
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    kind: HandleKind;
+/** A point in a view's world. A 2D world is the plane z = 0, so `z` is absent there. */
+interface AimPoint {
+    x: number;
+    y: number;
+    z?: number;
 }
-/** A node's bounds as computed during the current frame. */
-interface RecordedBounds {
-    id: string;
-    bounds: {
-        x: number;
-        y: number;
+/** A closed outline in a frame's CSS px, from the frame's top-left; at least 3 points. */
+type AimOutline = readonly {
+    x: number;
+    y: number;
+}[];
+/** A target view, as an aim is drawn into it: its world, and its frame. */
+interface AimSpace {
+    /** The view whose frame this is; `null` for a surface's root view. */
+    readonly viewId: string | null;
+    /** `'2d'` for core's views; any other value is its owner's (kernel3d: `'3d'`). */
+    readonly kind: string;
+    readonly size: {
         width: number;
         height: number;
     };
-}
-/** A node's transform origin as used during the current frame. */
-interface RecordedOrigin {
-    id: string;
-    point: {
+    /** World point to frame px; `null` where the point does not draw (behind a 3D camera). */
+    project(p: AimPoint): {
         x: number;
         y: number;
-    };
-}
-/** A snap candidate considered during the current gesture, and whether it
- *  won. Unlike the other records these survive across frames, until the
- *  gesture ends. */
-interface RecordedSnap {
-    point: {
+    } | null;
+    /** Frame px to the world point under it; `null` where there is none (a 3D ray missing its plane). */
+    unproject(px: {
         x: number;
         y: number;
-    };
-    accepted: boolean;
+    }): AimPoint | null;
 }
-/** A render layer that drew during the current frame. */
-interface RecordedLayer {
-    id: string;
-    label: string;
-    space: 'world' | 'screen';
-    index: number;
-}
-/** The last viewport change a gesture made. See `DebugSink.recordViewport`. */
-interface RecordedViewport {
-    kind: ViewportGestureKind;
-    from: View$1;
-    to: View$1;
-    /** World point the gesture held fixed, when it had one. */
-    anchor?: {
+/** What a viewport shows, read in the world of the view it names. */
+interface ViewAim<TExtent = unknown> {
+    readonly viewId: string | null;
+    /** Discriminates `extent`: `'rect'` for core's 2D views. */
+    readonly kind: string;
+    /** Where the aim lies in its world, in its owner's own terms. */
+    readonly extent: TExtent;
+    /** The aim's outline in `space`'s frame, or `null` when it cannot be drawn there. */
+    outlineIn(space: AimSpace): AimOutline | null;
+    /** This aim moved so the world point under frame px `from` in `space` ends up under `to`; `null` when either misses. */
+    pannedIn(space: AimSpace, from: {
         x: number;
         y: number;
-    };
-}
-/** What one render layer cost in a paint. */
-interface LayerFrameStats {
-    id: string;
-    /** GL draw calls issued while this layer's commands were dispatched. A
-     *  batched run is drawn when it closes, so it counts toward the layer that
-     *  closed it. */
-    drawCalls: number;
-    /** CPU milliseconds: building the layer's commands plus dispatching them. */
-    ms: number;
-}
-/** What one paint cost, for the frame panel. */
-interface FrameStats {
-    /** CPU milliseconds for the whole paint — command build and dispatch. GPU
-     *  time is not included; the GPU runs asynchronously. */
-    paintMs: number;
-    drawCalls: number;
-    layers: LayerFrameStats[];
-}
-/** Everything the sink collected, ready for the overlay to draw. */
-interface DebugSnapshot {
-    hitboxes: RecordedHitbox[];
-    handles: RecordedHandle[];
-    bounds: RecordedBounds[];
-    origins: RecordedOrigin[];
-    snap: RecordedSnap[];
-    layers: RecordedLayer[];
-    /** Latest viewport change; survives frames until replaced. */
-    viewport: RecordedViewport | null;
-    /** The previous paint's cost. The overlay draws before the paint it is part
-     *  of is dispatched, so this is always one paint behind. */
-    frame: FrameStats | null;
-}
-/** The sink `<Canvas>` creates: what tools record into, plus the canvas-side
- *  half — the frame stats only the painter knows — and the read the overlay
- *  draws from. */
-interface CanvasDebugSink extends DebugSink {
-    recordFrame(stats: FrameStats): void;
-    snapshot(): DebugSnapshot;
+    }, to: {
+        x: number;
+        y: number;
+    }): ViewAim<TExtent> | null;
 }
+/** Core's 2D aim: a world rect a view shows. */
+type RectAim = ViewAim<FramedBox> & {
+    readonly kind: 'rect';
+};
+/** The aim of view `viewId` (`null`: a surface's root) showing world rect `rect`. */
+declare function rectAim(viewId: string | null, rect: FramedBox): RectAim;
+/** Whether `aim` is core's 2D rect aim, so its `extent` is a world rect. */
+declare function isRectAim(aim: ViewAim): aim is RectAim;
+/** A 2D view's frame: `view` is its camera and `size` its frame; frame px are measured from the frame's top-left. */
+declare function aimSpace2d(viewId: string | null, view: View, size: Dims): AimSpace;
+/**
+ * The camera that shows `rect` in a frame of `size`: `'exact'` per axis (the inverse of `viewportWorldRect`),
+ * `'contain'` uniform and centered. Not clamped to a zoom range, and finite for an empty rect or frame. Normalized.
+ */
+declare function viewForAim(rect: FramedBox, size: Dims, fit: 'exact' | 'contain'): View;
 
 /**
  * A view added through {@link SceneCanvasApi.addView}.
@@ -926,6 +886,13 @@ interface SceneCanvasApi extends CanvasExtensionApi {
     }, opts?: {
         except?: string;
     }): ViewAt;
+    /** What view `id` shows (`null`: the canvas's own camera), or `null` while no such view is mounted. */
+    aimOf(id: string | null): ViewAim | null;
+    /** Point view `id` at `aim`. A camera-held view moves its camera to show the aim exactly, per axis, so a
+     *  rect of another shape stretches it; for a uniform zoom-to-fit, use `fitViewToBounds` or `animateView`.
+     *  An aim-held view reports the aim through `onAimChange`. `false` when there is no such view, the aim is
+     *  not one it can read, or the write goes nowhere: no camera writer, or a controlled view with no handler. */
+    setAim(id: string | null, aim: ViewAim): boolean;
 }
 
 /**
@@ -942,6 +909,8 @@ interface SceneCanvasApi extends CanvasExtensionApi {
  */
 interface GesturePreviewSource {
     previewIds?(): Iterable<string> | null;
+    /** Absent/null falls back to the node's effective pose, which is where a
+     *  transform publishing to the scene's overrides puts it. */
     previewPose?(id: string): unknown;
     /** Companion to `previewPose` for actions that mutate node data (anchor
      *  edits on `data.path` nodes). Absent/null falls back to committed data. */
@@ -1454,9 +1423,6 @@ interface UseNodeOverlayFrameOptions<TPose> {
  */
 declare function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(scene: Scene<TData, TLayer, TPose>, containerRef: RefObject<HTMLElement | null>, nodeId: string | null | undefined, options?: UseNodeOverlayFrameOptions<TPose>): NodeOverlayFrame | null;
 
-/** JSON with object keys sorted, so two equal values produce one string. */
-declare function stableStringify(value: unknown): string;
-
 /** A 2D point in the rect element's local coordinate space. */
 interface HandleDragPoint {
     x: number;
@@ -1644,7 +1610,7 @@ interface DeviceProfileProviderProps {
  * Publish one resolved profile to a subtree. `<SceneCanvas>` renders this so
  * overlays, affordances, and consumer chrome all read the same object.
  */
-declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): React$1.FunctionComponentElement<React$1.ProviderProps<DeviceProfile | null>>;
+declare function DeviceProfileProvider({ value, children }: DeviceProfileProviderProps): react.FunctionComponentElement<react.ProviderProps<DeviceProfile | null>>;
 
 /**
  * Call `onChange` each time `window.devicePixelRatio` changes: the window
@@ -1717,6 +1683,10 @@ interface PageLayoutOptions {
  * Throws on two pages with one id.
  */
 declare function layoutPages(pages: readonly Page[], options?: PageLayoutOptions): PlacedPage[];
+/** The name page `index` of the page order shows: its own, else "Page" and its place. */
+declare function pageName(page: {
+    readonly name?: string | undefined;
+}, index: number): string;
 /** The page under a world point, or `null` between and outside them. A point on an edge is on the page. */
 declare function pageAt(pages: readonly PlacedPage[], point: {
     readonly x: number;
@@ -1728,6 +1698,13 @@ declare function pageAt(pages: readonly PlacedPage[], point: {
  * rule that says which page an object is on.
  */
 declare function pageOfBounds(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null;
+/**
+ * The page a world-space box is held by: the one it is on (`pageOfBounds`),
+ * else the one nearest it by the box-to-box gap, the earlier of two equally
+ * near. `null` only with no pages. Used where every object must land on some
+ * page, such as an export; `pageOfBounds` stays the rule for what is on one.
+ */
+declare function pageHolding(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null;
 /**
  * The page `step` places along the page order from the one with id `current`:
  * the next slide is `1`, the one before is `-1`. `null` past either end, unless
@@ -1758,6 +1735,64 @@ declare function pagesLayer(pages: readonly PlacedPage[], options: PagesLayerOpt
 
 /** The view that shows one placed page whole: `fitViewToBounds` on its rect. */
 declare function fitViewToPage(page: PlacedPage, viewportDims: ViewportDims, currentView: View, options?: FitViewToBoundsOptions): View;
+/** The page the view shows most of: the one overlapping the visible world rect most, or `null` when none shows. */
+declare function pageInView(pages: readonly PlacedPage[], view: View, viewportDims: ViewportDims): PlacedPage | null;
+
+/**
+ * A document's pages as a scene document value, and the edits that change
+ * them. Each edit moves the nodes on a page by however far the page itself
+ * moved, so what is on a page stays where it is on that page.
+ */
+
+/** The document value under {@link PAGES_DOC_KEY}: the pages in order, and how they are laid out. */
+interface PagesDoc {
+    readonly pages: readonly Page[];
+    readonly layout?: PageLayoutOptions;
+}
+/** The scene document value key a page list lives under (`scene.doc`). */
+declare const PAGES_DOC_KEY = "core:pages";
+/** Options every page edit takes. */
+interface PageEditOptions {
+    /** The undo entry's label. */
+    label?: string;
+    /** How node poses are measured and moved. Default: poses are rects. */
+    descriptor?: PoseDescriptor<unknown>;
+}
+/** The scene's pages doc, or `null` when it has none. */
+declare function pagesOf<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>): PagesDoc | null;
+/** The scene's pages, placed in world space; empty when it has no pages doc. */
+declare function placedPagesOf<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>): PlacedPage[];
+/** An id none of `pages` has: `page-1`, `page-2`, and so on. */
+declare function nextPageId(pages: readonly Page[]): string;
+/**
+ * The root nodes on each placed page, by page id: each root belongs to the
+ * page its bounds overlap most (`pageOfBounds`). A root in the gaps belongs to
+ * none, and one that derives from other nodes is left out, since it follows
+ * them.
+ */
+declare function pageMembers<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, placed: readonly PlacedPage[], descriptor?: PoseDescriptor<unknown>): Map<string, NodeId[]>;
+/**
+ * Replace the scene's pages doc with `next`, moving each page's members by
+ * the change in their page's place, all as one undo entry labeled `label`.
+ * Members of a page `next` drops are left where they are; `removePage` deletes
+ * them first.
+ */
+declare function setPages<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, next: PagesDoc, label: string, options?: Pick<PageEditOptions, 'descriptor'>): void;
+/** Insert `page` at `index`, by default after the last page. */
+declare function addPage<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, page: Page, options?: PageEditOptions & {
+    index?: number;
+}): void;
+/** Delete page `id`, what is on it, and every node that derives from that, as one entry. */
+declare function removePage<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: string, options?: PageEditOptions): void;
+/** Move page `id` to `index` in the page order. */
+declare function movePage<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: string, index: number, options?: PageEditOptions): void;
+/** Give page `id` a new size. Its members keep their places on it; the pages after it shift. */
+declare function resizePage<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: string, size: {
+    readonly width: number;
+    readonly height: number;
+}, options?: PageEditOptions): void;
+/** Rename page `id`; an empty name removes it. */
+declare function renamePage<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, id: string, name: string, options?: PageEditOptions): void;
 
 /** Optional clamp bounds for `zoomAt`. Defaults: {@link DEFAULT_MIN_ZOOM} /
  *  {@link DEFAULT_MAX_ZOOM} (per axis). */
@@ -1965,6 +2000,211 @@ declare function useVelocityTracker(): VelocityTracker;
  */
 declare function interpolateView(from: View, to: View): (t: number) => View;
 
+/** An aim handed in by value (another surface's view, a 3D pane), with the writer that moves it. */
+interface AimSource {
+    aim(): ViewAim | null;
+    setAim?(aim: ViewAim): void;
+}
+/** How a marker's outline is stroked, in screen px. */
+interface ViewMarkerStyle {
+    stroke?: string;
+    width?: number;
+    dash?: readonly number[];
+}
+/** One view's aim, drawn inside another view's frame. */
+interface ViewMarkerProps {
+    /** Unique among the markers on one surface. */
+    id: string;
+    /** Whose aim: a view id on this surface, `null` for the root view, or an aim by value. */
+    source: string | null | AimSource;
+    /** Whose frame it is drawn in, after that view's layers: a view id, or `null` for the root. */
+    target: string | null;
+    /** Screen px. Default: stroke `#ffffff`, width 1, dash [2, 3]. */
+    style?: ViewMarkerStyle;
+    /** Default true: dragging the marker edits the source's aim. A source with no writer is never interactive.
+     *  A marker grabs its whole interior plus {@link VIEW_MARKER_HIT_SLOP_PX}, so one covering much of its
+     *  frame takes every press there; `false` opts out. */
+    interactive?: boolean;
+}
+/** The marker style a {@link ViewMarkerProps.style} fills in from: the minimap indicator's. */
+declare const VIEW_MARKER_DEFAULT_STYLE: Required<ViewMarkerStyle>;
+/** What a marker resolves aims through: the surface's views. */
+interface ViewMarkerHost {
+    aimOf(id: string | null): ViewAim | null;
+    setAim(id: string | null, aim: ViewAim): boolean;
+}
+/** A screen-space layer, id `view-marker:<id>`, drawing `props`'s source aim in the frame it is handed. */
+declare function createViewMarkerLayer(props: () => ViewMarkerProps, host: ViewMarkerHost): RenderLayer<unknown>;
+/** A press on a marker, held for the drag: where it started, and the aim it started from. */
+interface ViewMarkerGrab {
+    readonly markerId: string;
+    /** Pan the source so the world point under the press ends up under `world`, a point in the target's world. */
+    moveTo(world: {
+        x: number;
+        y: number;
+    }): void;
+}
+/** A press this many screen px outside the outline still counts. */
+declare const VIEW_MARKER_HIT_SLOP_PX = 4;
+/**
+ * The grab for a press at frame px `at` in `space`, the marker's target, or
+ * `null` when the marker is not interactive, its source has no writer or no
+ * aim, or `at` is not on its outline or within {@link VIEW_MARKER_HIT_SLOP_PX} of it. A surface with views
+ * calls this itself; a canvas with none, such as a detached minimap, calls it to route a press to its marker.
+ */
+declare function grabViewMarker(props: ViewMarkerProps, host: ViewMarkerHost, space: AimSpace, at: {
+    x: number;
+    y: number;
+}): ViewMarkerGrab | null;
+
+/**
+ * Draws one view's aim inside another's frame, after that view's own layers.
+ *
+ * Renders nothing; outside a surface it is inert. Either view may mount after
+ * the marker does: until both are there it draws nothing.
+ */
+declare function ViewMarker(props: ViewMarkerProps): null;
+
+/**
+ * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
+ *
+ * `@weasel-js/routing` never reads an overlay — it collects the live ones and
+ * hands them back in scope order — so it leaves the element type open. What a
+ * weasel canvas draws is a `RenderLayer`, and every kit call site should see
+ * that rather than `unknown`, so core binds the parameter once, here, and
+ * re-exports these names under the ones they have always had.
+ */
+
+/** What a canvas overlay is, at this layer. */
+type Overlay = RenderLayer<unknown>;
+declare module '@weasel-js/routing' {
+    interface OverlaySchema {
+        overlay: RenderLayer<unknown>;
+    }
+}
+/** Routing's `Contribution`, with overlays typed as `RenderLayer`. */
+type Contribution = Contribution$1<Overlay>;
+/** Routing's `ContributionChrome`, with overlays typed as `RenderLayer`. */
+type ContributionChrome = ContributionChrome$1<Overlay>;
+/** Routing's `Tool`, with overlays typed as `RenderLayer`. */
+type Tool = Tool$1<Overlay>;
+/** The same type as `Tool`, kept for code that imports it by this name. */
+type AnyTool = Tool;
+/** Routing's `ToolDef` (what `defineTool` takes), with overlays typed as `RenderLayer`. */
+type ToolDef = ToolDef$1<Overlay>;
+/** Routing's `ToolsApi`, with overlays typed as `RenderLayer`. */
+type ToolsApi = ToolsApi$1<Overlay>;
+/** Routing's `UseToolsOptions`, with overlays typed as `RenderLayer`. */
+type UseToolsOptions = UseToolsOptions$1<Overlay>;
+/** Routing's `useTools`, typed for `RenderLayer` overlays. */
+declare const useTools: (opts: UseToolsOptions) => ToolsApi;
+
+/**
+ * The versions a contribution can require, keyed by package without its
+ * `@weasel-js/` scope. Only core reports its version today.
+ */
+interface KitVersions {
+    core: string;
+}
+/** A contribution's `requires`: a semver range per package it was written against. */
+type KitRequirements = {
+    readonly [K in keyof KitVersions]?: string;
+};
+/** The running kit's versions. */
+declare const KIT_VERSIONS: Readonly<KitVersions>;
+/** One requirement the running kit does not meet. */
+interface RequirementMismatch {
+    package: string;
+    range: string;
+    /** The running version, or `undefined` when that package reports none. */
+    running: string | undefined;
+    reason: 'unsatisfied' | 'invalid-range' | 'unknown-package';
+}
+/**
+ * Whether `version` falls in `range`. `null` when either cannot be read, so a
+ * caller can tell a mismatch from a requirement it could not check.
+ */
+declare function satisfiesRange(version: string, range: string): boolean | null;
+/**
+ * Every requirement in `requires` the running kit does not meet. A package
+ * whose build does not know its own version (`0.0.0-unknown`, core's source
+ * bundled without its define) is skipped: nothing can be said about it.
+ */
+declare function checkRequirements(requires: KitRequirements, running?: Readonly<Partial<Record<string, string>>>): RequirementMismatch[];
+
+/** Reads the surface's deps from inside `SurfaceContribution.attach`. */
+interface ContributionDepReader {
+    get<K extends DepName>(name: K): DepSchema[K] | undefined;
+}
+/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */
+interface ContributionFrameCtx {
+    /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one
+     *  frame see the same value. */
+    readonly time: number;
+    /** The surface camera this frame paints with. */
+    readonly view: View;
+    /** Ask for another frame. A hook animating something calls this every frame
+     *  it still has work for, and stops calling it to let the loop go idle. */
+    requestFrame(): void;
+    /** The surface's deps, as `attach` reads them. */
+    readonly deps: ContributionDepReader;
+}
+/**
+ * A feature a surface installs in one step. Every role is optional: `bindings`,
+ * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus
+ * the ones below. Installing it installs every role it declares, and removing
+ * it removes them.
+ */
+interface SurfaceContribution extends Contribution {
+    /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */
+    views?: readonly CanvasViewProps[];
+    /** Markers this entry draws, as `<ViewMarker>` elements would. */
+    markers?: readonly ViewMarkerProps[];
+    /**
+     * Runs once the surface mounts; returns its teardown. For what the roles
+     * above cannot say — a registered (hit-testable) layer, a subscription.
+     *
+     * Keyed by the function's identity, so a contribution built once (in a
+     * `useMemo`, or at module scope) attaches once however often the host
+     * re-renders.
+     */
+    attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;
+    /**
+     * Runs on every frame the surface paints, before the paint — for state the
+     * entry's layers read, advanced once per frame. Hooks run in the order the
+     * surface lists its entries (registered tools, then `ambient` in array
+     * order), and one that throws is reported and skipped without stopping the
+     * frame.
+     */
+    beforePaint?: (ctx: ContributionFrameCtx) => void;
+    /** Runs after a frame's pixels have landed, in the same order as
+     *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */
+    afterPaint?: (ctx: ContributionFrameCtx) => void;
+    /**
+     * The kit versions this entry was written against, as semver ranges:
+     * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the
+     * surface is set to `versionCheck="strict"`.
+     */
+    requires?: KitRequirements;
+}
+/**
+ * Concatenate contribution bundles into one registry, preserving order. Throws
+ * on a duplicate entry id, dep name, view id or marker id — two features
+ * answering for the same name is a bug in whichever was added second.
+ */
+declare function mergeContributions<T extends SurfaceContribution>(...bundles: readonly (readonly T[])[]): T[];
+
+/** The action id a drag on a view marker routes to. */
+declare const VIEW_MARKER_DRAG = "view.marker.drag";
+/** Drags the grabbed marker. There is nothing to commit, so a cancel ends where a release does. */
+declare function viewMarkerDragAction(): Action;
+/**
+ * The always-on entry (id `'view-marker'`) that binds a drag on any marker to {@link VIEW_MARKER_DRAG}.
+ * A `<SceneCanvas>` installs it unless `actions={null}` or a `tools` takeover leaves it out; to turn marker
+ * dragging back on there, pass it in `ambient`, or in the takeover's own `useTools` ambient list.
+ */
+declare function createViewMarkerContribution(): SurfaceContribution;
+
 /** The size props every canvas host takes. */
 interface SurfaceSizeProps {
     /** CSS-pixel width. Omit it, or `height`, and the element fills its parent
@@ -2118,7 +2358,7 @@ interface SceneViewCanvasProps<TData, TLayer extends string, TPose> extends Surf
      *  pointer listeners or call `toBlob` for snapshots through this. */
     canvasRef?: Ref<HTMLCanvasElement>;
 }
-declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): React$1.JSX.Element;
+declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props: SceneViewCanvasProps<TData, TLayer, TPose>): react.JSX.Element;
 /**
  * Pointer-inert read-only scene view. It attaches no event listeners;
  * consumers attach their own through `canvasRef`, a plain prop because
@@ -2162,7 +2402,7 @@ interface DrawCanvasProps extends SurfaceSizeProps {
  * a package demo, a swatch, a preview — where a `<SceneCanvas>` would bring a
  * scene, tools and an input dispatcher that nothing uses.
  */
-declare function DrawCanvas(props: DrawCanvasProps): React$1.JSX.Element;
+declare function DrawCanvas(props: DrawCanvasProps): react.JSX.Element;
 
 /** The accent canvas chrome paints in when the element sits under no theme. */
 declare const FALLBACK_ACCENT = "#4c8dff";
@@ -2390,134 +2630,7 @@ declare function useKeyState(options?: UseKeyStateOptions): KeyState;
  * For chrome that draws the modifiers; a frame loop polls
  * {@link useKeyState} instead. The object is the same one between changes.
  */
-declare function useKeyModifiers(options?: UseKeyStateOptions): KeyModifiers;
-
-/**
- * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
- *
- * `@weasel-js/routing` never reads an overlay — it collects the live ones and
- * hands them back in scope order — so it leaves the element type open. What a
- * weasel canvas draws is a `RenderLayer`, and every kit call site should see
- * that rather than `unknown`, so core binds the parameter once, here, and
- * re-exports these names under the ones they have always had.
- */
-
-/** What a canvas overlay is, at this layer. */
-type Overlay = RenderLayer<unknown>;
-declare module '@weasel-js/routing' {
-    interface OverlaySchema {
-        overlay: RenderLayer<unknown>;
-    }
-}
-/** Routing's `Contribution`, with overlays typed as `RenderLayer`. */
-type Contribution = Contribution$1<Overlay>;
-/** Routing's `ContributionChrome`, with overlays typed as `RenderLayer`. */
-type ContributionChrome = ContributionChrome$1<Overlay>;
-/** Routing's `Tool`, with overlays typed as `RenderLayer`. */
-type Tool = Tool$1<Overlay>;
-/** The same type as `Tool`, kept for code that imports it by this name. */
-type AnyTool = Tool;
-/** Routing's `ToolDef` (what `defineTool` takes), with overlays typed as `RenderLayer`. */
-type ToolDef = ToolDef$1<Overlay>;
-/** Routing's `ToolsApi`, with overlays typed as `RenderLayer`. */
-type ToolsApi = ToolsApi$1<Overlay>;
-/** Routing's `UseToolsOptions`, with overlays typed as `RenderLayer`. */
-type UseToolsOptions = UseToolsOptions$1<Overlay>;
-/** Routing's `useTools`, typed for `RenderLayer` overlays. */
-declare const useTools: (opts: UseToolsOptions) => ToolsApi;
-
-/**
- * The versions a contribution can require, keyed by package without its
- * `@weasel-js/` scope. Only core reports its version today.
- */
-interface KitVersions {
-    core: string;
-}
-/** A contribution's `requires`: a semver range per package it was written against. */
-type KitRequirements = {
-    readonly [K in keyof KitVersions]?: string;
-};
-/** The running kit's versions. */
-declare const KIT_VERSIONS: Readonly<KitVersions>;
-/** One requirement the running kit does not meet. */
-interface RequirementMismatch {
-    package: string;
-    range: string;
-    /** The running version, or `undefined` when that package reports none. */
-    running: string | undefined;
-    reason: 'unsatisfied' | 'invalid-range' | 'unknown-package';
-}
-/**
- * Whether `version` falls in `range`. `null` when either cannot be read, so a
- * caller can tell a mismatch from a requirement it could not check.
- */
-declare function satisfiesRange(version: string, range: string): boolean | null;
-/**
- * Every requirement in `requires` the running kit does not meet. A package
- * whose build does not know its own version (`0.0.0-unknown`, core's source
- * bundled without its define) is skipped: nothing can be said about it.
- */
-declare function checkRequirements(requires: KitRequirements, running?: Readonly<Partial<Record<string, string>>>): RequirementMismatch[];
-
-/** Reads the surface's deps from inside `SurfaceContribution.attach`. */
-interface ContributionDepReader {
-    get<K extends DepName>(name: K): DepSchema[K] | undefined;
-}
-/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */
-interface ContributionFrameCtx {
-    /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one
-     *  frame see the same value. */
-    readonly time: number;
-    /** The surface camera this frame paints with. */
-    readonly view: View;
-    /** Ask for another frame. A hook animating something calls this every frame
-     *  it still has work for, and stops calling it to let the loop go idle. */
-    requestFrame(): void;
-    /** The surface's deps, as `attach` reads them. */
-    readonly deps: ContributionDepReader;
-}
-/**
- * A feature a surface installs in one step. Every role is optional: `bindings`,
- * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus
- * the ones below. Installing it installs every role it declares, and removing
- * it removes them.
- */
-interface SurfaceContribution extends Contribution {
-    /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */
-    views?: readonly CanvasViewProps[];
-    /**
-     * Runs once the surface mounts; returns its teardown. For what the roles
-     * above cannot say — a registered (hit-testable) layer, a subscription.
-     *
-     * Keyed by the function's identity, so a contribution built once (in a
-     * `useMemo`, or at module scope) attaches once however often the host
-     * re-renders.
-     */
-    attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;
-    /**
-     * Runs on every frame the surface paints, before the paint — for state the
-     * entry's layers read, advanced once per frame. Hooks run in the order the
-     * surface lists its entries (registered tools, then `ambient` in array
-     * order), and one that throws is reported and skipped without stopping the
-     * frame.
-     */
-    beforePaint?: (ctx: ContributionFrameCtx) => void;
-    /** Runs after a frame's pixels have landed, in the same order as
-     *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */
-    afterPaint?: (ctx: ContributionFrameCtx) => void;
-    /**
-     * The kit versions this entry was written against, as semver ranges:
-     * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the
-     * surface is set to `versionCheck="strict"`.
-     */
-    requires?: KitRequirements;
-}
-/**
- * Concatenate contribution bundles into one registry, preserving order. Throws
- * on a duplicate entry id, dep name or view id — two features answering for
- * the same name is a bug in whichever was added second.
- */
-declare function mergeContributions<T extends SurfaceContribution>(...bundles: readonly (readonly T[])[]): T[];
+declare function useKeyModifiers(options?: UseKeyStateOptions): KeyModifiers;
 
 /** Entry and layer id of the default feedback, so a host can find or order it. */
 declare const LONG_PRESS_FEEDBACK_ID = "long-press-feedback";
@@ -2629,6 +2742,13 @@ interface RenderSceneToPixelsArgs<TData, TLayer extends string, TPose> {
      *  output's top-left, one unit per output pixel. Annotations, watermarks,
      *  and `renderDebugSnapshot`'s overlay ride here. */
     overlay?: readonly DrawCommand[];
+    /** Draw the scene's annotation layers (`isAnnotationLayer`). Default
+     *  `false`: a raster is an export, which leaves them out as the SVG export
+     *  does. Pass `true` to reproduce the canvas as it looked. */
+    annotations?: boolean;
+    /** Screen space → output pixels, which `'screen'`-unit paint is measured in. Default: output pixels. A
+     *  raster standing in for part of a larger surface, such as an export's page, names the whole here. */
+    screen?: GlMat3;
 }
 /** The result of planning a headless render: how big the output is, the view
  *  that maps the source rect onto it, and the commands to draw. */
@@ -2774,6 +2894,8 @@ interface RenderDebugSnapshotArgs<TData, TLayer extends string, TPose> extends O
     /** Which overlay features to draw, as on `<Canvas debug>`. The frame panel
      *  shows the recorded paint cost but no rate: a still image has no frames. */
     config: DebugConfig;
+    /** Draw the scene's annotation layers. Default `true`, as the canvas did. */
+    annotations?: boolean;
 }
 /**
  * Rasterize the scene through `view` at `size` and paint the debug overlay
@@ -2794,18 +2916,18 @@ declare function rasterToPng(image: RasterImage): Promise<Blob>;
 /** Mount a `<PointerContextProvider>` only when none is already in scope. */
 declare function PointerProviderIfRoot({ children }: {
     children: ReactNode;
-}): React$1.JSX.Element;
+}): react.JSX.Element;
 
 /** Mount an `<ActionsProvider>` only when none is already in scope. */
 declare function ActionsProviderIfRoot({ children }: {
     children: ReactNode;
-}): React$1.JSX.Element;
+}): react.JSX.Element;
 
 /** Mount a `<DepRegistryProvider>` only when none is already in scope, so a
  *  consumer's dep sources are not shadowed by a nested canvas. */
 declare function DepRegistryProviderIfRoot({ children }: {
     children: ReactNode;
-}): React$1.JSX.Element;
+}): react.JSX.Element;
 
 /**
  * Open the menu for a right-click, or for Shift+F10 when `params` carry no client point. Reads
@@ -2847,18 +2969,14 @@ type PathGestureFamily = Exclude<keyof typeof PATH_GESTURE_TAGS, 'path'>;
 /** The tags of a path operation in `family`. */
 declare function pathOperationTags(family: PathGestureFamily): readonly string[];
 
-/**
- * The box of a node as drawn — its pose box with the stroke included — which
- * is what selection chrome, resize, rotate, and alignment sit on. Places that
- * store geometry (a group's derived pose, booleans, export) keep reading the
- * pose box through `framedBounds`.
- */
-
 /** The scene reads {@link drawnBoundsOf} makes. `childrenOf` absent: every
- *  node is a leaf. */
+ *  node is a leaf. `derivedPathOf` absent: every node is measured by its pose,
+ *  a path-derived one included — `drawnBoundsScene` supplies it for a `Scene`. */
 interface DrawnBoundsScene {
     get(id: NodeId): Node<unknown, string, unknown> | undefined;
     childrenOf?(id: NodeId): readonly NodeId[];
+    /** The path a node shows in place of its pose's, or `null` for one that shows its own. */
+    derivedPathOf?(id: NodeId): Path | null;
 }
 /** How {@link drawnBoundsOf} reads a node. */
 interface DrawnBoundsOptions {
@@ -2877,7 +2995,8 @@ interface DrawnBoundsOptions {
  * drawn in: a turned node's box comes back turned with it. A node with no
  * stroke, a painter that declares no {@link NodeShapeEntry.drawnBounds}, or
  * `includeStroke: false` answers `framedBounds` unchanged. A container's box
- * reaches as far as its members' boxes do.
+ * reaches as far as its members' boxes do. A node showing a derived path is
+ * boxed around that path, and its placeholder pose plays no part.
  */
 declare function drawnBoundsOf(scene: DrawnBoundsScene, id: NodeId, pose: unknown, opts?: DrawnBoundsOptions): FramedBox;
 /** How far `id`'s ink at `pose` reaches past its pose box on each side, in
@@ -2956,7 +3075,9 @@ interface UseAlignOptions<TPose> {
      *  the same value and the alignment runs entirely in stored coordinates. */
     composition?: PoseComposition<TPose>;
     /** The nodes behind the adapter's ids. With it, a stroked node aligns by
-     *  the box it is drawn with (`drawnBoundsOf`); without, by its pose box. */
+     *  the box it is drawn with (`drawnBoundsOf`); without, by its pose box.
+     *  Pass a `Scene` through `drawnBoundsScene` so a path-derived node is
+     *  boxed by its path. */
     scene?: DrawnBoundsScene;
     /** View scale a screen-pixel stroke is resolved at. Default 1. */
     viewScale?: () => number | Scale2;
@@ -3145,6 +3266,7 @@ declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose
     setChildOrder(parentId: string | null, ids: string[]): void;
     setData(id: string, data: unknown): void;
     setLayer(id: string, layer: string): void;
+    setDependsOn(id: string, dependsOn: readonly string[] | "children" | undefined): void;
     setLayout(id: string, layout: string | LayoutStrategy<TPose> | null): void;
     setHidden(id: string, hidden: boolean): void;
     setLocked(id: string, locked: boolean): void;
@@ -3182,6 +3304,14 @@ declare const flipAction: Action & {
     requires: string[];
 };
 
+/** Options for {@link createResizeAction}. */
+interface ResizeActionOptions {
+    /** Runs in place of the scene commit, handed each resized node's pose at
+     *  release, so a host keeping the geometry as data can store it. The scene
+     *  is left as it was, and no undo entry is made; the constraints' `onEnd`
+     *  answers are not asked for. */
+    commit?: (poses: ReadonlyMap<NodeId, unknown>, deps: ActionDeps) => void;
+}
 /**
  * Anchor-relative drag resize, committed as one batch on release. It needs
  * `InvocationCtx.drag.affordance` with a `handle:*` kind.
@@ -3192,6 +3322,10 @@ declare const flipAction: Action & {
  * carries the constraints, point snaps, and `expandIds`; absent, the invoker
  * runs no constraints and `ids => ids` expansion.
  */
+declare function createResizeAction(opts?: ResizeActionOptions): Action & {
+    requires: string[];
+};
+/** The resize that commits to the scene. */
 declare const resizeAction: Action & {
     requires: string[];
 };
@@ -3628,6 +3762,34 @@ declare const sliceAction: Action & {
     requires: string[];
 };
 
+/**
+ * Delete ops for the sources a removal of `ids` takes with it (see
+ * `hiddenSourcesTakenWith`), for an action whose own ops remove `ids` some
+ * other way. Append them after those ops: a delete finds its slot as it runs.
+ * Sources in `keep` stay.
+ */
+declare function hiddenSourceDeleteOps(scene: Scene<unknown, string, unknown>, ids: readonly NodeId[], label: string, keep?: ReadonlySet<NodeId>): Op[];
+/** Options for {@link createDeleteAction}. */
+interface DeleteActionOptions {
+    /** Runs in place of the default, {@link commitDeleteToScene}. */
+    commit?: (ids: readonly NodeId[], deps: ActionDeps) => void;
+}
+/** The default commit: removes `ids`, their dependents, and the sources a
+ *  path effect among them hid, as one undo entry, then empties the selection. */
+declare function commitDeleteToScene(ids: readonly NodeId[], deps: ActionDeps): void;
+/** Delete on Delete and Backspace: hands the selected ids to `commit`. */
+declare function createDeleteAction(opts?: DeleteActionOptions): Action & {
+    requires: string[];
+};
+/**
+ * Removes every selected node from the scene as one undo entry. Undo restores
+ * everything the removal cascaded — a container's children and a deleted
+ * node's dependents come back with it, at their own slots.
+ */
+declare const deleteAction: Action & {
+    requires: string[];
+};
+
 /**
  * Tuning for {@link makePinchZoomAction}.
  */
@@ -3663,7 +3825,8 @@ declare const clipboardCopyAction: Action & {
 };
 /**
  * Static descriptor for the `clipboard.cut` Action (Cmd/Ctrl+X) — copy, then
- * the same batched delete `deleteAction` performs, as one undo entry.
+ * the same batched delete `deleteAction` performs, as one undo entry: the
+ * sources a path effect hid go too.
  */
 declare const clipboardCutAction: Action & {
     requires: string[];
@@ -4323,318 +4486,6 @@ interface UseStickyToolOptions extends InsertToolOptions, StickyStyle {
  */
 declare function useStickyTool(options?: UseStickyToolOptions): Tool;
 
-/** The part of a scene a rig's skins read and write. */
-interface SkinScene<TPose> {
-    get(id: NodeId): {
-        pose: TPose;
-        data?: unknown;
-    } | undefined;
-    readonly overrides: PoseOverrides<TPose>;
-    setPose(id: NodeId, pose: TPose): void;
-    update(id: NodeId, patch: {
-        data: never;
-    }): void;
-}
-/** Where a node's path is drawn, for a skin to bend: `null` for a node with none. */
-type RestPath<TPose> = (node: {
-    pose: TPose;
-    data?: unknown;
-}) => Path | null;
-/** The path in a node's `data.path`, carried through its pose as `kit:path` paints it. */
-declare function dataRestPath<TPose>(node: {
-    pose: TPose;
-    data?: unknown;
-}): Path | null;
-
-/** The part of a scene a rig writes to. */
-interface RigScene<TPose> extends SkinScene<TPose> {
-    batch<T>(label: string, fn: () => T): T;
-}
-/** What a `RigApply` knows about the node it is posing. */
-interface RigApplyContext<TPose> {
-    /** The joint the node rides. */
-    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;
-/** Options for `bindRig`. */
-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[]>>;
-    /** Node id → the weights its path bends by. Where a bound node moves whole with one joint,
-     *  a skinned node's points each follow their own joints, and the rig shows the bent path
-     *  through the node's pose override, posed at the path's bounds. */
-    skins?: Readonly<Record<NodeId, Skin>>;
-    /** Where a skinned node's path is drawn when the rig is bound. Default
-     *  {@link dataRestPath}: the node's `data.path`, through its pose. */
-    restPath?: RestPath<TPose>;
-    /** 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>;
-}
-/** A skeleton bound to scene nodes, as `bindRig` returns it. */
-interface Rig {
-    readonly skeleton: Skeleton;
-    /**
-     * The rig's pose as a value an animator moves. Its committed value starts as `{}`, the bind
-     * pose, and each frame the rig is posed with what the target shows. A clip is a
-     * `SampledTrack<Pose>` given this as its `target`: clips on one rig crossfade by their
-     * `weight`s, weights short of 1 leave the rest to the committed pose, and a `spring` or
-     * `tween` from a pose away from the committed one adds on top. `animator.hold` shows a pose made elsewhere the same way, an
-     * IK solve included.
-     */
-    readonly target: Target<Pose>;
-    /**
-     * Commit `pose` and move every bound node to what the target now shows, which is `pose`
-     * unless something is animating the target; a hold on it weighs the new pose in when it is
-     * next read, at the animator's next frame or the hold's `touch()`. Writes go through the scene's pose overrides —
-     * no history entry, no document write, no version bump — and are committed. `root`, where
-     * given, replaces the placement, as {@link Rig.place}.
-     */
-    pose(pose: Pose, root?: GlMat3): void;
-    /** Place the rig in the world by `root`, which may mirror it, and pose it there. It stays
-     *  until placed again; with no `root`, the rig goes back to where its skeleton puts it. */
-    place(root?: GlMat3): void;
-    /** The joint world transforms as the rig was last posed, root applied. */
-    world(): ReadonlyMap<string, GlMat3>;
-    /** Write the current frame into the bound nodes' document poses as one
-     *  undo entry, and drop the overrides. A skinned node's bent path goes into
-     *  its `data.path`. 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
-     *  rig is next posed. */
-    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;
-
-/** What a rig reads from node data: a `skeleton` on the node that is the rig, and on the nodes
- *  under it a `skin` for a path that bends or a `joint` for a node that rides one whole. */
-interface RigNodeData {
-    /** Joints relative to the node's pose: its box's top-left corner, turned as the node is. */
-    skeleton?: Skeleton;
-    skin?: Skin;
-    joint?: string;
-}
-/** Weights to bind in place of the document's, and word of when they change. A `RigEditState`
- *  is one: it holds what a stroke of the weight tool has painted and not yet written. */
-interface PaintedSkins {
-    /** By node. A new map whenever the weights change. */
-    painted(): ReadonlyMap<NodeId, Skin>;
-    listen(fn: () => void): () => void;
-}
-/** The part of a scene `rigFromNode` reads. */
-interface RigNodeSource<TPose> {
-    get(id: NodeId): {
-        pose: TPose;
-        data?: unknown;
-    } | undefined;
-    childrenOf(id: NodeId): readonly NodeId[];
-}
-/** The skeleton, bindings, and skins a rig node declares, as `bindRig` takes them. */
-interface RigNodeParts {
-    skeleton: Skeleton;
-    bindings: Record<string, NodeId[]>;
-    skins: Record<NodeId, Skin>;
-}
-/**
- * A skeleton as a rig node's data keeps it, moved to where the node's pose puts it: its root
- * joints are offset from the pose box's top-left corner and turned as the node is. Joints
- * under a root are relative to their parents and are left as they are.
- */
-declare function placeSkeleton<TPose>(skeleton: Skeleton, pose: TPose, descriptor?: PoseDescriptor<TPose>): Skeleton;
-/** The inverse of {@link placeSkeleton}: a skeleton in the scene's space, as the node at
- *  `pose` would keep it in its data. */
-declare function unplaceSkeleton<TPose>(skeleton: Skeleton, pose: TPose, descriptor?: PoseDescriptor<TPose>): Skeleton;
-/**
- * Read a rig out of the scene: the skeleton in `id`'s `data.skeleton`, placed by that node's
- * pose, and under it every node whose data has a `skin` or names a `joint`.
- */
-declare function rigFromNode<TPose>(scene: RigNodeSource<TPose>, id: NodeId, descriptor?: PoseDescriptor<TPose>): RigNodeParts;
-/** Options for `useRigNode`. */
-interface UseRigNodeOptions<TPose> extends Pick<BindRigOptions<TPose>, 'apply' | 'descriptor' | 'restPath'> {
-    scene: RigScene<TPose> & RigNodeSource<TPose> & {
-        subscribe(listener: () => void): () => void;
-        getVersion(): number;
-    };
-    /** The node whose data holds the skeleton. */
-    node: NodeId;
-    /** Weights bound in place of a node's `data.skin` while they are held. Give it the
-     *  `RigEditState` the weight tool has, and a stroke bends the path as it is painted. */
-    painting?: PaintedSkins;
-}
-/**
- * A {@link Rig} read from a node, as {@link rigFromNode} reads it. It is bound again when the
- * rig node or a node under it changes its pose or data, or when nodes under it come or go; an
- * edit elsewhere in the scene leaves it alone. A rig bound again keeps its `target`, with the
- * animations running on it, its committed pose, and its placement, unless the skeleton's
- * joints were added, removed, renamed, or reordered. Then it has a new `target`, which takes
- * over the placement and the pose of every joint the skeleton still names. Animations go on
- * running on the target they were started on and show through the new one, so a joint that
- * was renamed stops moving.
- */
-declare function useRigNode<TPose>(options: UseRigNodeOptions<TPose>): Rig;
-
-/** What the bone and weight tools share between gestures: the joint they act on, and the
- *  weights a stroke has painted and not yet written. */
-interface RigEditState extends PaintedSkins {
-    /** The active joint's name, or `null`. */
-    active(): string | null;
-    setActive(joint: string | null): void;
-    /** Weights a stroke of the weight tool has painted and not yet written, by node. Empty
-     *  between strokes. `useRigNode` given this state as `painting` binds them as they change. */
-    painted(): ReadonlyMap<NodeId, Skin>;
-    /** Replace the painted weights; `null` empties them. */
-    paint(next: ReadonlyMap<NodeId, Skin> | null): void;
-    /** Notified when the active joint or the painted weights change. Returns an unsubscribe. */
-    listen(fn: () => void): () => void;
-}
-/** A `RigEditState` with no joint active. Hand one to both tools so a joint picked with the
- *  bone tool is the one the weight tool paints. */
-declare function createRigEditState(): RigEditState;
-
-/** Options for `useBoneTool`. */
-interface UseBoneToolOptions {
-    scene: Scene<unknown, string, unknown>;
-    /** The node whose data holds the skeleton, or will once a bone is drawn: usually read from
-     *  the selection. `null` leaves the tool with nothing to edit. */
-    rig: () => NodeId | null;
-    /** Shared with `useWeightTool`, so both act on one joint. Default: the tool's own. */
-    state?: RigEditState;
-    /** Override the default keybinding (`{ key: 'J' }`). Pass `null` to omit. */
-    keybinding?: ToolKeybinding | null;
-    /** Screen px around a joint within which a press takes it. Default 10. */
-    reach?: number;
-}
-/**
- * Draws and edits the skeleton in a node's `data.skeleton`. A drag on a joint moves it, with
- * the joints under it; a drag from anywhere else draws a bone, from the active joint if there
- * is one and from the press if not, and the new joint becomes the active one. A click picks
- * the active joint or clears it, Delete removes it with everything under it, taking its
- * weights out of every skin beneath the rig node, and Escape clears it. Each edit is one undo
- * entry.
- */
-declare function useBoneTool(options: UseBoneToolOptions): Tool;
-
-/** A rig node and its skeleton in the scene's space, as the rig tools edit and draw it. */
-interface PlacedRig {
-    id: NodeId;
-    skeleton: Skeleton;
-}
-/** The rig at node `id`, an empty skeleton for a node that has none yet, or `null` when
- *  there is no such node. */
-declare function placedRig(scene: {
-    get(id: NodeId): {
-        pose: unknown;
-        data?: unknown;
-    } | undefined;
-}, id: NodeId | null): PlacedRig | null;
-
-/**
- * A screen-space layer drawing a skeleton as bones and joints at a constant size: a line from
- * each joint to its parent, a ring on each joint, and the active joint filled.
- */
-declare function createBoneOverlay(source: {
-    id: string;
-    /** The skeleton to draw, in the scene's space, or `null` for none. */
-    skeleton(): Skeleton | null;
-    active(): string | null;
-    subscribe(fn: () => void): () => void;
-    /** Joint dot radius in screen px, read each frame. Default `JOINT_RADIUS_PX`. */
-    jointRadiusPx?: () => number | undefined;
-}): RenderLayer<unknown>;
-
-/** Options for `useWeightTool`. */
-interface UseWeightToolOptions {
-    scene: Scene<unknown, string, unknown>;
-    /** The node whose data holds the skeleton; the tool paints the paths under it. */
-    rig: () => NodeId | null;
-    /** Shared with `useBoneTool`, so both act on one joint. Default: the tool's own. */
-    state?: RigEditState;
-    /** Override the default keybinding (`{ key: 'W' }`). Pass `null` to omit. */
-    keybinding?: ToolKeybinding | null;
-    /** The brush's radius in screen px. Default 24. */
-    radius?: number;
-    /** Screen px around a joint within which a click picks it. Default 10. */
-    reach?: number;
-}
-/**
- * Paints how much the active joint weighs each point of the paths under a rig node, into
- * their `data.skin`. A click on a joint makes it the active one. A drag is a round brush:
- * points under it follow the active joint more, the nearer the brush's center, and their
- * other joints give way; with Alt held they follow it less. A click away from any joint is
- * one dab. Every point shows as a dot colored by the active joint's share of it. A stroke is
- * one undo entry, and until it ends its weights are in `state.painted()`, which `useRigNode`
- * binds when given the same `state` as `painting`.
- */
-declare function useWeightTool(options: UseWeightToolOptions): Tool;
-
-/** One path under the rig node, where it is drawn, with the weights now showing. */
-interface WeighedPath {
-    id: NodeId;
-    path: PolygonPath;
-    skin: Skin;
-}
-/** What the weight tool's actions read and write, all of it the tool's own. */
-interface WeightEnv {
-    scene(): Scene<unknown, string, unknown>;
-    placed(): PlacedRig | null;
-    state: RigEditState;
-    /** Screen px around a joint within which a click picks it. */
-    reachPx(): number;
-    /** The brush's radius in screen px. */
-    radiusPx(): number;
-    /** Weights a stroke has painted and not yet committed, by node. */
-    painted(): ReadonlyMap<NodeId, Skin>;
-    paint(next: ReadonlyMap<NodeId, Skin> | null): void;
-}
-/** Every path under the rig node, with what `env.painted()` holds for it in place of its
- *  `data.skin`. */
-declare function weighedPaths(env: Pick<WeightEnv, 'scene' | 'placed' | 'painted'>): WeighedPath[];
-
-/**
- * A screen-space layer drawing a dot on every point of every path under a rig, anchors and
- * curve handles alike, colored by how much the active joint weighs it. With no joint active
- * the dots are gray.
- */
-declare function createWeightOverlay(source: {
-    id: string;
-    paths(): readonly WeighedPath[];
-    active(): string | null;
-    subscribe(fn: () => void): () => void;
-    /** Point dot radius in screen px, read each frame. Default `POINT_RADIUS_PX`. */
-    pointRadiusPx?: () => number | undefined;
-}): RenderLayer<unknown>;
-
 /**
  * In-progress pen anchor. A click places a corner, with no handles. A drag
  * sets `outHandle` to the drag point and `inHandle` to its mirror through
@@ -5297,6 +5148,8 @@ interface UseHoverTrackingArgs {
         id: NodeId;
     } | null;
     enabled?: boolean;
+    /** Called when the hovered id changes, `null` once the pointer is over no node or has left. */
+    onChange?: (id: NodeId | null) => void;
 }
 /** What `useHoverTracking` returns. Both members keep their identity. */
 interface HoverTracking {
@@ -5381,95 +5234,33 @@ interface SceneCanvasPointerProps {
      *  behavior, so a pick it made is already in the selection, and fires
      *  again on a node that was already picked. */
     onClick?: (hit: SceneCanvasHit | null) => void;
+    /** Called when the topmost pickable node under the pointer changes, with
+     *  its id, and with `null` once there is none or the pointer leaves. */
+    onHover?: (id: string | null) => void;
+}
+
+/** The `<SceneCanvas>` props that change the actions and bindings a canvas has. */
+interface SceneCanvasActionProps {
+    /**
+     * Tune actions on this canvas without restating them, keyed by action id:
+     * `params` every invocation starts from, and `bindings` added beside the
+     * action's own. A tuning applies to whichever descriptor holds the id, a
+     * preset's or a tool's. Pass a stable object; a params thunk is read on
+     * every call. See the core README ("Tuning an action").
+     */
+    tune?: ActionTunings;
+    /**
+     * Replace or remove bindings by binding id, on actions and contributions
+     * alike: a route string (`'[*:*] keyDown(=) +mod'`), a spec (`key('Mod+=')`),
+     * or `null` to unbind. Pass a stable object.
+     */
+    bindingOverrides?: BindingOverrides;
+    /**
+     * Replace, add or mute whole action descriptors. Pass `null` to disable
+     * all defaults. To change a built-in's params or add a key, use `tune`.
+     */
+    actions?: ActionsProp;
 }
-
-/**
- * The kit's built-in shape kinds — one table, every other spelling derived.
- *
- * This module imports nothing on purpose: `useBuiltinShapeTools` imports the
- * package barrel, so anything barrel-reachable that needs these lists at
- * module-evaluation time must not route through it.
- */
-/** What the kit knows about one built-in shape kind. */
-interface ShapeKindDescriptor {
-    /** Mounted as a built-in shape tool by `useBuiltinShapeTools`, and so a
-     *  member of `BuiltinShapeToolId` / `KIT_SHAPE_KINDS`. `image` is false:
-     *  `useImageTool` needs a `src` and can't be auto-mounted. */
-    readonly tool: boolean;
-    /** `insertAction` emits an `insertPreview` overlay for this kind, and the
-     *  dispatcher overlay layer knows how to draw it. Kinds without one still
-     *  commit; they just have no live drag preview. */
-    readonly insertPreview: boolean;
-    /** A node of this kind is a text node: an insert drops into its caret, and
-     *  its properties carry the text groups. Absent, it is not. */
-    readonly text?: boolean;
-}
-/**
- * Declaration order is the enumeration order of every derived list —
- * `KIT_SHAPE_KINDS`, and through it `defaultNodeRouting` /
- * `defaultNodeProperties` / `BUILTIN_TOOL_IDS`.
- */
-declare const SHAPE_KINDS: {
-    readonly rect: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly ellipse: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly line: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly polygon: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly star: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly pen: {
-        readonly tool: true;
-        readonly insertPreview: false;
-    };
-    readonly pencil: {
-        readonly tool: true;
-        readonly insertPreview: true;
-    };
-    readonly lasso: {
-        readonly tool: true;
-        readonly insertPreview: false;
-    };
-    readonly text: {
-        readonly tool: true;
-        readonly insertPreview: true;
-        readonly text: true;
-    };
-    readonly sticky: {
-        readonly tool: true;
-        readonly insertPreview: true;
-        readonly text: true;
-    };
-    readonly image: {
-        readonly tool: false;
-        readonly insertPreview: true;
-    };
-};
-/** Every kind in the table, tool or not. */
-type ShapeKind = keyof typeof SHAPE_KINDS;
-/** The keys of a shape-kind table whose descriptor sets `F` to `true`. */
-type ShapeKindsWhere<T, F extends keyof ShapeKindDescriptor> = {
-    [K in keyof T]: T[K] extends Record<F, true> ? K : never;
-}[keyof T];
-/** Built-in shape tool ids handled by `useBuiltinShapeTools`. */
-type BuiltinShapeToolId = ShapeKindsWhere<typeof SHAPE_KINDS, 'tool'>;
-/** The insert kinds the kit's dispatcher overlay layer knows how to render.
- *  Consumer-defined kinds fall outside it: no live preview, commit unaffected. */
-type KitInsertShape = ShapeKindsWhere<typeof SHAPE_KINDS, 'insertPreview'>;
-/** Runtime, iterable list of the shape-tool ids in `BuiltinShapeToolId`. */
-declare const KIT_SHAPE_KINDS: readonly BuiltinShapeToolId[];
 
 /**
  * Turns pasted or dropped plain text into a text node sized to the string. Registered nowhere by
@@ -5606,6 +5397,9 @@ interface NodeRouting {
     /** Enumerate registered kinds in registration order. */
     list(): readonly NodeRoutingEntry[];
 }
+/** The routing kind of a node: the name of the first entry whose `matches(data, node)` returns
+ *  true, or `'unknown'`. What `NodeRouting.classify` answers, for a caller holding a plain list. */
+declare function routeKind(entries: readonly NodeRoutingEntry[], data: unknown, node?: RoutedNode): string;
 /** Build a registry of per-node-kind routing entries. Registering a duplicate
  *  kind name throws. */
 declare function createNodeRouting(): NodeRouting;
@@ -6212,6 +6006,12 @@ interface CanvasProps<TPose = unknown> extends SurfaceSizeProps {
      *  zoom, whatever the scene's world unit. A number holds a fixed world
      *  tolerance instead. */
     flattenTolerance?: FlattenTolerance;
+    /** How images drawn smaller than their pixels are filtered, forwarded to
+     *  `WeaselRendererOptions.imageMinification`. Default `'linear'`, one tap,
+     *  which aliases an image drawn at half size or less; `'auto'` builds an
+     *  image's mipmaps the first time a frame draws it that small. Changing it
+     *  re-uploads every image. */
+    imageMinification?: ImageMinification;
     /** Which unchanged layers the renderer keeps as pixels between frames and
      *  composites as one quad, instead of drawing their commands again — see
      *  `RenderLayer.retain` and `LayerRetainPolicy`. `false` retains no layer on
@@ -6298,11 +6098,14 @@ interface CanvasProps<TPose = unknown> extends SurfaceSizeProps {
     /** Inline style for the `<canvas>` this component renders; a tool's cursor
      *  is merged over it. Not applied under `paintInto`, where only that cursor
      *  is written, onto the input element. */
-    style?: React__default.CSSProperties;
+    style?: react__default.CSSProperties;
     /** Tab order of the `<canvas>` this component renders. Default 0, so the
      *  canvas is focusable. Not applied under `paintInto`: whether the input
      *  element can take focus is the caller's to decide. */
     tabIndex?: number;
+    /** Accessible name of the `<canvas>` this component renders; devtools lists the canvas under it.
+     *  Not applied under `paintInto`. */
+    'aria-label'?: string;
     /** Fired when the element input comes from gains focus: the canvas, or
      *  under `paintInto` the `inputElement`. Called with the DOM event. */
     onFocus?: (event: FocusEvent) => void;
@@ -6327,7 +6130,7 @@ interface CanvasProps<TPose = unknown> extends SurfaceSizeProps {
      * (move/resize/rotate) instead of the committed scene; an id outside the active overlay
      * falls back to the adapter.
      */
-    helpersRef?: React__default.MutableRefObject<CanvasHelpers<TPose> | null>;
+    helpersRef?: react__default.MutableRefObject<CanvasHelpers<TPose> | null>;
     /**
      * Debug overlay configuration.
      *  - `undefined` (default): read `?debug=…` from the URL.
@@ -6341,7 +6144,7 @@ interface CanvasProps<TPose = unknown> extends SurfaceSizeProps {
     debug?: DebugConfig | false;
     /** Test-only escape hatch: writes the live debug sink to this ref so tests
      *  can call `snapshot()` after a render. No effect when debug is off. */
-    debugSinkRef?: React__default.MutableRefObject<CanvasDebugSink | null>;
+    debugSinkRef?: react__default.MutableRefObject<CanvasDebugSink | null>;
     /**
      * Shader programs to compile before the frame that first draws them; one
      * not named here compiles on that frame. Each handle comes from a
@@ -6414,6 +6217,115 @@ interface CanvasProps<TPose = unknown> extends SurfaceSizeProps {
  *  Pass a stable object: a new one each render re-registers it. */
 declare function useSnapSource(source: SnapSource): void;
 
+/**
+ * Add a follower to the `transformFollowers` dep for the lifetime of the
+ * calling component, after every one already there in its scope and the
+ * scopes above. `follower` is read each time the dep is; answering null adds
+ * nothing.
+ */
+declare function useTransformFollower(follower: () => TransformFollower | null): void;
+
+/**
+ * The kit's built-in shape kinds — one table, every other spelling derived.
+ *
+ * This module imports nothing on purpose: `useBuiltinShapeTools` imports the
+ * package barrel, so anything barrel-reachable that needs these lists at
+ * module-evaluation time must not route through it.
+ */
+/** What the kit knows about one built-in shape kind. */
+interface ShapeKindDescriptor {
+    /** Mounted as a built-in shape tool by `useBuiltinShapeTools`, and so a
+     *  member of `BuiltinShapeToolId` / `KIT_SHAPE_KINDS`. `image` is false:
+     *  `useImageTool` needs a `src` and can't be auto-mounted. */
+    readonly tool: boolean;
+    /** `insertAction` emits an `insertPreview` overlay for this kind, and the
+     *  dispatcher overlay layer knows how to draw it. Kinds without one still
+     *  commit; they just have no live drag preview. */
+    readonly insertPreview: boolean;
+    /** The tool family a kind with a tool belongs to: which built-in tool set
+     *  names it, and so which palette group it sits in. */
+    readonly family?: 'shape' | 'draw' | 'select' | 'type';
+    /** A node of this kind is a text node: an insert drops into its caret, and
+     *  its properties carry the text groups. Absent, it is not. */
+    readonly text?: boolean;
+}
+/**
+ * Declaration order is the enumeration order of every derived list —
+ * `KIT_SHAPE_KINDS`, and through it `defaultNodeRouting` /
+ * `defaultNodeProperties` / `BUILTIN_TOOL_IDS`.
+ */
+declare const SHAPE_KINDS: {
+    readonly rect: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "shape";
+    };
+    readonly ellipse: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "shape";
+    };
+    readonly line: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "shape";
+    };
+    readonly polygon: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "shape";
+    };
+    readonly star: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "shape";
+    };
+    readonly pen: {
+        readonly tool: true;
+        readonly insertPreview: false;
+        readonly family: "draw";
+    };
+    readonly pencil: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly family: "draw";
+    };
+    readonly lasso: {
+        readonly tool: true;
+        readonly insertPreview: false;
+        readonly family: "select";
+    };
+    readonly text: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly text: true;
+        readonly family: "type";
+    };
+    readonly sticky: {
+        readonly tool: true;
+        readonly insertPreview: true;
+        readonly text: true;
+        readonly family: "type";
+    };
+    readonly image: {
+        readonly tool: false;
+        readonly insertPreview: true;
+    };
+};
+/** Every kind in the table, tool or not. */
+type ShapeKind = keyof typeof SHAPE_KINDS;
+/** The keys of a shape-kind table whose descriptor sets `F` to `true`. */
+type ShapeKindsWhere<T, F extends keyof ShapeKindDescriptor> = {
+    [K in keyof T]: T[K] extends Record<F, true> ? K : never;
+}[keyof T];
+/** Built-in shape tool ids handled by `useBuiltinShapeTools`. */
+type BuiltinShapeToolId = ShapeKindsWhere<typeof SHAPE_KINDS, 'tool'>;
+/** The insert kinds the kit's dispatcher overlay layer knows how to render.
+ *  Consumer-defined kinds fall outside it: no live preview, commit unaffected. */
+type KitInsertShape = ShapeKindsWhere<typeof SHAPE_KINDS, 'insertPreview'>;
+/** Runtime, iterable list of the shape-tool ids in `BuiltinShapeToolId`. */
+declare const KIT_SHAPE_KINDS: readonly BuiltinShapeToolId[];
+
 /** Per-tool option overrides for the built-in tools.
  *  Each entry is a narrow subset of the underlying hook's options surface
  *  — just the knobs that need consumer control under the bundle pattern. */
@@ -6433,20 +6345,6 @@ interface BuiltinToolOptions {
     slice?: {
         closeHitRadius?: number;
     };
-    /** The bone and weight tools. `rig` names the node they edit; by default the one
-     *  selected node, or the nearest ancestor of it holding `data.skeleton`. `state` is the
-     *  joint they share, which a canvas otherwise makes for itself; pass the one handed to
-     *  `useRigNode` as `painting` so a stroke shows as it is painted. `reach` is the screen
-     *  px around a joint within which a press takes it. */
-    rig?: {
-        rig?: () => NodeId | null;
-        state?: RigEditState;
-        reach?: number;
-    };
-    /** The weight tool's brush radius, in screen px. */
-    weight?: {
-        radius?: number;
-    };
 }
 
 /** How a surface treats an entry whose `requires` the running kit does not
@@ -6492,6 +6390,26 @@ interface SceneCanvasViewport {
     recenter?: () => View | void;
 }
 
+/** Built-in tool ids SceneCanvas knows how to mount, through `defaultTools` or a preset. */
+type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId | 'slice';
+/** The selection tools: click and marquee, and the lasso. */
+declare const SELECT_TOOLS: ToolSet<BuiltinToolId>;
+/** The view tools. */
+declare const VIEW_TOOLS: ToolSet<BuiltinToolId>;
+/** The tools that drag out a closed or open primitive. */
+declare const SHAPE_TOOLS: ToolSet<BuiltinToolId>;
+/** The freehand and bezier path tools. */
+declare const DRAW_TOOLS: ToolSet<BuiltinToolId>;
+/** The text tools: text and the sticky note. */
+declare const TYPE_TOOLS: ToolSet<BuiltinToolId>;
+/** The tools that cut the page itself. */
+declare const PAGE_TOOLS: ToolSet<BuiltinToolId>;
+/** Every built-in tool, in palette order: the navigation tools, the shape-kind
+ *  table's tools in its order, then the knife. */
+declare const BUILTIN_TOOLS: ToolSet<BuiltinToolId>;
+/** Every built-in tool id, in palette order: {@link BUILTIN_TOOLS} opened. */
+declare const BUILTIN_TOOL_IDS: readonly BuiltinToolId[];
+
 /** Default size in CSS pixels for selection corner-handles AND their
  *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal
  *  use sites multiply by `DeviceProfile.targetScale`. */
@@ -6518,12 +6436,6 @@ interface SceneCanvasLongPress {
 type SceneCanvasLayers<TNode extends {
     id: string;
 }, TPose> = LayersMap<TNode, TPose, Partial<SceneSlotConfig<TNode, TPose>>>;
-/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop
- *  is supplied, via `defaultTools`. */
-type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId | 'slice' | 'bone' | 'weight';
-/** Every built-in tool id, in palette order: the navigation tools, the shape
- *  tools of the `core/shapeKinds` table, then the knife and the rig tools. */
-declare const BUILTIN_TOOL_IDS: readonly BuiltinToolId[];
 
 /** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing
  *  else it renders that scene and keeps a selection no input sets; `features`
@@ -6593,8 +6505,8 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     selectTool?: {
         move?: UseMoveOptions<TPose>;
         resize?: UseResizeOptions<TPose>;
-        /** Rotation options, or `false` to disable rotation entirely — drops the
-         *  `rotate` action AND hides the selection rotation-handle chrome. */
+        /** Rotation options, or `false` to hide the rotation handle and bind it to
+         *  nothing; the `rotate` action stays, for other tools and `actions.rotate`. */
         rotate?: UseRotateOptions<TPose> | false;
         handleHitRadius?: number;
         /** Override the body-pick used on click/pointerdown. Alt-aware: receives
@@ -6706,8 +6618,8 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,
      *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown
      *      built-in ids warn in dev and are ignored.
-     *    - `Tool` adds a new id or replaces an existing one
-     *      (dev-only warning on replace).
+     *    - `Tool` adds a new id or replaces an existing one in place
+     *      (dev-only warning if `defaultTools` also names that id).
      *    - `false` omits a bundled tool entirely.
      *  Auto-wiring (keybindings, dispatcher, action registry) still runs.
      *
@@ -6745,12 +6657,13 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     onToolsCreated?: (tools: ToolsApi) => void;
     /**
      * Built-in tools SceneCanvas registers in its internal `useTools`, on top
-     * of the ones presets bring (`select` from `pick`, `hand` from `view`).
+     * of the ones presets bring (`select` from `pick`, `hand` from `view`):
+     * ids, or sets of them such as `SHAPE_TOOLS`, or `withoutTools(...)` of one.
      * Default: none. Each tool also registers the kit actions it binds, so
      * `['rect']` brings `insert`. Ignored when the consumer supplies their own
      * `tools` prop.
      */
-    defaultTools?: readonly BuiltinToolId[];
+    defaultTools?: readonly ToolEntry<BuiltinToolId>[];
     /** Per-tool option overrides for the built-in tools. Each entry is a
      *  narrow subset of the underlying hook's options surface — `lasso.mode`,
      *  `rig.state`, etc. */
@@ -6778,25 +6691,12 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     longPress?: SceneCanvasLongPress;
     /** Configures the `view` preset, and implies it. See {@link SceneCanvasViewport}. */
     viewport?: SceneCanvasViewport;
-    /**
-     * Tune actions on this canvas without restating them, keyed by action id:
-     * `params` every invocation starts from, and `bindings` added beside the
-     * action's own. A tuning applies to whichever descriptor holds the id, a
-     * preset's or a tool's. Pass a stable object; a params thunk is read on
-     * every call. See the core README ("Tuning an action").
-     */
-    tune?: ActionTunings;
-    /**
-     * Replace, add or mute whole action descriptors. Pass `null` to disable
-     * all defaults. To change a built-in's params or add a key, use `tune`.
-     */
-    actions?: ActionsProp;
     /**
      * Given a scene node, return a short human-readable "kind" label (e.g. `'rectangle'`,
      * `'sticky note'`), which the kit publishes per id into any surrounding
      * `<SelectionContextProvider>`. Return `undefined` to skip an entry. When omitted,
-     * containers report `'group'`, poses with a `kind` property report `'path'`, and
-     * everything else is left unlabelled.
+     * each node reports its routing kind (see `routing`), and a node that routes as
+     * `'unknown'` is left unlabeled.
      */
     describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;
     /**
@@ -6912,7 +6812,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      * nor picked here. See `CanvasProps.layerOrder`.
      */
     layerOrder?: string[];
-} & SceneCanvasPointerProps;
+} & SceneCanvasPointerProps & SceneCanvasActionProps;
 
 /**
  * The behavior presets `<SceneCanvas features>` composes. A bare canvas renders
@@ -6960,8 +6860,8 @@ interface FeaturePreset {
      *  are standard actions: `<SceneCanvas actions>` overrides and mutes them,
      *  and `tune` reaches them. */
     readonly actions?: readonly Action[];
-    /** Tools it mounts: a built-in by id, or a tool of its own. */
-    readonly tools?: readonly (BuiltinToolId | Tool)[];
+    /** Tools it mounts: a built-in by id or a set of them, or a tool of its own. */
+    readonly tools?: readonly (ToolEntry<BuiltinToolId> | Tool)[];
     /** Its ambient bindings: an always-live entry routing a gesture to its
      *  actions under any tool that does not claim the gesture itself. */
     readonly ambient?: (options: FeatureBindingOptions) => Contribution;
@@ -7040,7 +6940,7 @@ declare function rotateAroundAABBCenter(x: number, y: number, width: number, hei
 
 declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose> & {
     presetSource: PresetSource;
-}, ref: React__default.ForwardedRef<SceneCanvasApi>): React__default.JSX.Element;
+}, ref: react__default.ForwardedRef<SceneCanvasApi>): react__default.JSX.Element;
 /**
  * The canvas component: renders a `Scene` and wires the interaction stack
  * around it.
@@ -7056,9 +6956,16 @@ declare function SceneCanvasInner<TData, TLayer extends string, TPose>(props: Sc
  * fit a prop (view control, hit queries, redraw requests).
  */
 declare const SceneCanvas: <TData, TLayer extends string, TPose>(props: SceneCanvasProps<TData, TLayer, TPose> & {
-    ref?: React__default.Ref<SceneCanvasApi>;
+    ref?: react__default.Ref<SceneCanvasApi>;
 }) => ReturnType<typeof SceneCanvasInner>;
 
+/**
+ * What a canvas's WebGL2 context is opened with. A context keeps the attributes of whoever opened it
+ * first, and the renderer refuses one without a stencil buffer, so anything that may open a weasel
+ * canvas before its first paint (a pixel reader in a test, a tenant sharing the buffer) asks for these.
+ */
+declare const CANVAS_CONTEXT_ATTRIBUTES: Readonly<WebGLContextAttributes>;
+
 /** How each `polyline` overlay role reads. An action publishes the run and
  *  the word; this table is the whole of the paint, for the dispatcher overlay
  *  and for any tool previewing the same kind of run between gestures. */
@@ -7078,8 +6985,8 @@ type LeanSceneCanvasProps<TData, TLayer extends string, TPose> = Omit<SceneCanva
  * `viewPreset` here; pass it.
  */
 declare const LeanSceneCanvas: <TData, TLayer extends string, TPose>(props: LeanSceneCanvasProps<TData, TLayer, TPose> & {
-    ref?: React__default.Ref<SceneCanvasApi>;
-}) => React__default.ReactElement;
+    ref?: react__default.Ref<SceneCanvasApi>;
+}) => react__default.ReactElement;
 
 /**
  * How a painter asks for part of a node's paint to land on top of the node's
@@ -7203,7 +7110,7 @@ interface CursorCoordsHudProps {
 }
 /** Debug overlay showing the pointer's client and world coordinates and the
  *  current frame rate, pinned to the canvas's top-right corner. */
-declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, toWorld, offset }: CursorCoordsHudProps): React$1.JSX.Element | null;
+declare function CursorCoordsHud({ canvasRef, anchorRef, viewRef, toWorld, offset }: CursorCoordsHudProps): react.JSX.Element | null;
 
 /** Props for `<PickHud>`. */
 interface PickHudProps {
@@ -7231,7 +7138,43 @@ interface PickHudProps {
 }
 /** Debug overlay listing every node under the pointer, with the one a click
  *  would actually select shown in bold. */
-declare function PickHud({ canvasRef, anchorRef, viewRef, toWorld, pickEvery, pickBest, offset }: PickHudProps): React$1.JSX.Element | null;
+declare function PickHud({ canvasRef, anchorRef, viewRef, toWorld, pickEvery, pickBest, offset }: PickHudProps): react.JSX.Element | null;
+
+/** The part of a scene the lookup reads. */
+type ParentLookup<TNode> = {
+    get(id: NodeId): TNode | undefined;
+};
+type PaintedNode = {
+    data?: unknown;
+    parent?: NodeId | null;
+};
+/** What `node`'s `'inherit'` fields take from its containers in `scene`, or
+ *  `undefined` for a node that inherits nothing. */
+declare function inheritedPaintIn<TNode extends PaintedNode>(scene: ParentLookup<TNode>, node: TNode): InheritedPaint | undefined;
+/** What an `'inherit'` fill and stroke on `node` would take from its
+ *  containers in `scene`, whatever `node` holds now — what an editor offering
+ *  the choice shows it would paint. */
+declare function paintAbove<TNode extends PaintedNode>(scene: ParentLookup<TNode>, node: TNode): InheritedPaint;
+/**
+ * Wrap a `drawOne` so a node whose fill or stroke is `'inherit'` arrives at
+ * the painter with its containers' paint on `ctx.inherited`, as
+ * `withDerivedPaths` does for a derived path. Every other node passes the
+ * caller's `ctx` through untouched.
+ */
+declare function withInheritedPaints<TData, TLayer extends string, TPose>(scene: ParentLookup<Node<TData, TLayer, TPose>>, drawOne: SceneViewDrawOne<TData, TLayer, TPose>): SceneViewDrawOne<TData, TLayer, TPose>;
+
+/**
+ * The render walk's half of derived paths: resolving one against a scene, and
+ * handing it to the painter.
+ *
+ * The resolver itself lives in `core/scene/derivedPath.ts`, beside
+ * `derivedPose` — a *pose* can derive from a dependency's path, so
+ * `effectivePose` has to be able to reach it.
+ */
+
+/** `scene` read as `drawnBoundsOf` reads one, each node that shows a computed
+ *  path answering it. One object per scene, so it can key a memo. */
+declare function drawnBoundsScene<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>): DrawnBoundsScene;
 
 /**
  * Synthesize a `<Canvas>`-compatible adapter from a `Scene` primitive.
@@ -7282,6 +7225,8 @@ type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node<
     setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;
     /** Move a node to another layer — what a `setLayer` op writes through. */
     setLayer(id: string, layer: TLayer): void;
+    /** Retarget a derived node's sources — what a `setDependsOn` op writes through. */
+    setDependsOn(id: string, dependsOn: readonly string[] | 'children' | undefined): void;
     /** Hide or show a node — what a `setHidden` op writes through. */
     setHidden(id: string, hidden: boolean): void;
     /** Lock or unlock a node — what a `setLocked` op writes through. */
@@ -7430,22 +7375,24 @@ declare const defaultNodeProperties: readonly NodePropertiesEntry[];
 declare const inferredNodeProperties: readonly NodePropertiesEntry[];
 
 /**
- * What an in-flight gesture is proposing, resolved against the committed scene.
+ * What an in-flight gesture is proposing, resolved against the scene.
  *
- * An ongoing action publishes interim poses on its handle rather than writing
- * them to the scene, and `<SceneCanvas>`'s ghost layer used to be the only
- * thing that knew how to read them: which ids are in flight, which of those are
- * roots, whose preview wins when two sources name the same id, and which are
- * merely displaced rather than dragged. None of that is about drawing, and a
- * consumer with its own renderer needs all of it.
+ * An ongoing action names the ids it previews on its handle. A transform —
+ * move, resize, rotate — publishes their poses to the scene's overrides, and
+ * other actions answer `previewPose` on the handle. Resolving them means
+ * knowing which ids are in flight, which of those are roots, whose preview
+ * wins when two sources name the same id, and which are merely displaced
+ * rather than dragged. None of that is about drawing, and a consumer with its
+ * own renderer needs all of it.
  */
 
 /** One node an in-flight gesture is previewing, as {@link resolvePreviews} returns it. */
 interface PreviewNode<TData, TLayer extends string, TPose> {
     id: NodeId;
-    /** The node as committed — the gesture has not touched the scene. */
+    /** The node as committed. */
     node: Node<TData, TLayer, TPose>;
-    /** The interim pose, or the committed one when only data is in flight. */
+    /** The pose a source previews, else the node's effective pose — where the
+     *  scene's overrides put it mid-transform. */
     pose: TPose;
     /** The interim data, or the committed one when only the pose is in flight. */
     data: TData;
@@ -7463,7 +7410,7 @@ interface PreviewNode<TData, TLayer extends string, TPose> {
  * which is what lets a caller draw a container and its contents as one thing.
  *
  * An id with no node is skipped: an insert previews before the node it will
- * create exists. So is an id no source has a pose or data for.
+ * create exists.
  */
 declare function resolvePreviews<TData, TLayer extends string, TPose>(sources: Iterable<GesturePreviewSource>, scene: Scene<TData, TLayer, TPose>): PreviewNode<TData, TLayer, TPose>[];
 /** Every entry in the forest, parents before their children. */
@@ -7629,11 +7576,11 @@ interface IconRegistryProviderProps {
     children: ReactNode;
 }
 /** Holds one icon registry for everything below it. */
-declare function IconRegistryProvider({ icons, variants, children }: IconRegistryProviderProps): React$1.JSX.Element;
+declare function IconRegistryProvider({ icons, variants, children }: IconRegistryProviderProps): react.JSX.Element;
 /** Mount an empty {@link IconRegistryProvider} only when none is already in scope. */
 declare function IconRegistryProviderIfRoot({ children }: {
     children: ReactNode;
-}): React$1.JSX.Element;
+}): react.JSX.Element;
 /** The registry in scope, or `null` outside every provider. */
 declare function useIconRegistry(): IconRegistry | null;
 
@@ -7674,7 +7621,7 @@ interface WeaselProviderProps {
  * panel, or two canvases that should agree on the selection. Mount it above
  * any `useTools(...)` call, or the dispatcher sees a stale active tool.
  */
-declare function WeaselProvider({ children, isolate, icons, iconVariants }: WeaselProviderProps): React$1.JSX.Element;
+declare function WeaselProvider({ children, isolate, icons, iconVariants }: WeaselProviderProps): react.JSX.Element;
 
 /** Options for {@link workspaceTintLayer}. */
 interface WorkspaceTintLayerOptions {
@@ -7817,6 +7764,22 @@ declare const DEFAULT_DEBUG_THEME: DebugTheme;
  */
 declare const DEFAULT_DEBUG_STROKES: DebugStrokes;
 
+/** Props for `<DevtoolsLabel>`. */
+interface DevtoolsLabelProps {
+    /** The name a devtools panel lists each canvas below this under, unless the canvas has an `aria-label` or id. */
+    value: string;
+    children?: ReactNode;
+}
+/**
+ * Names the canvases beneath it in a devtools panel, ahead of any labeled
+ * element between them and it. A host that frames canvases it did not write,
+ * such as a lab's trial or a story's frame, knows the right name; the nearest
+ * labeled ancestor is only a guess.
+ */
+declare function DevtoolsLabel({ value, children }: DevtoolsLabelProps): react.JSX.Element;
+/** The label the nearest `<DevtoolsLabel>` gives, or null outside one. */
+declare function useDevtoolsLabel(): string | null;
+
 /**
  * Bundle a list of Affordances into a single RenderLayer.
  *
@@ -8139,8 +8102,8 @@ interface DefaultTextData {
     text?: string;
     style?: TextStyle;
     runs?: readonly StyledRun[];
-    fill?: Fill | null;
-    stroke?: Stroke | null;
+    fill?: Fill | Inherit | null;
+    stroke?: Stroke | Inherit | null;
     verticalAlign?: TextVerticalAlign;
     padding?: number;
     overflow?: TextOverflow;
@@ -8371,10 +8334,6 @@ declare function strokeOf(color: string, width?: number): CommandStroke & {
 /** A stroke painted with `paint` at `width` world units — `strokeOf`'s sibling
  *  for a gradient or pattern, which has no color to pass. */
 declare function strokeWith(paint: Paint, width?: number): Stroke;
-/** The kit's default node fill — what a shape with no declared fill paints. */
-declare const DEFAULT_SHAPE_FILL: Fill & {
-    paint: Paint;
-};
 /**
  * The 0..1 alpha a paint paints at.
  *
@@ -8404,50 +8363,27 @@ declare function paintWithColor(paint: Paint | undefined, color: string): Paint;
  * call-sites can dispatch through `(adapter.applyOps ?? applyOpsTo)` with
  * matching arguments. The default ignores it.
  */
-declare function applyOpsTo<A>(adapter: A, ops: Op[], _label?: string): void;
-/**
- * Dispatcher: invokes `adapter.applyOps` if present, otherwise falls back
- * to `applyOpsTo`. Convenience for hooks so they don't repeat the
- * `?? applyOpsTo` pattern at every call site.
- */
-declare function dispatchApplyBatch<A>(adapter: A, ops: Op[], label?: string): void;
-
-/** Arguments to {@link createTransformOp}: replace node `id`'s pose `from` → `to`. */
-interface TransformArgs<TPose> {
-    id: string;
-    from: TPose;
-    to: TPose;
-    label?: string;
-    coalesceKey?: string;
-}
-/** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to
- *  `transform:${id}` so successive pose writes to the same node (drag-move,
- *  resize, repeated nudges) merge into one undo entry within the history's
- *  coalesce window. Pass an explicit key (or a unique one) to opt out. */
-declare function createTransformOp<TPose>(args: TransformArgs<TPose>): Op;
-
-/** One pose write an {@link createArrangeOp} made. */
-interface ArrangedPose {
-    id: string;
-    from: unknown;
-    to: unknown;
-}
-/** Arguments to {@link createArrangeOp}. */
-interface ArrangeArgs {
-    /** The writes to make. Absent until a computed arrangement has run once. */
-    placed?: ArrangedPose[];
-}
-/**
- * Op: write a set of poses decided when the op first applies, not when it is
- * built. The scene appends one to an edit that moves nodes into a container,
- * and `compute` asks the container what to do with them after the rest of
- * the edit has landed. Every later apply — redo, or a rebuild from a
- * serialized history — replays the writes it recorded, so the arrangement is
- * decided once. `write` replaces the adapter's `setPose` for this op and its
- * inverses — the scene passes its own, since not every adapter an edit is
- * applied through can write poses.
+declare function applyOpsTo<A>(adapter: A, ops: Op[], _label?: string): void;
+/**
+ * Dispatcher: invokes `adapter.applyOps` if present, otherwise falls back
+ * to `applyOpsTo`. Convenience for hooks so they don't repeat the
+ * `?? applyOpsTo` pattern at every call site.
  */
-declare function createArrangeOp(args: ArrangeArgs, compute?: () => ArrangedPose[], write?: (id: string, pose: unknown) => void): Op;
+declare function dispatchApplyBatch<A>(adapter: A, ops: Op[], label?: string): void;
+
+/** Arguments to {@link createTransformOp}: replace node `id`'s pose `from` → `to`. */
+interface TransformArgs<TPose> {
+    id: string;
+    from: TPose;
+    to: TPose;
+    label?: string;
+    coalesceKey?: string;
+}
+/** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to
+ *  `transform:${id}` so successive pose writes to the same node (drag-move,
+ *  resize, repeated nudges) merge into one undo entry within the history's
+ *  coalesce window. Pass an explicit key (or a unique one) to opt out. */
+declare function createTransformOp<TPose>(args: TransformArgs<TPose>): Op;
 
 /**
  * A node's position among its siblings, recorded so an op can put it back.
@@ -8605,6 +8541,20 @@ interface SetLayerArgs {
  *  explicit key to opt out. */
 declare function createSetLayerOp(args: SetLayerArgs): Op;
 
+type DependsOn = readonly string[] | 'children' | undefined;
+/** Arguments to {@link createSetDependsOnOp}: retarget node `id`'s derivation
+ *  from the sources `from` to `to`. `undefined` is no derivation. */
+interface SetDependsOnArgs {
+    id: string;
+    from: DependsOn;
+    to: DependsOn;
+    label?: string;
+    coalesceKey?: string;
+}
+/** Op: set what a derived node's geometry derives from, inverting back to
+ *  `from`. */
+declare function createSetDependsOnOp(args: SetDependsOnArgs): Op;
+
 /** Arguments to {@link createSetHiddenOp} and {@link createSetLockedOp}: set
  *  node `id`'s flag `from` → `to`. */
 interface NodeFlagArgs {
@@ -8739,6 +8689,18 @@ interface SetPathArgs {
  */
 declare function createSetPathOp(args: SetPathArgs): Op;
 
+/** A node's pose and data, as a batch of ops leaves them. */
+interface WrittenNode {
+    pose: unknown;
+    data: unknown;
+}
+/**
+ * The pose and data `ops` leave each node they write, by id, read by applying
+ * them to a recorder rather than the scene; null when one cannot be read that
+ * way. A node only re-parented, re-layered, inserted, or removed is not in it.
+ */
+declare function writtenBy(sc: Scene<unknown, string, unknown>, ops: readonly Op[]): Map<string, WrittenNode> | null;
+
 /** Rebuilds an op from its serialized `args`. */
 type OpFactory = (args: unknown) => Op;
 /** Every registered op factory, keyed by op name, in registration order. */
@@ -8764,6 +8726,31 @@ declare function registeredOpNames(): readonly string[];
  *  parent updates compose correctly. */
 declare function scenePoseAdapter(scene: Scene<unknown, string, unknown>): PoseAdapter<unknown>;
 
+/**
+ * Bringing a node's descendants along when something writes the node's pose
+ * and nothing writes theirs: a layout restacking a container, a drop landing
+ * one, a page move. Under absolute poses a descendant stores its own world
+ * pose, so it stays behind unless it is written too.
+ */
+
+/** What carrying reads: the tree, every stored pose, and how poses compose. */
+interface CarrySource<TPose> {
+    childrenOf(id: NodeId): readonly NodeId[];
+    poses: PoseAdapter<TPose>;
+    composition: PoseComposition<TPose>;
+}
+/** A {@link CarrySource} over a scene's document poses. */
+declare function sceneCarrySource(scene: Scene<unknown, string, unknown>): CarrySource<unknown>;
+/**
+ * The stored poses that bring `root`'s descendants along with it: each one's
+ * world pose put through `translate`, rebased into the frame it is stored in.
+ * A descendant stored in the frame of `root` or of a node under it is left
+ * out, since that frame carries it, and so is one `translate` answers null
+ * for. A descendant `moving` names is moving on its own: it and everything
+ * under it are left to whoever moves it.
+ */
+declare function carriedDescendants<TPose>(source: CarrySource<TPose>, root: NodeId, translate: (world: TPose, id: NodeId) => TPose | null, moving?: (id: NodeId) => boolean): Map<NodeId, TPose>;
+
 /** @internal */
 interface HitAdapter<TNode extends {
     id: string;
@@ -8946,6 +8933,13 @@ interface ScopedScene {
 declare function sceneUnitScopes(scene: ScopedScene, id: NodeId, root: UnitScope, opts?: {
     inclusive?: boolean;
 }): UnitScope[];
+/**
+ * The unit scopes every node of `ids` sits in, outermost first: the run of
+ * their chains that agree, where two containers declaring equal scopes
+ * agree. What a reader showing or snapping several nodes as one reads them
+ * in; the root alone for no nodes.
+ */
+declare function sceneSharedUnitScopes(scene: ScopedScene, ids: readonly NodeId[], root: UnitScope): UnitScope[];
 
 /**
  * Thrown by a scene edit — `batch`, `untracked`, or a bare `add` / `move` —
@@ -9006,6 +9000,10 @@ declare function derivedPose<TPose>(source: PoseSource<TPose>, node: PosedNode<T
  * resolved before it is read.
  */
 declare function derivedDepOf<TPose>(source: PoseSource<TPose>, id: NodeId, reader?: PosedNode<TPose>): DerivedDep<TPose> | undefined;
+/** `id` as {@link derivedDepOf} answers it, but at the pose and path the
+ *  document holds: no override anywhere down its dependencies counts. For a
+ *  reader that must not see an in-flight gesture, such as an edit pass. */
+declare function documentDepOf<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, at every link of the
@@ -9587,17 +9585,33 @@ interface PathEditPreview {
     previewPose: NonNullable<OngoingHandle['previewPose']>;
     previewData: NonNullable<OngoingHandle['previewData']>;
 }
+/** One frame of a drag that reshapes the path in edit mode: the world-space
+ *  polygon it makes, and where each of its points came from when the drag
+ *  knows (`editAnchorSetTracked`). */
+interface PathEditFrame {
+    path: PolygonPath;
+    origins?: readonly (PointOrigin | null)[];
+}
+/** `path`, a frame of an edit of `id`, finished by the dep's `finishEdit` as
+ *  committing it would be: its path and the other nodes' that move with it.
+ *  Null when an extension cannot finish it. */
+declare function finishPathEditFrame(dep: EditAnchorsDep, id: string, path: PolygonPath, origins?: readonly (PointOrigin | null)[]): FinishedEditFrame | null;
 /**
  * Preview ghosts for a drag that reshapes the path in edit mode. `current`
- * answers the world-space polygon to show, or null while there is nothing to
- * preview yet; `others`, the world-space paths of other nodes the edit moves
- * with it. Null when the node stores its path in neither supported place.
- *
- * The ghost is what committing `current` would store (`storeEditablePath`),
+ * answers the frame to show, or null while there is nothing to preview yet.
+ * Each frame is finished as committing it would be
+ * ({@link finishPathEditFrame}), so the node's constraints and the nodes
+ * linked to it show as they will commit; a frame that cannot be finished
+ * commits nothing, and shows nothing. A drag that finishes its own frames
+ * passes `finished`, the world-space paths of the other nodes its frame
+ * moves, and its frames are shown as they are. Null when the node stores its
+ * path in neither supported place.
+ *
+ * The ghost is what committing the frame would store (`storeEditablePath`),
  * so a path drawn from a form is drawn again from the edited form on every
  * move.
  */
-declare function pathEditPreview(dep: EditAnchorsDep, id: string, current: () => PolygonPath | null, others?: () => readonly {
+declare function pathEditPreview(dep: EditAnchorsDep, id: string, current: () => PathEditFrame | null, finished?: () => readonly {
     id: string;
     path: PolygonPath;
 }[]): PathEditPreview | null;
@@ -9648,12 +9662,21 @@ declare function nodeOutline(node: Node<unknown, string, unknown>): Path | null;
 /** One painted piece of a derived path. */
 interface DerivedPart {
     path: Path;
-    /** The part's fill. Absent, the node's own `data.fill` paints it; `null`
-     *  paints none. */
-    fill?: Fill | null;
+    /** The part's fill, read as a node's is: absent paints none, and
+     *  `INHERIT` takes the node's own `data.fill`. */
+    fill?: Fill | Inherit | null;
     /** The part's stroke, on the same terms as `fill`. */
-    stroke?: Stroke | null;
-}
+    stroke?: Stroke | Inherit | null;
+}
+/** What `part` paints, its `INHERIT` taken from `own`, the deriving node's
+ *  data — whose own `INHERIT` takes `inherited`, its container's. */
+declare function resolvePartPaint(part: DerivedPart, own: {
+    fill?: Fill | Inherit | null;
+    stroke?: Stroke | Inherit | null;
+} | null | undefined, inherited?: InheritedPaint): {
+    fill: PaintedFill | null;
+    stroke: PaintedStroke | null;
+};
 /**
  * One path holding every part's outline, with the parts remembered against
  * it for the painter. Return it from a `derivePath`. `null` for no parts.
@@ -9670,6 +9693,21 @@ declare function derivedPartsOf(path: Path | null | undefined): readonly Derived
  * `createPathEffectDerivations` by the layer that owns the painters.
  */
 
+/** Options every path effect may take. */
+interface PathEffectOptions {
+    /** Its sources are hidden while it shows them. */
+    hideSources?: boolean;
+}
+/** One rigid piece an effect lays along a path, in its own frame: x from 0 at its leading edge to `length`, y down,
+ *  its anchor line (a glyph's baseline) at y = 0. */
+interface EffectItem {
+    /** How much of the path it takes. */
+    length: number;
+    /** Height above the anchor line of the line it centers on — a glyph's x-height middle. */
+    middle: number;
+    /** What it paints; empty for a piece that only takes room, such as a space. */
+    parts: readonly DerivedPart[];
+}
 /** A source shape. */
 interface EffectSource {
     /** Its outline where it is drawn. */
@@ -9691,6 +9729,9 @@ interface EffectSource {
      *  a real "none". */
     fill: Fill | null;
     stroke: Stroke | null;
+    /** The pieces it lays one by one along a path — a text node's grapheme
+     *  clusters. Called only by an effect that lays items. */
+    items?: () => readonly EffectItem[];
 }
 /** Reads one dependency as a source; `null` when it has no outline. */
 type EffectSourceReader = (dep: DerivedDep<unknown>) => EffectSource | null;
@@ -9702,7 +9743,7 @@ type EffectSourceReader = (dep: DerivedDep<unknown>) => EffectSource | null;
 
 /** Steps between two shapes. Its sources are `[from, to]`, or
  *  `[from, to, spine]` to lay the steps along a third path. */
-interface BlendEffect extends BlendPathsOptions {
+interface BlendEffect extends BlendPathsOptions, PathEffectOptions {
     kind: 'blend';
     /** How many shapes stand between the two sources, spacing by count. */
     steps: number;
@@ -9729,22 +9770,53 @@ interface BlendEffect extends BlendPathsOptions {
     orient?: boolean;
 }
 
+/**
+ * Text along a path: a source's items — a text node's grapheme clusters, or a
+ * whole shape as one item — laid end to end along a path, each turned to it.
+ */
+
+/**
+ * Text (or any shape) laid along a path, item by item. Its sources are `[text, path]`. Only the text's first laid line
+ * follows the path; a color glyph keeps its advance and paints nothing; underlines and other decorations are not drawn.
+ * On an open path an item whose middle falls past either end is not drawn; on a closed one the text wraps past the
+ * seam, and an item a whole lap on from the first item's start is not drawn.
+ */
+interface TextAlongEffect extends PathEffectOptions {
+    kind: 'textAlong';
+    /** Which part of the text sits at `start`. Default `'start'`. */
+    align?: RunAlign;
+    /** Where the text sits, as a fraction 0..1 of the path's length from its first point. Default 0. */
+    start?: number;
+    /** How far the anchor line sits off the path, toward the glyphs' up, in world units. Default 0. */
+    shift?: number;
+    /** What sits on the path: the glyphs' baseline, or (`'center'`) their x-height middle. Default `'baseline'`. */
+    anchor?: 'baseline' | 'center';
+    /** Text longer than its room is cut at the path's end (`'clip'`), or has the gaps between items squeezed until it
+     *  fits (`'fit'`). Default `'clip'`. */
+    overflow?: 'clip' | 'fit';
+    /** Which side of the path the glyphs stand on; see `TrackSide`. Default `'auto'`, whichever reads upright. Turned over,
+     *  the text keeps the stretch of path it had, and on an open path drops whichever letters fall off it. */
+    side?: TrackSide;
+}
+/** The parts `items` paint laid along `path` as `effect` says; `[]` when there is nothing to lay or nowhere to lay it. */
+declare function textAlongParts(effect: TextAlongEffect, items: readonly EffectItem[], path: Path): DerivedPart[];
+
 /**
  * The path effects, each as the parts it paints from its sources: a blend's
  * steps between two shapes, a shape bent along a spine, copies of a shape
- * along a path.
+ * along a path, text laid along a path.
  */
 
 /** A shape bent along a spine. Its sources are `[shape, spine]`. */
-interface BendAlongEffect extends BendAlongPathOptions {
+interface BendAlongEffect extends BendAlongPathOptions, PathEffectOptions {
     kind: 'bendAlong';
 }
 /** Copies of a shape along a path. Its sources are `[shape, path]`. */
-interface RepeatAlongEffect extends Omit<RepeatAlongPathOptions, 'flattenTolerance'> {
+interface RepeatAlongEffect extends Omit<RepeatAlongPathOptions, 'flattenTolerance'>, PathEffectOptions {
     kind: 'repeatAlong';
 }
 /** A path effect, as a node's `data.pathEffect` holds it. */
-type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect;
+type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect | TextAlongEffect;
 
 /**
  * A path effect as a scene node: a leaf whose `dependsOn` names its sources,
@@ -9815,7 +9887,11 @@ declare function registeredPathEffects(registry: {
     derivePose?: Readonly<Record<string, unknown>>;
 }): PathEffectDerivations | null;
 
-/** `dep` as a path effect's source, or `null` when it has no outline. */
+/** Note that the derivation running now read glyph outlines. */
+declare function noteFontRead(): void;
+
+/** `dep` as a path effect's source, or `null` when it has no outline. A text
+ *  node's source also carries its grapheme clusters as items. */
 declare function readEffectSource(dep: DerivedDep<unknown>): EffectSource | null;
 
 /**
@@ -9835,6 +9911,26 @@ declare const PATH_EFFECT_DERIVATIONS: PathEffectDerivations;
  */
 declare function withPathEffectsRegistry<TPose, TData = unknown, TLayer extends string = string>(registry?: SceneRegistry<TPose, TData, TLayer>): SceneRegistry<TPose, TData, TLayer>;
 
+/**
+ * For a path-effect node with `hideSources`, the source an edit of `role`
+ * goes to: `'text'`, its first source when that is a text node; `'path'`, the
+ * path it lays along — the second source of an along kind, a blend's spine.
+ * `null` otherwise. The one answer every edit route asks.
+ */
+declare function effectSourceFor<TData, TLayer extends string, TPose>(scene: Pick<Scene<TData, TLayer, TPose>, 'get'>, id: NodeId, role: 'text' | 'path'): NodeId | null;
+/**
+ * The sources a removal of `ids` takes with it: those that a path effect with
+ * `hideSources` in the removal hid, and that nothing staying still derives
+ * from. A source another effect still reads stays, and so does one shown
+ * again since or named in `keep`. Transitive, so an effect's hidden effect
+ * takes its own too.
+ */
+declare function hiddenSourcesTakenWith<TData, TLayer extends string, TPose>(scene: Pick<Scene<TData, TLayer, TPose>, 'get' | 'removalClosure'>, ids: readonly NodeId[], keep?: ReadonlySet<NodeId>): NodeId[];
+
+/** For each selected path-effect node with `hideSources`, its hidden sources' outlines as the effect reads them, in a
+ *  one-screen-pixel stroke of the `'chrome'` overlay color at 40% opacity. The selection comes off the draw envelope. */
+declare function useEffectSourcesLayer<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>): RenderLayer<unknown>;
+
 /** The Boolean path operations, each acting on the current selection and
  *  committing as one undo step. */
 interface UseBooleansReturn {
@@ -10203,6 +10299,33 @@ interface AnchorHit {
  *  are within `threshold` (controls are smaller and rendered on top). */
 declare function hitAnchor(path: PolygonPath, worldX: number, worldY: number, threshold: number): AnchorHit | null;
 
+type AnyScene = Scene<unknown, string, unknown>;
+/** The deps {@link moveNodes} reads; an action calling it declares these. */
+declare const MOVE_NODES_REQUIRES: readonly ["scene", "selection", "applyOps", "poseDescriptor", "geometryProjection", "transformFollowers"];
+/**
+ * The ops that move `ids` by `delta` the way a drag of them commits: each id
+ * that is not itself derived (a derived one is moved through what it derives
+ * from) and every descendant not carried by a moving frame, each translated in
+ * the frame it is stored in. `delta` is in the coordinates a gesture's points
+ * are — world on a 2D canvas — and the `poseDescriptor` dep turns it into each
+ * pose's translation, so a 3D host's descriptor lands it on the node's plane.
+ */
+declare function moveNodesOps(scene: AnyScene, ids: readonly string[], delta: {
+    dx: number;
+    dy: number;
+}, deps?: Pick<ActionDeps, 'poseDescriptor' | 'geometryProjection'>, label?: string): Op[];
+/**
+ * Move `ids` by `delta` the way a drag of them commits ({@link moveNodesOps}),
+ * finished by the `transformFollowers` and committed as one undo entry through
+ * `applyOps`, else the scene. Inside an open `scene.batch` it joins that
+ * batch's entry. Returns whether anything moved. A caller running as an
+ * action declares {@link MOVE_NODES_REQUIRES}.
+ */
+declare function moveNodes(deps: ActionDeps, ids: readonly string[], delta: {
+    dx: number;
+    dy: number;
+}, label?: string): boolean;
+
 /**
  * A transform the selection underwent, kept relative so it can be applied to
  * whatever is selected next.
@@ -10605,6 +10728,120 @@ interface MomentumOptions {
  */
 declare function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose>;
 
+/** The part of a scene a rig's skins read and write. */
+interface SkinScene<TPose> {
+    get(id: NodeId): {
+        pose: TPose;
+        data?: unknown;
+    } | undefined;
+    readonly overrides: PoseOverrides<TPose>;
+    setPose(id: NodeId, pose: TPose): void;
+    update(id: NodeId, patch: {
+        data: never;
+    }): void;
+}
+/** Where a node's path is drawn, for a skin to bend: `null` for a node with none. */
+type RestPath<TPose> = (node: {
+    pose: TPose;
+    data?: unknown;
+}) => Path | null;
+/** The path in a node's `data.path`, carried through its pose as `kit:path` paints it. */
+declare function dataRestPath<TPose>(node: {
+    pose: TPose;
+    data?: unknown;
+}): Path | null;
+
+/** The part of a scene a rig writes to. */
+interface RigScene<TPose> extends SkinScene<TPose> {
+    batch<T>(label: string, fn: () => T): T;
+}
+/** What a `RigApply` knows about the node it is posing. */
+interface RigApplyContext<TPose> {
+    /** The joint the node rides. */
+    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;
+/** Options for `bindRig`. */
+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[]>>;
+    /** Node id → the weights its path bends by. Where a bound node moves whole with one joint,
+     *  a skinned node's points each follow their own joints, and the rig shows the bent path
+     *  through the node's pose override, posed at the path's bounds. */
+    skins?: Readonly<Record<NodeId, Skin>>;
+    /** Where a skinned node's path is drawn when the rig is bound. Default
+     *  {@link dataRestPath}: the node's `data.path`, through its pose. */
+    restPath?: RestPath<TPose>;
+    /** 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>;
+}
+/** A skeleton bound to scene nodes, as `bindRig` returns it. */
+interface Rig {
+    readonly skeleton: Skeleton;
+    /**
+     * The rig's pose as a value an animator moves. Its committed value starts as `{}`, the bind
+     * pose, and each frame the rig is posed with what the target shows. A clip is a
+     * `SampledTrack<Pose>` given this as its `target`: clips on one rig crossfade by their
+     * `weight`s, weights short of 1 leave the rest to the committed pose, and a `spring` or
+     * `tween` from a pose away from the committed one adds on top. `animator.hold` shows a pose made elsewhere the same way, an
+     * IK solve included.
+     */
+    readonly target: Target<Pose>;
+    /**
+     * Commit `pose` and move every bound node to what the target now shows, which is `pose`
+     * unless something is animating the target; a hold on it weighs the new pose in when it is
+     * next read, at the animator's next frame or the hold's `touch()`. Writes go through the scene's pose overrides —
+     * no history entry, no document write, no version bump — and are committed. `root`, where
+     * given, replaces the placement, as {@link Rig.place}.
+     */
+    pose(pose: Pose, root?: GlMat3): void;
+    /** Place the rig in the world by `root`, which may mirror it, and pose it there. It stays
+     *  until placed again; with no `root`, the rig goes back to where its skeleton puts it. */
+    place(root?: GlMat3): void;
+    /** The joint world transforms as the rig was last posed, root applied. */
+    world(): ReadonlyMap<string, GlMat3>;
+    /** Write the current frame into the bound nodes' document poses as one
+     *  undo entry, and drop the overrides. A skinned node's bent path goes into
+     *  its `data.path`. 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
+     *  rig is next posed. */
+    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;
+
 /**
  * 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
@@ -10612,12 +10849,78 @@ declare function momentum<TPose>(opts: MomentumOptions): MoveBehavior<TPose>;
  */
 declare function useRig<TPose>(options: BindRigOptions<TPose>): Rig;
 
+/** What a rig reads from node data: a `skeleton` on the node that is the rig, and on the nodes
+ *  under it a `skin` for a path that bends or a `joint` for a node that rides one whole. */
+interface RigNodeData {
+    /** Joints relative to the node's pose: its box's top-left corner, turned as the node is. */
+    skeleton?: Skeleton;
+    skin?: Skin;
+    joint?: string;
+}
+/** Weights to bind in place of the document's, and word of when they change. `@weasel-js/rig`'s
+ *  `RigEditState` is one: it holds what a stroke of the weight tool has painted and not yet written. */
+interface PaintedSkins {
+    /** By node. A new map whenever the weights change. */
+    painted(): ReadonlyMap<NodeId, Skin>;
+    listen(fn: () => void): () => void;
+}
+/** The part of a scene `rigFromNode` reads. */
+interface RigNodeSource<TPose> {
+    get(id: NodeId): {
+        pose: TPose;
+        data?: unknown;
+    } | undefined;
+    childrenOf(id: NodeId): readonly NodeId[];
+}
+/** The skeleton, bindings, and skins a rig node declares, as `bindRig` takes them. */
+interface RigNodeParts {
+    skeleton: Skeleton;
+    bindings: Record<string, NodeId[]>;
+    skins: Record<NodeId, Skin>;
+}
+/**
+ * A skeleton as a rig node's data keeps it, moved to where the node's pose puts it: its root
+ * joints are offset from the pose box's top-left corner and turned as the node is. Joints
+ * under a root are relative to their parents and are left as they are.
+ */
+declare function placeSkeleton<TPose>(skeleton: Skeleton, pose: TPose, descriptor?: PoseDescriptor<TPose>): Skeleton;
+/** The inverse of {@link placeSkeleton}: a skeleton in the scene's space, as the node at
+ *  `pose` would keep it in its data. */
+declare function unplaceSkeleton<TPose>(skeleton: Skeleton, pose: TPose, descriptor?: PoseDescriptor<TPose>): Skeleton;
+/**
+ * Read a rig out of the scene: the skeleton in `id`'s `data.skeleton`, placed by that node's
+ * pose, and under it every node whose data has a `skin` or names a `joint`.
+ */
+declare function rigFromNode<TPose>(scene: RigNodeSource<TPose>, id: NodeId, descriptor?: PoseDescriptor<TPose>): RigNodeParts;
+/** Options for `useRigNode`. */
+interface UseRigNodeOptions<TPose> extends Pick<BindRigOptions<TPose>, 'apply' | 'descriptor' | 'restPath'> {
+    scene: RigScene<TPose> & RigNodeSource<TPose> & {
+        subscribe(listener: () => void): () => void;
+        getVersion(): number;
+    };
+    /** The node whose data holds the skeleton. */
+    node: NodeId;
+    /** Weights bound in place of a node's `data.skin` while they are held. Give it the
+     *  `RigEditState` `@weasel-js/rig`'s weight tool has, and a stroke bends the path as it is painted. */
+    painting?: PaintedSkins;
+}
+/**
+ * A {@link Rig} read from a node, as {@link rigFromNode} reads it. It is bound again when the
+ * rig node or a node under it changes its pose or data, or when nodes under it come or go; an
+ * edit elsewhere in the scene leaves it alone. A rig bound again keeps its `target`, with the
+ * animations running on it, its committed pose, and its placement, unless the skeleton's
+ * joints were added, removed, renamed, or reordered. Then it has a new `target`, which takes
+ * over the placement and the pose of every joint the skeleton still names. Animations go on
+ * running on the target they were started on and show through the new one, so a joint that
+ * was renamed stops moving.
+ */
+declare function useRigNode<TPose>(options: UseRigNodeOptions<TPose>): Rig;
+
 /** A glyph this package draws, by its bare name. */
-type CoreIconName = 'arrow' | 'bone' | 'ellipse' | 'eyedropper' | 'hand' | 'image' | 'lasso' | 'line' | 'pen' | 'pencil' | 'polygon' | 'rect' | 'select' | 'slice' | 'star' | 'sticky' | 'text' | 'unknown' | 'weight' | 'cut' | 'copy' | 'paste' | 'duplicate' | 'transformAgain' | 'group' | 'ungroup' | 'bringForward' | 'bringToFront' | 'sendBackward' | 'sendToBack' | 'flipX' | 'flipY' | 'delete' | 'undo' | 'redo' | 'measure' | 'tune' | 'alignLeft' | 'alignRight' | 'alignTop' | 'alignBottom' | 'alignCenterX' | 'alignCenterY' | 'distributeHorizontal' | 'distributeVertical' | 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge' | 'join' | 'bridge' | 'cutAtCrossings' | 'simplify' | 'offsetPath' | 'retractHandles' | 'symmetricHandles' | 'holdHandleAngle' | 'holdHandleLength' | 'simplifyBrush' | 'harmonize' | 'averageAnchors' | 'bendSegment' | 'nudgeAnchors' | 'nudgeAnchorsUp' | 'nudgeAnchorsDown' | 'nudgeAnchorsLeft' | 'createOutlines' | 'outlineStroke' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'overline' | 'superscript' | 'subscript' | 'textAlignLeft' | 'textAlignCenter' | 'textAlignRight' | 'textAlignJustify' | 'textAlignTop' | 'textAlignMiddle' | 'textAlignBottom' | 'strokeWidth' | 'strokeCap' | 'strokeJoin' | 'strokeAlign' | 'capButt' | 'capRound' | 'capSquare' | 'joinMiter' | 'joinRound' | 'joinBevel' | 'alignInner' | 'alignCenter' | 'alignOuter' | 'dashSolid' | 'dashDashed' | 'dashDotted' | 'dashCustom' | 'paintSolid' | 'paintLinear' | 'paintRadial' | 'paintConic' | 'paintMesh' | 'paintPattern' | 'paintNone';
+type CoreIconName = 'arrow' | 'ellipse' | 'eyedropper' | 'hand' | 'image' | 'lasso' | 'line' | 'pen' | 'pencil' | 'polygon' | 'rect' | 'select' | 'slice' | 'star' | 'sticky' | 'text' | 'unknown' | 'cut' | 'copy' | 'paste' | 'duplicate' | 'transformAgain' | 'group' | 'ungroup' | 'bringForward' | 'bringToFront' | 'sendBackward' | 'sendToBack' | 'flipX' | 'flipY' | 'delete' | 'undo' | 'redo' | 'measure' | 'tune' | 'alignLeft' | 'alignRight' | 'alignTop' | 'alignBottom' | 'alignCenterX' | 'alignCenterY' | 'distributeHorizontal' | 'distributeVertical' | 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge' | 'join' | 'bridge' | 'cutAtCrossings' | 'simplify' | 'offsetPath' | 'retractHandles' | 'symmetricHandles' | 'holdHandleAngle' | 'holdHandleLength' | 'simplifyBrush' | 'harmonize' | 'averageAnchors' | 'bendSegment' | 'nudgeAnchors' | 'nudgeAnchorsUp' | 'nudgeAnchorsDown' | 'nudgeAnchorsLeft' | 'createOutlines' | 'outlineStroke' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'overline' | 'superscript' | 'subscript' | 'textAlignLeft' | 'textAlignCenter' | 'textAlignRight' | 'textAlignJustify' | 'textAlignTop' | 'textAlignMiddle' | 'textAlignBottom' | 'strokeWidth' | 'strokeCap' | 'strokeJoin' | 'strokeAlign' | 'capButt' | 'capRound' | 'capSquare' | 'joinMiter' | 'joinRound' | 'joinBevel' | 'alignInner' | 'alignCenter' | 'alignOuter' | 'dashSolid' | 'dashDashed' | 'dashDotted' | 'dashCustom' | 'paintSolid' | 'paintLinear' | 'paintRadial' | 'paintConic' | 'paintMesh' | 'paintPattern' | 'paintNone';
 declare module '@weasel-js/icons' {
     interface IconName {
         'core:arrow': true;
-        'core:bone': true;
         'core:ellipse': true;
         'core:eyedropper': true;
         'core:hand': true;
@@ -10634,7 +10937,6 @@ declare module '@weasel-js/icons' {
         'core:sticky': true;
         'core:text': true;
         'core:unknown': true;
-        'core:weight': true;
         'core:cut': true;
         'core:copy': true;
         'core:paste': true;
@@ -10830,7 +11132,8 @@ declare const SNAP_ROLES: {
 /** The angle step `snap.constrain` (Shift) holds a direction to: a line, a
  *  measurement, a rotate, a symmetry axis. 15 degrees. */
 declare const SNAP_ANGLE_STEP: number;
-/** The step an `'axis'` lock holds a move to: the axes and the diagonals. */
+/** The step an `'axis'` lock holds a move or an anchor drag to, and Shift a
+ *  pen handle: the axes and the diagonals. */
 declare const SNAP_AXIS_STEP: number;
 /** The snap roles `ctx` holds. */
 declare function snapMods(ctx: {
@@ -10840,6 +11143,8 @@ declare function snapMods(ctx: {
 
 /** The sources that answer `gesture`: those naming it, and, for one naming none, point, move and resize. */
 declare function snapSourcesFor<S extends Pick<SnapSource<unknown>, 'gestures'>>(sources: readonly S[], gesture: SnapGesture): S[];
+/** Throws if two of `sources` share an id: one would silently replace the other. */
+declare function assertSnapSourceIds(sources: readonly Pick<SnapSource<unknown>, 'id'>[]): void;
 /** What a candidate draws when the result meets it. */
 type SnapCandidateMark<P> = NonNullable<SourceCandidate<P>['mark']>;
 /** How `gatherSnapCandidates` reads a host's points. */
@@ -10917,6 +11222,9 @@ declare function pathSnapSource(opts?: PathSnapSourceOptions): SnapSource;
 /** The canvas's reach when neither a source nor the kit settings name one. */
 declare const DEFAULT_SNAP_PX = 8;
 
+/** A screen-space layer drawing the marks in `store`, redrawn when they change. */
+declare function createSnapReadoutLayer(store: SnapOutcomeStore, style?: SnapReadoutStyle): RenderLayer<unknown>;
+
 /**
  * The screen-space drawing the snap readout and the guides overlay share:
  * ticked segments, number pills, and the glyph-and-label of a point mark.
@@ -10951,8 +11259,6 @@ interface CoreKitTargetSettings {
     penCloseHintRadiusPx: number;
     /** How near the pen's first anchor a click closes the subpath. */
     penCloseHitPx: number;
-    boneJointRadiusPx: number;
-    weightPointRadiusPx: number;
     sliceVertexRadiusPx: number;
     /** How near the knife's first point a click closes the cut. */
     sliceCloseHitPx: number;
@@ -11002,6 +11308,10 @@ declare const coreKitSettingsSchema: Omit<_weasel_js_prefs.PrefGroup, "children"
                 readonly dragPx: _weasel_js_prefs.PrefNumber & {
                     default: number;
                 };
+                readonly keymapUnbound: _weasel_js_prefs.PrefEnumBase<"modal" | "cascade"> & {
+                    default: "modal" | "cascade";
+                    clearable?: false;
+                };
             };
         };
         readonly targets: Omit<_weasel_js_prefs.PrefGroup, "children"> & {
@@ -11039,12 +11349,6 @@ declare const coreKitSettingsSchema: Omit<_weasel_js_prefs.PrefGroup, "children"
                 readonly penCloseHitPx: _weasel_js_prefs.PrefNumber & {
                     default: number;
                 };
-                readonly boneJointRadiusPx: _weasel_js_prefs.PrefNumber & {
-                    default: number;
-                };
-                readonly weightPointRadiusPx: _weasel_js_prefs.PrefNumber & {
-                    default: number;
-                };
                 readonly sliceVertexRadiusPx: _weasel_js_prefs.PrefNumber & {
                     default: number;
                 };
@@ -11063,4 +11367,4 @@ declare const coreKitSettingsSchema: Omit<_weasel_js_prefs.PrefGroup, "children"
     };
 };
 
-export { ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, ActionsProviderIfRoot, AddNodeSpec, Affordance, AffordanceBinding, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignEdge, type AlignReference, type AnchorEdit, type AnchorFieldsApi, type AnchorHit, AnchorMarkerShape, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimatedReflow, type AnnotationFlag, type AnyTool, AreaSelectAdapter, type ArrangeArgs, type ArrangedPose, BUILTIN_TOOL_IDS, type BaseFeature, type BendAlongEffect, type BindRigOptions, type BlendEffect, type BooleanCommitPiece, BooleanOp, BooleanOpOptions, BooleanOpResult, type BooleanOperands, type BooleanSource, BooleanStrokes, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COMPOSITE_FEATURES, type CameraProps, type CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasRetainOptions, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type ChildOrder, type ChromeCtx, type ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type CompositeFeature, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, type CoreIconName, type CoreKitTargetSettings, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, CreateOutlinesAdapter, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_OVERLAY_STYLE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_SIMPLIFY_TOLERANCE, DEFAULT_SNAP_PX, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DefaultTextData, type DeleteArgs, DepRegistryProviderIfRoot, type Departures, DerivePathFn, DerivePoseFn, DerivedDep, type DerivedPart, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type DistributeAdapter, type DistributeAxis, type DistributeMode, 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, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DrawnBoundsOptions, type DrawnBoundsScene, type DropZoneOptions, EditAnchorsDep, EditAnchorsParams, type EditableShape, type EditedLayerOf, type EditingDrawOne, type EffectSource, type EffectSourceReader, FALLBACK_ACCENT, FEATURE_ACTION_IDS, type Feature, type FeatureBindingOptions, type FeatureEntry, type FeaturePreset, type FeedDelta, type FeedNode, FitViewToBoundsOptions, type FlipAxis, type FlipPivot, type FrameStats, GHOST_STROKE, type GateLayerOptions, type GateSource, type GatedLayer, type GatedNode, type GatherSnapOptions, type GeneratedShape, GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, HANDLE_BASE_PX, HANDLE_LOCK_ROLES, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HandleEdit, HandleLocks, type HandleScope, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, INSERT_REPOSITION_BINDING, IconRegistryProvider, IconRegistryProviderIfRoot, type IconRegistryProviderProps, InertiaConfig, type InkExtents, InsertAdapter, type InsertArgs, InsertBehavior, InsertNodeFactory, type InsertOp, type InsertOverlayStyle, InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, type JoinPlan, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, KIT_VERSIONS, type KeyModifiers, type KeyState, type KeyStateAttachOptions, type KitInsertShape, type KitRequirements, type KitVersions, LONG_PRESS_FEEDBACK_ID, LassoHitMode, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, type LayerFrameStats, LayerGroup, LayerHit, type LayerSlotValue, type LayersMap, LayoutDropTargetMode, LayoutFrame, type LayoutRef, LayoutStrategy, LeanSceneCanvas, type LeanSceneCanvasProps, type LifecycleAdapter, type LifecycleAnimation, type LinePoint, type LivePathEditSpec, type LongPressFeedbackOptions, MEASURE_ACTION_IDS, MEASURE_AFFORDANCE_KIND, MEASURE_LAYER_ID, type MeasureCell, type MeasureData, type MeasureEnd, type MeasureEndSourceOptions, type MeasureHit, type MeasurePoint, type Measurement, type Measurements, type ModeTriggerHandlers, type MomentumOptions, MoveAdapter, MoveBehavior, type MoveToIndexArgs, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeFlagArgs, type NodeGates, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OVERLAY_ROLE_STROKES, type OpFactory, type OpenFilePickerOptions, type OpsApplier, OrderedAdapter, OriginProjection, type OutlineStrokeResult, type Overlay, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATHFINDER_STROKES, PATH_ANCHOR_CHROME_ID, PATH_EFFECT, PATH_EFFECT_DERIVATIONS, PATH_GESTURE_TAGS, PATH_SNAP_LABELS, type Page, type PageLayoutOptions, type PagesLayerOptions, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, PasteCtx, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, PathEditExtension, type PathEditHost, PathEditMark, type PathEditOpening, type PathEditPreview, PathEditTarget, type PathEditingOverlaySlotConfig, type PathEditingOverlayStyle, type PathEffect, type PathEffectDerivations, type PathGestureFamily, type PathNode, PathPaint, type PathSnapSourceOptions, type PathStorageKind, PathSymmetryDep, type PenContinuation, type PenPreviewStyle, type PenScratch, type PenSubpath, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedPage, type PlacedRig, PlaneMap, type PointSnap, type PointerFollower, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PolygonGenerator, type PolygonPoint, PoseAdapter, type PoseAnimationAdapter, type PoseCascade, PoseComposition, PoseDescriptor, type PoseFeed, type PoseFrame, PoseOverrides, PoseRemoval, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PoseTargetOptions, type PoseTargetScene, type PoseTransitionScene, type PoseTransitionSeat, PoseWrite, type PosedNode, type PressureToWidthOptions, type PreviewNode, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, type RecordedViewport, RectPose, RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, type RegisterNodeShapeOptions, RegisteredOp, type RenderDebugSnapshotArgs, RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RepeatAlongEffect, type RepeatableTransform, type RequirementMismatch, ResizeAdapter, ResizeHandleLayout, type ResolvableView, type ResolvedOverlay, type RestPath, type Rig, type RigApply, type RigApplyContext, type RigEditState, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RoutedNode, SCENE_CANVAS_FEATURES, SELECTION_MOVE_ID, SELECTION_RESIZE_ID, SELECTION_ROTATE_ID, SELECTION_TRANSFORM_ID, SHAPE_COUNT_RANGE, SHAPE_KINDS, SNAP_ANGLE_STEP, SNAP_AXIS_STEP, SNAP_ROLES, STAR_RATIO_RANGE, Scene, type SceneAdapterSelection, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasGeometry, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, SceneCanvasSnap, type SceneCanvasViewport, type SceneClipTargetsOptions, Node as SceneNode, type SceneNodeClientRectOpts, ScenePoseReports, SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, type SelectAdapter, type SelectFromLassoOptions, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionRotateOptions, type SelectionStore, type SelectionTransformOptions, SerializedScene, type SetAnchorFieldParams, type SetChildOrderArgs, type SetDataArgs, type SetLayerArgs, type SetLayoutArgs, type SetPathArgs, type SetPathFields, type SetSelectionArgs, type SetTextArgs, type ShapeCoversPointOptions, type ShapeGenerator, type ShapeKind, type ShapeKindDescriptor, type ShapeKindsWhere, type ShownDeparture, type SiblingSlot, SliceDep, type SliceLeaf, type SlicePiece, type SliceScratch, type SliceableNode, type SnapCandidateMark, SnapCollect, SnapDep, SnapGesture, SnapMark, SnapMods, SnapOutcome, SnapProbeAt, SnapSource, SourceCandidate, type SpatialReference, type SpatialReferenceSources, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, type StarGenerator, type StarPoint, StickyStyle, type StrokeRegionOptions, type StylusData, type SurfaceContribution, type SurfaceSizeProps, SvgIngestOptions, SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, TargetTransform, TextOverflow, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, type TransformArgs, type TweenPoseOptions, UNION_OF_CHILDREN, type UseAlignOptions, type UseAlignReturn, type UseBoneToolOptions, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, type UseMeasureToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRigNodeOptions, type UseRotateOptions, type UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSliceToolOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseStickyToolOptions, type UseToolsOptions, type UseWeightToolOptions, VERSION, type VelocityTracker, type VersionCheck, ViewAnimationOptions, type ViewAt, type ViewKitSettings, type ViewLike, type ViewPoseAdapter, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WeighedPath, type WeightEnv, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenPoseTargetOptions, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, adjacentPage, alignDeltaFor, alignTargetBounds, always, anchorEditWouldChange, and, animateLifecycle, animateOnSetPose, annotationLayerIds, annulusSemiAxes, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, arrangePreset, axisAlignedBounds, axisZoomFactor, bindPoseTransition, bindRig, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, checkRequirements, clampShapeGenerator, clampView, classifyPathStorage, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, clipboardPasteEventAction, cloneAction, coarsePointer, commitAnchorEdit, commitBooleanPieces, commitOps, composeAffordanceLayer, composeRectPose, composeRigidPose, composeSelectionPose, computeFitViewport, computeSliceOps, computeWheelAction, cond, contextMenuAction, coreKitSettingsSchema, createArrangeOp, createBoneOverlay, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createDepartures, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMeasurements, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathEffectDerivations, createPathLayer, createPenPreviewLayer, createPointerFollower, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createRigEditState, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetHiddenOp, createSetLayerOp, createSetLayoutOp, createSetLockedOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, createWeightOverlay, createWrittenPoseTarget, currentMeasureId, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, deleteAnchorsAction, deleteNode, deleteSelectedMark, depOf, derivedDepOf, derivedPartsOf, derivedPose, dispatchApplyBatch, documentPose, dragPanContribution, dragPointOf, drawnAABBOf, drawnBoundsOf, editAnchorsAction, editPreset, editTargetOf, editedPathSymmetries, editingAnchors, editingLayer, effectivePose, enterTextEditAction, enumerateAnchors, exitPathEditToolAction, findNodeShape, findShapeBounds, findShapeDrawnBounds, findShapeInk, findShapeSilhouette, fitToBounds, fitViewToPage, fitZoom, flattenPreviews, flipAction, focused, forEachCoalesced, forgetTransform, gateLayer, gatherSnapCandidates, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, glidesByDefault, groupNodeRouting, hasEditablePath, hidesSubtree, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, ingestPreset, inkExtentsOf, insertAction, insertAt, insertLayer, insertPreviewExtent, insertRepositionAction, interpolateView, isAnnotationLayer, isAnnotationNode, isNodeHidden, isNodeLocked, isOverChildren, isShapeGenerator, joinPathsCommand, joinSelectedAnchors, kitTextHandler, lassoSelectAction, lastTransform, layoutPages, livePathEdit, locksInForce, makeHandleCommand, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markUnder, measureAt, measureBetween, measureEndSource, measureEndsOf, measureIds, measureNode, measurePose, measuredSegmentCommands, measurementOf, measurementsContribution, mergeAlphaFromPrev, mergeContributions, modeDecorationLayer, modeIn, modeIs, modeNot, modeTriggers, modifierHeld, momentum, moveAction, movePreset, multiActive, nestedHitTester, never, nodeGates, nodeOutline, normalizeView, normalizeZoom, not, nudgeAnchorsDownAction, nudgeAnchorsLeftAction, nudgeAnchorsRightAction, nudgeAnchorsUpAction, onEmptyCanvas, opFactoryRegistry, openContextMenu, openFilePicker, or, outlinePreset, overChildren, pageAt, pageOfBounds, pagesBounds, pagesLayer, paintAlpha, paintWithAlpha, paintWithColor, parseDebugFlags, pathCopy, pathEditPathOf, pathEditPreview, pathEditToolAction, pathEditToolActive, pathEffectNode, pathEffectOf, pathEffectParts, pathFromParts, pathNodesOf, pathOperationTags, pathOriginProjection, pathPoseDescriptor, pathSnapGlyph, pathSnapSource, pathsPreset, pickTopMostHit, pillCommands, pinchZoomAction, placeAction, placeSkeleton, placedRig, planJoin, planPixelRender, pointRegionFrame, pointSnap, poseAxes, pressureToWidth, rasterToPng, readEffectSource, rebuildOp, reconcileSpecs, recordTransform, regenerateShape, registerNodeShape, registerOpFactory, registeredOpNames, registeredPathEffects, releaseCanvasRenderer, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, requiresAnchorSelection, reshapeOps, reshapeTo, resizeAction, resizePreset, resolveBooleanOperands, resolveEditablePathOf, resolveOverlays, resolvePreviews, resolveSpatialReference, resolveVisibility, resolvedSnapMarks, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePreset, rotationDegreesUnit, rotationHandle, rotationSnapSource, satisfiesRange, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseAdapter, scenePoseFrame, scenePoseTarget, sceneSelectionStore, sceneToAdapter, sceneUnitScopes, screenToWorld, screenTolerance, segmentUnder, selectAnchorAction, selectFromLasso, selectPreset, selectedPathNodes, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, settleShapeGenerator, shapeCoversPoint, shapeGeneratorOf, shapeGeneratorPath, sliceAction, slotOf, snapMods, snapSourcesFor, solid, splitOverChildren, springPose, stableStringify, staggerSpringPose, startThresholdDrag, stepAngles, storeEditablePath, strokeOf, strokeRegion, strokeWith, tickedSegment, toHex8, translateRectPose, tweenPose, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnchorFields, useAnimatedReflow, useAutoCenter, useBoneTool, useBooleans, useBooleansAdapter, useBooleansAdapterSource, useCanvasSize, useCreateOutlinesAdapter, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useElementSize, useEllipseTool, useEyedropperTool, useGradientKinds, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useIconGlyph, useIconRegistry, useIconVariant, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLineTool, useMeasureTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, usePoseTransition, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useSnapSource, useStandardActions, useStarTool, useStickyTool, useTextTool, useTools, useVelocityTracker, useWeightTool, viewPreset, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportWorldRect, viewportZoomAction, warmRender, watchDevicePixelRatio, weighedPaths, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withPath, withPathEffectsRegistry, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+export { ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, ActionsProviderIfRoot, AddNodeSpec, Affordance, AffordanceBinding, AffordanceRegion, type AffordanceRegionHit, type AimHeldViewProps, type AimOutline, type AimPoint, type AimSource, type AimSpace, type AlignAdapter, type AlignEdge, type AlignReference, type AnchorEdit, type AnchorFieldsApi, type AnchorHit, AnchorMarkerShape, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimatedReflow, type AnnotationFlag, type AnyTool, AreaSelectAdapter, type ArrangeArgs, type ArrangedPose, BUILTIN_TOOLS, BUILTIN_TOOL_IDS, type BaseFeature, type BendAlongEffect, type BindRigOptions, type BlendEffect, type BooleanCommitPiece, BooleanOp, BooleanOpOptions, BooleanOpResult, type BooleanOperands, type BooleanSource, BooleanStrokes, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CANVAS_CONTEXT_ATTRIBUTES, COMPOSITE_FEATURES, type CameraHeldViewProps, type CameraProps, CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasRetainOptions, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewCommonProps, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type CarrySource, type ChildOrder, type ChromeCtx, type ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type CompositeFeature, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, type CoreIconName, type CoreKitTargetSettings, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, CreateOutlinesAdapter, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_OVERLAY_STYLE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SIMPLIFY_TOLERANCE, DEFAULT_SNAP_PX, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, DRAW_TOOLS, DebugConfig, DebugSnapshot, DebugStrokes, DebugTheme, type DefaultTextData, type DeleteActionOptions, type DeleteArgs, DepRegistryProviderIfRoot, type Departures, DerivePathFn, DerivePoseFn, DerivedDep, type DerivedPart, DeviceProfileProvider, type DeviceProfileProviderProps, DevtoolsLabel, type DevtoolsLabelProps, Dims, type DistributeAdapter, type DistributeAxis, type DistributeMode, 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, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DrawnBoundsOptions, type DrawnBoundsScene, type DropZoneOptions, EditAnchorsDep, EditAnchorsParams, type EditableShape, type EditedLayerOf, type EditingDrawOne, type EffectItem, type EffectSource, type EffectSourceReader, FALLBACK_ACCENT, FEATURE_ACTION_IDS, type Feature, type FeatureBindingOptions, type FeatureEntry, type FeaturePreset, type FeedDelta, type FeedNode, FinishedEditFrame, FitViewToBoundsOptions, type FlipAxis, type FlipPivot, GHOST_STROKE, type GateLayerOptions, type GateSource, type GatedLayer, type GatedNode, type GatherSnapOptions, type GeneratedShape, GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, HANDLE_BASE_PX, HANDLE_LOCK_ROLES, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HandleEdit, HandleLocks, type HandleScope, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, INSERT_REPOSITION_BINDING, IconRegistryProvider, IconRegistryProviderIfRoot, type IconRegistryProviderProps, InertiaConfig, InheritedPaint, type InkExtents, InsertAdapter, type InsertArgs, InsertBehavior, InsertNodeFactory, type InsertOp, type InsertOverlayStyle, InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, type JoinPlan, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, KIT_VERSIONS, type KeyModifiers, type KeyState, type KeyStateAttachOptions, type KitInsertShape, type KitRequirements, type KitVersions, LONG_PRESS_FEEDBACK_ID, LassoHitMode, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerGroup, LayerHit, type LayerSlotValue, type LayersMap, LayoutDropTargetMode, LayoutFrame, type LayoutRef, LayoutStrategy, LeanSceneCanvas, type LeanSceneCanvasProps, type LifecycleAdapter, type LifecycleAnimation, type LinePoint, type LivePathEditSpec, type LongPressFeedbackOptions, MEASURE_ACTION_IDS, MEASURE_AFFORDANCE_KIND, MEASURE_LAYER_ID, MOVE_NODES_REQUIRES, type MeasureCell, type MeasureData, type MeasureEnd, type MeasureEndSourceOptions, type MeasureHit, type MeasurePoint, type Measurement, type Measurements, type ModeTriggerHandlers, type MomentumOptions, MoveAdapter, MoveBehavior, type MoveToIndexArgs, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeFlagArgs, type NodeGates, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OVERLAY_ROLE_STROKES, type OpFactory, type OpenFilePickerOptions, type OpsApplier, OrderedAdapter, OriginProjection, type OutlineStrokeResult, type Overlay, type OverlayPoint, type OverlayVisibilityId, PAGES_DOC_KEY, PAGE_TOOLS, PAINTED_CURSOR_LAYER_ID, PATHFINDER_STROKES, PATH_ANCHOR_CHROME_ID, PATH_EFFECT, PATH_EFFECT_DERIVATIONS, PATH_GESTURE_TAGS, PATH_SNAP_LABELS, type Page, type PageEditOptions, type PageLayoutOptions, type PagesDoc, type PagesLayerOptions, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, PasteCtx, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, PathEditExtension, type PathEditFrame, type PathEditHost, PathEditMark, type PathEditOpening, type PathEditPreview, PathEditTarget, type PathEditingOverlaySlotConfig, type PathEditingOverlayStyle, type PathEffect, type PathEffectDerivations, type PathEffectOptions, type PathGestureFamily, type PathNode, PathPaint, type PathSnapSourceOptions, type PathStorageKind, PathSymmetryDep, type PenContinuation, type PenPreviewStyle, type PenScratch, type PenSubpath, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedPage, PlaneMap, type PointSnap, type PointerFollower, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PolygonGenerator, type PolygonPoint, PoseAdapter, type PoseAnimationAdapter, type PoseCascade, PoseComposition, PoseDescriptor, type PoseFeed, type PoseFrame, PoseOverrides, PoseRemoval, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PoseTargetOptions, type PoseTargetScene, type PoseTransitionScene, type PoseTransitionSeat, PoseWrite, type PosedNode, type PressureToWidthOptions, type PreviewNode, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RectAim, RectPose, RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, type RegisterNodeShapeOptions, RegisteredOp, type RenderDebugSnapshotArgs, RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RepeatAlongEffect, type RepeatableTransform, type RequirementMismatch, type ResizeActionOptions, ResizeAdapter, ResizeHandleLayout, type ResolvableView, type ResolvedOverlay, type RestPath, type Rig, type RigApply, type RigApplyContext, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RoutedNode, SCENE_CANVAS_FEATURES, SELECTION_MOVE_ID, SELECTION_RESIZE_ID, SELECTION_ROTATE_ID, SELECTION_TRANSFORM_ID, SELECT_TOOLS, SHAPE_COUNT_RANGE, SHAPE_KINDS, SHAPE_TOOLS, SNAP_ANGLE_STEP, SNAP_AXIS_STEP, SNAP_ROLES, STAR_RATIO_RANGE, Scene, type SceneAdapterSelection, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasGeometry, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, SceneCanvasSnap, type SceneCanvasViewport, type SceneClipTargetsOptions, Node as SceneNode, type SceneNodeClientRectOpts, ScenePoseReports, SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, type SelectAdapter, type SelectFromLassoOptions, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionRotateOptions, type SelectionStore, type SelectionTransformOptions, SerializedScene, type SetAnchorFieldParams, type SetChildOrderArgs, type SetDataArgs, type SetDependsOnArgs, type SetLayerArgs, type SetLayoutArgs, type SetPathArgs, type SetPathFields, type SetSelectionArgs, type SetTextArgs, type ShapeCoversPointOptions, type ShapeGenerator, type ShapeKind, type ShapeKindDescriptor, type ShapeKindsWhere, type ShownDeparture, type SiblingSlot, SliceDep, type SliceLeaf, type SlicePiece, type SliceScratch, type SliceableNode, type SnapCandidateMark, SnapCollect, SnapDep, SnapGesture, SnapMark, SnapMods, SnapOutcome, SnapOutcomeStore, SnapProbeAt, SnapReadoutStyle, SnapSource, SourceCandidate, type SpatialReference, type SpatialReferenceSources, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, type StarGenerator, type StarPoint, StickyStyle, type StrokeRegionOptions, type StylusData, type SurfaceContribution, type SurfaceSizeProps, SvgIngestOptions, SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, TYPE_TOOLS, TargetTransform, type TextAlongEffect, TextOverflow, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, type TransformArgs, TransformFollower, type TweenPoseOptions, UNION_OF_CHILDREN, type UseAlignOptions, type UseAlignReturn, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, type UseMeasureToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRigNodeOptions, type UseRotateOptions, type UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSliceToolOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseStickyToolOptions, type UseToolsOptions, VERSION, VIEW_MARKER_DEFAULT_STYLE, VIEW_MARKER_DRAG, VIEW_MARKER_HIT_SLOP_PX, VIEW_TOOLS, type VelocityTracker, type VersionCheck, type ViewAim, ViewAnimationOptions, type ViewAt, type ViewKitSettings, type ViewLike, ViewMarker, type ViewMarkerGrab, type ViewMarkerHost, type ViewMarkerProps, type ViewMarkerStyle, type ViewPoseAdapter, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenNode, type WrittenPoseTargetOptions, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, addPage, adjacentPage, aimSpace2d, alignDeltaFor, alignTargetBounds, always, anchorEditWouldChange, and, animateLifecycle, animateOnSetPose, annotationLayerIds, annulusSemiAxes, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, arrangePreset, assertSnapSourceIds, axisAlignedBounds, axisZoomFactor, bindPoseTransition, bindRig, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, carriedDescendants, checkRequirements, clampShapeGenerator, clampView, classifyPathStorage, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, clipboardPasteEventAction, cloneAction, coarsePointer, commitAnchorEdit, commitBooleanPieces, commitDeleteToScene, commitOps, composeAffordanceLayer, composeRectPose, composeRigidPose, composeSelectionPose, computeFitViewport, computeSliceOps, computeWheelAction, cond, contextMenuAction, coreKitSettingsSchema, createArrangeOp, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteAction, createDeleteOp, createDepartures, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMeasurements, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathEffectDerivations, createPathLayer, createPenPreviewLayer, createPointerFollower, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createResizeAction, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetDependsOnOp, createSetHiddenOp, createSetLayerOp, createSetLayoutOp, createSetLockedOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSnapReadoutLayer, createTextLayer, createTransformOp, createVelocityTracker, createViewMarkerContribution, createViewMarkerLayer, createViewResolver, createViewportLayer, createWrittenPoseTarget, currentMeasureId, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, deleteAction, deleteAnchorsAction, deleteNode, deleteSelectedMark, depOf, derivedDepOf, derivedPartsOf, derivedPose, dispatchApplyBatch, documentDepOf, documentPose, dragPanContribution, dragPointOf, drawnAABBOf, drawnBoundsOf, drawnBoundsScene, editAnchorsAction, editPreset, editTargetOf, editedPathSymmetries, editingAnchors, editingLayer, effectSourceFor, effectivePose, enterTextEditAction, enumerateAnchors, exitPathEditToolAction, findNodeShape, findShapeBounds, findShapeDrawnBounds, findShapeInk, findShapeSilhouette, finishPathEditFrame, fitToBounds, fitViewToPage, fitZoom, flattenPreviews, flipAction, focused, forEachCoalesced, forgetTransform, gateLayer, gatherSnapCandidates, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, glidesByDefault, grabViewMarker, groupNodeRouting, hasEditablePath, hiddenSourceDeleteOps, hiddenSourcesTakenWith, hidesSubtree, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, ingestPreset, inheritedPaintIn, inkExtentsOf, insertAction, insertAt, insertLayer, insertPreviewExtent, insertRepositionAction, interpolateView, isAnnotationLayer, isAnnotationNode, isNodeHidden, isNodeLocked, isOverChildren, isRectAim, isShapeGenerator, joinPathsCommand, joinSelectedAnchors, kitTextHandler, lassoSelectAction, lastTransform, layoutPages, livePathEdit, locksInForce, makeHandleCommand, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markUnder, measureAt, measureBetween, measureEndSource, measureEndsOf, measureIds, measureNode, measurePose, measuredSegmentCommands, measurementOf, measurementsContribution, mergeAlphaFromPrev, mergeContributions, modeDecorationLayer, modeIn, modeIs, modeNot, modeTriggers, modifierHeld, momentum, moveAction, moveNodes, moveNodesOps, movePage, movePreset, multiActive, nestedHitTester, never, nextPageId, nodeGates, nodeOutline, normalizeView, normalizeZoom, not, noteFontRead, nudgeAnchorsDownAction, nudgeAnchorsLeftAction, nudgeAnchorsRightAction, nudgeAnchorsUpAction, onEmptyCanvas, opFactoryRegistry, openContextMenu, openFilePicker, or, outlinePreset, overChildren, pageAt, pageHolding, pageInView, pageMembers, pageName, pageOfBounds, pagesBounds, pagesLayer, pagesOf, paintAbove, paintAlpha, paintWithAlpha, paintWithColor, parseDebugFlags, pathCopy, pathEditPathOf, pathEditPreview, pathEditToolAction, pathEditToolActive, pathEffectNode, pathEffectOf, pathEffectParts, pathFromParts, pathNodesOf, pathOperationTags, pathOriginProjection, pathPoseDescriptor, pathSnapGlyph, pathSnapSource, pathsPreset, pickTopMostHit, pillCommands, pinchZoomAction, placeAction, placeSkeleton, placedPagesOf, planJoin, planPixelRender, pointRegionFrame, pointSnap, poseAxes, pressureToWidth, rasterToPng, readEffectSource, rebuildOp, reconcileSpecs, recordTransform, rectAim, regenerateShape, registerNodeShape, registerOpFactory, registeredOpNames, registeredPathEffects, releaseCanvasRenderer, removePage, renamePage, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, requiresAnchorSelection, reshapeOps, reshapeTo, resizeAction, resizePage, resizePreset, resolveBooleanOperands, resolveEditablePathOf, resolveOverlays, resolvePartPaint, resolvePreviews, resolveSpatialReference, resolveVisibility, resolvedSnapMarks, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePreset, rotationDegreesUnit, rotationHandle, rotationSnapSource, routeKind, satisfiesRange, sceneCarrySource, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseAdapter, scenePoseFrame, scenePoseTarget, sceneSelectionStore, sceneSharedUnitScopes, sceneToAdapter, sceneUnitScopes, screenToWorld, screenTolerance, segmentUnder, selectAnchorAction, selectFromLasso, selectPreset, selectedPathNodes, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, setPages, settleShapeGenerator, shapeCoversPoint, shapeGeneratorOf, shapeGeneratorPath, sliceAction, slotOf, snapMods, snapSourcesFor, solid, splitOverChildren, springPose, staggerSpringPose, startThresholdDrag, stepAngles, storeEditablePath, strokeOf, strokeRegion, strokeWith, textAlongParts, tickedSegment, toHex8, translateRectPose, tweenPose, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnchorFields, useAnimatedReflow, useAutoCenter, useBooleans, useBooleansAdapter, useBooleansAdapterSource, useCanvasSize, useCreateOutlinesAdapter, useDeviceProfile, useDevtoolsLabel, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEffectSourcesLayer, useElementSize, useEllipseTool, useEyedropperTool, useGradientKinds, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useIconGlyph, useIconRegistry, useIconVariant, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLineTool, useMeasureTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, usePoseTransition, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useSnapSource, useStandardActions, useStarTool, useStickyTool, useTextTool, useTools, useTransformFollower, useVelocityTracker, viewForAim, viewMarkerDragAction, viewPreset, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportWorldRect, viewportZoomAction, warmRender, watchDevicePixelRatio, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withInheritedPaints, withPath, withPathEffectsRegistry, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldToScreen, writtenBy, zoomAt, zoomAtLeast };