@weasel-js/core 1.11.0 → 1.11.1

package/dist/index.d.ts

@@ -1,24 +1,30 @@
-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 { 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, I as InertiaConfig, E as EditAnchorsDep, G as GestureLifecycleOptions, k as SliceDep, l as StickyStyle, C as ContentHandlerEntry, A as AnchorMarkerShape, P as PathEditMark, m as ChromeState, n as LayerGroup, S as SnapSource, T as TransformFollower, o as GeometryProjection, p as InsertNodeFactory, q as InsertPaint, r as SvgIngestOptions, s as SceneCanvasSnap, t as Affordance, u as AffordanceRegion, v as AffordanceBinding, w as CommonAffordanceScratch, x as TextOverflow, y as CreateOutlinesAdapter, z as PaintKindEntry, B as PathEditTarget, J as FinishedEditFrame, K as PathSymmetryDep, H as HandleLocks, M as BooleanOpOptions, N as BooleansAdapter, O as BooleanOp, Q as PathPaint, U as BooleanOpResult, W as BooleanStrokes, X as SnapMods, Y as SourceCandidate, Z as SnapProbeAt, $ as SnapCollect, a0 as SnapMark, b as SnapGesture, a1 as SnapDep, a2 as SnapOutcome, f as SnapOutcomeStore, a3 as SnapReadoutStyle } from './depSchema-BpZNOv7q.js';
+export { a4 as AngleCandidate, a5 as AngleCollect, a6 as AnimateToBoundsOptions, a7 as AreaSelectDep, a8 as BooleanOpPreview, a9 as BooleanPreviewPiece, aa as CanDropIntoDep, ab as ClipboardDep, ac as ClipboardIngestCtx, ad as CreateOutlinesResult, ae as CustomPaintContext, af as DEFAULT_LAYER_RETAIN, ag as DecayLoopConfig, ah as FinishedPathEdit, ai as GEOMETRY_BOUND_DATA, aj as HandleLock, ak as HitTestView, al as IngestCtx, am as IngestionDep, an as InsertDep, ao as InsertEnds, ap as InsertExtras, aq as InsertIntoDep, ar as InsertLive, as as LassoSelectDep, at as LayerCommandCache, au as LayerDrawFailure, av as LayerDrawSpan, aw as LayerRetainPolicy, ax as LayoutDep, ay as Locus, az as MinSize, aA as NodeAtPointDep, aB as OutlinePathSpec, aC as PATH_OVERLAY_ROLES, aD as PaintKind, aE as PaintKindEditorProps, aF as PaintKindFamily, aG as PaintKindLoader, aH as PanBounds, aI as PathEditDrag, aJ as PathEditDragStart, aK as PathEditFinishCtx, aL as PathEditHandleMove, aM as PathEditMarksCtx, aN as PathEditOther, aO as PathEditPart, aP as PathEditStore, aQ as PathForm, aR as PathOverlay, aS as PathOverlayOptions, aT as PathOverlayStyle, aU as PathRepresentation, aV as PathTransformFinishCtx, aW as PreviewPathsDep, aX as ResizePolicy, aY as STICKY_DEFAULTS, aZ as SnapBegin, c as SnapConstrain, a_ as SnapEdge, a$ as SnapEdges, e as SnapGeometry, b0 as SnapMarks, b1 as SnapReadoutDep, d as SnapResizeBox, g as SnapSession, b2 as SvgUnpacker, b3 as TextEditDep, b4 as TextNodeData, b5 as TransformPreviewNode, b6 as TransientPath, b7 as VIEW_ANIMATION_KEY, b8 as ViewAnimationApi, b9 as ViewApi, ba as ViewChannel, bb as applyBooleanOp, bc as applyCreateOutlines, bd as asPaint, be as createPathOverlay, bf as createSnapOutcomeStore, bg as depsUnchanged, bh as drawLayers, bi as drawOneLayer, bj as fitViewToBounds, bk as getPaintKind, bl as isLayerPainted, bm as isLayerVisible, bn as listGradientKinds, bo as listPaintKinds, bp as minSizeOf, bq as paintKindOf, br as paintKindRegistry, bs as paintedLayers, bt as paintsLayer, bu as paletteInsertPaint, bv as pathPaintOf, bw as patternFamily, bx as previewBooleanOp, by as registerContentHandler, bz as registerPaintKind, bA as registerPaintKindLoader, bB as seedTile, bC as stickyData, bD as stickyNodeFactory, bE as subscribeToSources, bF as switchGradientKind, bG as textBoxOf, bH as useDecayLoop, bI as useViewAnimation, bJ as useViewAnimationOn, bK as viewAxes, bL as withoutGeometryBoundData } from './depSchema-BpZNOv7q.js';
+import { View, Scale2, Path, FramedBox, PolygonPath, Point as Point$3, AnchorField, AnchorSet, GlMat3, PlacementAlign, Rect, Affine, PathSnapKind, PathInWorldPose, AnchorFieldValues, NumberEntry, JoinOptions, SegmentHit, PointOrigin, 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, 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, DebugSink, ToolSet, ToolEntry, ActionTunings, ActionsProp, 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, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingScope, BindingSource, BoundGesture, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, 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, KeyBinding, KeyReach, 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, ToolEntry, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSet, ToolSlot, TunedBinding, UiOngoingControl, ViewportGestureKind, WalkStep, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, 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, isToolSet, keySpecShortcut, keysHeld, liveScope, matchActionItem, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, overlaysOf, pastDragThreshold, readActionSettings, 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';
+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';
@@ -28,17 +34,17 @@ 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-BHuoMs1o.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-BHuoMs1o.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';
+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';
@@ -60,6 +66,29 @@ export { a as aabbCenter, p as pointInRotatedRect, r as rectCorners, b as rotate
 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 +138,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
@@ -291,6 +322,9 @@ 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;
 }
 
 /** What a painter that declares no `ink` is assumed to do. */
@@ -499,178 +533,6 @@ 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 node's bounds as computed during the current frame. */
-interface RecordedBounds {
-    id: string;
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-/** A node's transform origin as used during the current frame. */
-interface RecordedOrigin {
-    id: string;
-    point: {
-        x: number;
-        y: number;
-    };
-}
-/** A snap candidate considered during the current gesture, and whether it
- *  won. Unlike the other records these survive across frames, until the
- *  gesture ends. */
-interface RecordedSnap {
-    point: {
-        x: number;
-        y: number;
-    };
-    accepted: boolean;
-}
-/** A render layer that drew during the current frame. */
-interface RecordedLayer {
-    id: string;
-    label: string;
-    space: 'world' | 'screen';
-    index: number;
-}
-/** 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?: {
-        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;
-}
-
 /**
  * A view added through {@link SceneCanvasApi.addView}.
  */
@@ -942,6 +804,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. */
@@ -1644,7 +1508,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 +1581,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 +1596,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 +1633,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). */
@@ -2118,7 +2051,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 +2095,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";
@@ -2629,6 +2562,10 @@ 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;
 }
 /** 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 +2711,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 +2733,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
@@ -2855,10 +2794,13 @@ declare function pathOperationTags(family: PathGestureFamily): readonly string[]
  */
 
 /** 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 +2819,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 +2899,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 +3090,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 +3128,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 +3146,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 +3586,27 @@ declare const sliceAction: Action & {
     requires: string[];
 };
 
+/** 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` and their dependents 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}.
  */
@@ -4323,318 +4302,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 +4964,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,96 +5050,11 @@ 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 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
  * default: a canvas opts in with `ingestion={{ handlers: [kitTextHandler] }}`.
@@ -5606,6 +5190,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 +5799,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 +5891,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 +5923,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 +5937,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 +6010,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. */
@@ -6431,21 +6136,7 @@ interface BuiltinToolOptions {
     sticky?: StickyStyle;
     /** The knife: screen px around the first point within which a click closes the cut. */
     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;
+        closeHitRadius?: number;
     };
 }
 
@@ -6492,6 +6183,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 +6229,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 +6298,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 +6411,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 +6450,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. */
@@ -6795,8 +6501,8 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      * 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;
     /**
@@ -6960,8 +6666,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 +6746,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 +6762,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 +6791,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 +6916,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 +6944,20 @@ 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 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 +7008,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 +7158,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 +7193,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 +7359,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 +7404,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 +7547,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.
  *
@@ -8426,29 +8172,6 @@ interface TransformArgs<TPose> {
  *  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 createArrangeOp(args: ArrangeArgs, compute?: () => ArrangedPose[], write?: (id: string, pose: unknown) => void): Op;
-
 /**
  * A node's position among its siblings, recorded so an op can put it back.
  *
@@ -8605,6 +8328,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 +8476,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 +8513,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 +8720,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 +8787,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 +9372,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;
@@ -10203,6 +10004,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 +10433,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 +10554,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 +10642,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 +10837,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 +10848,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 +10927,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 +10964,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;
@@ -11039,12 +11050,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 +11068,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 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 CameraProps, 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 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_SHAPE_FILL, 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 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, 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 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, 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, 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_TOOLS, 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 WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenNode, type WrittenPoseTargetOptions, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, addPage, adjacentPage, 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, 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, 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, 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, moveNodes, moveNodesOps, movePage, movePreset, multiActive, nestedHitTester, never, nextPageId, nodeGates, nodeOutline, normalizeView, normalizeZoom, not, nudgeAnchorsDownAction, nudgeAnchorsLeftAction, nudgeAnchorsRightAction, nudgeAnchorsUpAction, onEmptyCanvas, opFactoryRegistry, openContextMenu, openFilePicker, or, outlinePreset, overChildren, pageAt, pageHolding, pageInView, pageMembers, pageName, pageOfBounds, pagesBounds, pagesLayer, pagesOf, 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, regenerateShape, registerNodeShape, registerOpFactory, registeredOpNames, registeredPathEffects, releaseCanvasRenderer, removePage, renamePage, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, requiresAnchorSelection, reshapeOps, reshapeTo, resizeAction, resizePage, resizePreset, resolveBooleanOperands, resolveEditablePathOf, resolveOverlays, 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, stableStringify, staggerSpringPose, startThresholdDrag, stepAngles, storeEditablePath, strokeOf, strokeRegion, strokeWith, 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, 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, viewPreset, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportWorldRect, viewportZoomAction, warmRender, watchDevicePixelRatio, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withPath, withPathEffectsRegistry, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldToScreen, writtenBy, zoomAt, zoomAtLeast };