@weasel-js/core 1.13.0 → 1.14.0

package/dist/index.d.ts

@@ -1,24 +1,25 @@
-import { D as Dims, R as RenderLayer, L as LayerHit, h as LayerDims, V as ViewAnimationOptions, a as PathEditExtension, i as ViewportDims, F as FitViewToBoundsOptions, j as RedrawSource, k as EditAnchorsParams, I as InertiaConfig, E as EditAnchorsDep, G as GestureLifecycleOptions, l as SliceDep, m as StickyStyle, n as EnteredGroupApi, C as ContentHandlerEntry, A as AnchorMarkerShape, P as PathEditMark, o as ChromeState, p as LayerGroup, S as SnapSource, T as TransformFollower, q as GeometryProjection, r as InsertNodeFactory, s as InsertPaint, t as SvgIngestOptions, u as SceneCanvasSnap, v as Affordance, w as AffordanceRegion, x as AffordanceBinding, y as CommonAffordanceScratch, z as TextOverflow, B as CreateOutlinesAdapter, J as PaintKindEntry, K as PathEditTarget, M as FinishedEditFrame, N as PathSymmetryDep, H as HandleLocks, O as BooleanOpOptions, Q as BooleansAdapter, U as BooleanOp, W as PathPaint, X as BooleanOpResult, Y as BooleanStrokes, Z as SnapMods, $ as SourceCandidate, a0 as SnapProbeAt, a1 as SnapCollect, a2 as SnapMark, b as SnapGesture, a3 as SnapDep, a4 as SnapOutcome, f as SnapOutcomeStore, a5 as SnapReadoutStyle } from './depSchema-CpIQzKWQ.js';
-export { a6 as AngleCandidate, a7 as AngleCollect, a8 as AnimateToBoundsOptions, a9 as AreaSelectDep, aa as BooleanOpPreview, ab as BooleanPreviewPiece, ac as CanDropIntoDep, ad as ClipboardDep, ae as ClipboardIngestCtx, af as CreateOutlinesResult, ag as CustomPaintContext, ah as DEFAULT_LAYER_RETAIN, ai as DecayLoopConfig, aj as FinishedPathEdit, ak as GEOMETRY_BOUND_DATA, al as HandleLock, am as HitTestView, an as IngestCtx, ao as IngestionDep, ap as InsertDep, aq as InsertEnds, ar as InsertExtras, as as InsertIntoDep, at as InsertLive, au as LassoSelectDep, av as LayerCommandCache, aw as LayerDrawFailure, ax as LayerDrawSpan, ay as LayerRetainPolicy, az as LayoutDep, aA as Locus, aB as MinSize, aC as NodeAtPointDep, aD as OutlinePathSpec, aE as PATH_OVERLAY_ROLES, aF as PaintKind, aG as PaintKindEditorProps, aH as PaintKindFamily, aI as PaintKindLoader, aJ as PanBounds, aK as PathEditDrag, aL as PathEditDragStart, aM as PathEditFinishCtx, aN as PathEditHandleMove, aO as PathEditMarksCtx, aP as PathEditOther, aQ as PathEditPart, aR as PathEditStore, aS as PathForm, aT as PathOverlay, aU as PathOverlayOptions, aV as PathOverlayStyle, aW as PathRepresentation, aX as PathTransformFinishCtx, aY as PreviewPathsDep, aZ as ResizePolicy, a_ as STICKY_DEFAULTS, a$ as SnapBegin, c as SnapConstrain, b0 as SnapEdge, b1 as SnapEdges, e as SnapGeometry, b2 as SnapMarks, b3 as SnapReadoutDep, d as SnapResizeBox, g as SnapSession, b4 as SvgUnpacker, b5 as TextEditDep, b6 as TextNodeData, b7 as TransformPreviewNode, b8 as TransientPath, b9 as VIEW_ANIMATION_KEY, ba as ViewAnimationApi, bb as ViewApi, bc as ViewChannel, bd as applyBooleanOp, be as applyCreateOutlines, bf as asPaint, bg as createEnteredGroup, bh as createPathOverlay, bi as createSnapOutcomeStore, bj as depsUnchanged, bk as drawLayers, bl as drawOneLayer, bm as fitViewToBounds, bn as getPaintKind, bo as isLayerPainted, bp as isLayerVisible, bq as listGradientKinds, br as listPaintKinds, bs as minSizeOf, bt as paintKindOf, bu as paintKindRegistry, bv as paintedLayers, bw as paintsLayer, bx as paletteInsertPaint, by as pathPaintOf, bz as patternFamily, bA as previewBooleanOp, bB as registerContentHandler, bC as registerPaintKind, bD as registerPaintKindLoader, bE as seedTile, bF as stickyData, bG as stickyNodeFactory, bH as subscribeToSources, bI as switchGradientKind, bJ as textBoxOf, bK as useDecayLoop, bL as useEnteredGroup, bM as useViewAnimation, bN as useViewAnimationOn, bO as viewAxes, bP as withoutGeometryBoundData } from './depSchema-CpIQzKWQ.js';
-import { View, Scale2, Path, FramedBox, PolygonPath, GlMat3, Point as Point$3, AnchorField, AnchorSet, PlacementAlign, Rect, Affine, PathSnapKind, PathInWorldPose, AnchorFieldValues, NumberEntry, JoinOptions, SegmentHit, PointOrigin, AnchorSymmetry, BlendPathsOptions, RunAlign, TrackSide, BendAlongPathOptions, RepeatAlongPathOptions, PoseLinear } from '@weasel-js/geom';
-export { AnchorField, AnchorFieldValues, AnchorPair, AverageAxis, BendAlongPathOptions, BezierEasing, BlendPathsOptions, FramedBox as Bounds, CONSTRAINT_TOLERANCE, CORNER_FIT_TOLERANCE, CORNER_KEYWORDS, ConstrainedPathEdit, ConstraintPoint, CornerFrame, CornerKeyword, CornerPiece, CornerShape, CornerShapeFrame, CornerSpec, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EasingFn, EasingName, EasingSpec, ExtendToMeetOptions, JoinOptions, MeasurePathOptions, NumberEntry, OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, PathBlend, PathBuilder, PathConstraint, PathConstraintKind, PathCrossing, PathFillRule, PathInWorldPose, PathMeasure, PathSegment, PathSnapHit, PathSnapIndex, PathSnapKind, PathSnapQuery, PathStation, PathStop, PenAnchor, PointAlongPathOptions, PointInPathOptions, PolygonPath, PoseLinear, PoseRotation, Rect, RectPath, RepeatAlongPathOptions, RepeatStation, ResolvedCorners, SPRING_PRESETS, Scale2, SegmentCrossing, SimplifyPathOptions, SmudgePathOptions, SolveConstraintsOptions, SolveConstraintsResult, SpringPreset, SpringPresetName, TrimPathOptions, TrimResult, Point as Vec2, View, ZOOM_FLOOR, asPolygonPath, averageAnchorsAt, bendAlongPath, blendPaths, boundsOfPath, circlePath, composePath, constrainPathEdit, constraintAnchors, cornerAt, cornerFrameAt, cornerFrames, cornerKeywordOf, cornerShapeK, cornerShapePieces, cornerSpecAt, countPathAnchors, createPathSnapIndex, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, extendToMeet, findPathSnap, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasCorners, hasOpenSubpath, intersectSegments, isCornerShape, joinAnchorsAt, lengthenOpenEnd, linePath, linear, meanScale, measurePath, nextCornerShape, openEndRay, openPathEnds, pathAnchorPoints, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathSignedArea, pathThroughPoseFrame, pathToAnchors, pathToD, pointAlongPath, pointInPath, polygonFromPoints, polylineFromPoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, remapPerAnchor, repeatAlongPath, resolveCorners, resolveCornersWithSources, resolveEasing, reversePath, rotatePathAround, roundRectPath, scaleDelta, scalePathToBounds, screenAngleOf, simplifyAnchorsAt, simplifyPath, smudgePath, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, starPath, stationsAlongPath, transformPath, translatePath, trimPathAt, unionBoundsPath, unsatisfiedConstraints, withCorner, withinPxBox, withinPxRadius, withoutCorners, worldEditToStorage } from '@weasel-js/geom';
-import { a as PlaneMap, L as LayoutStrategy, R as ReflowTransition, b as LayoutDropTargetMode } from './types-49uYJN3j.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-49uYJN3j.js';
+import { D as Dims, R as RenderLayer, L as LayerHit, h as LayerDims, V as ViewAnimationOptions, a as PathEditExtension, i as ViewportDims, F as FitViewToBoundsOptions, j as RedrawSource, k as EditAnchorsParams, I as InertiaConfig, E as EditAnchorsDep, G as GestureLifecycleOptions, l as SliceDep, m as StickyStyle, A as AnchorMarkerShape, P as PathEditMark, T as TextOverflow, n as EnteredGroupApi, C as ContentHandlerEntry, o as ChromeState, p as LayerGroup, S as SnapSource, q as TransformFollower, r as GeometryProjection, s as InsertNodeFactory, t as InsertPaint, u as SvgIngestOptions, v as SceneCanvasSnap, w as Affordance, x as AffordanceRegion, y as AffordanceBinding, z as CommonAffordanceScratch, B as CreateOutlinesAdapter, J as PaintKindEntry, K as PathEditTarget, M as FinishedEditFrame, N as PathSymmetryDep, H as HandleLocks, O as BooleanOpOptions, Q as BooleansAdapter, U as BooleanOp, W as PathPaint, X as BooleanOpResult, Y as BooleanStrokes, Z as SnapMods, $ as SourceCandidate, a0 as SnapProbeAt, a1 as SnapCollect, a2 as SnapMark, b as SnapGesture, a3 as SnapDep, a4 as SnapOutcome, f as SnapOutcomeStore, a5 as SnapReadoutStyle } from './depSchema-C3BwxitB.js';
+export { a6 as AngleCandidate, a7 as AngleCollect, a8 as AnimateToBoundsOptions, a9 as AreaSelectDep, aa as BooleanOpPreview, ab as BooleanPreviewPiece, ac as CanDropIntoDep, ad as ClipboardDep, ae as ClipboardIngestCtx, af as CreateOutlinesResult, ag as CustomPaintContext, ah as DEFAULT_LAYER_RETAIN, ai as DecayLoopConfig, aj as DropRefusal, ak as DropVerdict, al as FinishedPathEdit, am as GEOMETRY_BOUND_DATA, an as HandleLock, ao as HitTestView, ap as IngestCtx, aq as IngestionDep, ar as InsertDep, as as InsertEnds, at as InsertExtras, au as InsertIntoDep, av as InsertLive, aw as LassoSelectDep, ax as LayerCommandCache, ay as LayerDrawFailure, az as LayerDrawSpan, aA as LayerRetainPolicy, aB as LayoutDep, aC as Locus, aD as MinSize, aE as NodeAtPointDep, aF as OutlinePathSpec, aG as PATH_OVERLAY_ROLES, aH as PaintKind, aI as PaintKindEditorProps, aJ as PaintKindFamily, aK as PaintKindLoader, aL as PanBounds, aM as PathEditDrag, aN as PathEditDragStart, aO as PathEditFinishCtx, aP as PathEditHandleMove, aQ as PathEditMarksCtx, aR as PathEditOther, aS as PathEditPart, aT as PathEditStore, aU as PathForm, aV as PathOverlay, aW as PathOverlayOptions, aX as PathOverlayStyle, aY as PathRepresentation, aZ as PathTransformFinishCtx, a_ as PoseChange, a$ as PreviewPathsDep, b0 as ResizePolicy, b1 as STICKY_DEFAULTS, b2 as SnapBegin, c as SnapConstrain, b3 as SnapEdge, b4 as SnapEdges, b5 as SnapFrame, e as SnapGeometry, b6 as SnapMarks, b7 as SnapReadoutDep, d as SnapResizeBox, g as SnapSession, b8 as SvgUnpacker, b9 as TextEditDep, ba as TextNodeData, bb as TransformPreviewNode, bc as TransientPath, bd as VIEW_ANIMATION_KEY, be as ViewAnimationApi, bf as ViewApi, bg as ViewChannel, bh as applyBooleanOp, bi as applyCreateOutlines, bj as asPaint, bk as createEnteredGroup, bl as createPathOverlay, bm as createSnapOutcomeStore, bn as depsUnchanged, bo as drawLayers, bp as drawOneLayer, bq as fitViewToBounds, br as getPaintKind, bs as isLayerPainted, bt as isLayerVisible, bu as listGradientKinds, bv as listPaintKinds, bw as minSizeOf, bx as paintKindOf, by as paintKindRegistry, bz as paintedLayers, bA as paintsLayer, bB as paletteInsertPaint, bC as pathPaintOf, bD as patternFamily, bE as previewBooleanOp, bF as refusalOf, bG as registerContentHandler, bH as registerPaintKind, bI as registerPaintKindLoader, bJ as seedTile, bK as stickyData, bL as stickyNodeFactory, bM as subscribeToSources, bN as switchGradientKind, bO as textBoxOf, bP as useDecayLoop, bQ as useEnteredGroup, bR as useViewAnimation, bS as useViewAnimationOn, bT as viewAxes, bU as withoutGeometryBoundData } from './depSchema-C3BwxitB.js';
+import { View, Scale2, Path, FramedBox, PolygonPath, Affine, GlMat3, Point, AnchorField, AnchorSet, PlacementAlign, Rect, PathSnapKind, PathInWorldPose, AnchorFieldValues, NumberEntry, JoinOptions, SegmentHit, PointOrigin, AnchorSymmetry, BlendPathsOptions, RunAlign, TrackSide, BendAlongPathOptions, RepeatAlongPathOptions, RoughenPathOptions, ZigzagPathOptions, PuckerBloatPathOptions, 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, PuckerBloatPathOptions, Rect, RectPath, RepeatAlongPathOptions, RepeatStation, ResolvedCorners, RoughenPathOptions, SPRING_PRESETS, Scale2, SegmentCrossing, SimplifyPathOptions, SmudgePathOptions, SolveConstraintsOptions, SolveConstraintsResult, SpringPreset, SpringPresetName, TrimPathOptions, TrimResult, Point as Vec2, View, ZOOM_FLOOR, ZigzagPathOptions, 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, puckerBloatPath, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, remapPerAnchor, repeatAlongPath, resolveCorners, resolveCornersWithSources, resolveEasing, reversePath, rotatePathAround, roughenPath, 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, zigzagPath } from '@weasel-js/geom';
+import { a as PlaneMap, L as LayoutStrategy, R as ReflowTransition, b as LayoutDropTargetMode } from './types-A_sNJYRd.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-A_sNJYRd.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 { R as RectPose, a as SystemLayerSpec, A as AddNodeSpec, b as RegisteredOp, c as SceneRegistry, P as PoseComposition, L as LayoutFrame, N as Node, I as InheritedPaint, 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 SerializedSceneV1, k as SpecsFromSerializedOptions, l as NodeClip, m as DerivePathFn, n as DerivedDep } from './types-BEdRIhNc.js';
-export { o as AddLayerSpec, B as Bivariant, C as ClipFromPoseFn, p as CopiesFromPoseFn, G as GroupNode, q as IDENTITY_POSE_COMPOSITION, r as LayerRecord, s as LayoutMove, M as MarkNode, t as PoseClosure, u as PoseHold, v as PoseOverride, w as PoseWriteOrigin, x as RemovedNode, y as SCENE_HISTORY_FORM, z as SceneArrivalHandler, E as SceneBatchOptions, F as SceneDeclaredFieldSetters, H as SceneDoc, J as SceneDocValues, K as SceneEditPass, O as SceneEditPassOptions, Q as SceneEditSummary, T as SerializedDoc, U as SerializedLayer, V as SerializedNode, W as SerializedNodeV1, X as SerializedSceneHistory, Y as SkippedKey, Z as SystemLayerRecord, _ as UserLayerRecord, $ as V1Classifier, a0 as asNodeId, a1 as composeWorldPose, a2 as composesFrames, a3 as inheritedPaintIn, a4 as inheritedPaintOf, a5 as inheritsPaint, a6 as nodeKindOf, a7 as rebaseLocalPose, a8 as specsFromSerialized, a9 as withInheritedPaint } from './types-BEdRIhNc.js';
-import { NodeId, SelectionMode, SelectionExtendKey, SelectionApi, IngestItem, OngoingOverlay, PointerSessionCancelReason, DeviceProfile, Bounds, Tool as Tool$1, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, ToolDef as ToolDef$1, DepName, DepSchema, Action, ActionDeps, GestureBinding, AffordanceHit, ActionDisabledReason, ToolKeybinding, HotkeyTrigger, ModifierState, RuleCtx, Rule, ActionTunings, BindingOverrides, ActionsProp, DebugSink, ToolSet, ToolEntry, Dispatcher, OverlayRole, ResizeAnchor, InvocationCtx, OngoingHandle } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDisabledReasonValue, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionParamSchema, ActionParams, ActionPresentation, ActionSettings, ActionSettingsState, ActionShortcut, ActionTuning, ActionTunings, ActionUnavailable, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingOverrides, BindingScope, BindingSource, BoundGesture, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, CaptureGestureOptions, CaptureKeyOptions, CaptureKind, CapturedSpec, Carried, Carry, CarryCallbacks, CarryPayload, CarryPointer, CarryStage, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepListing, DepName, DepRegistry, DepSchema, DepSource, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, GestureKitSettings, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, KEYMAP_HOLD, KeyBinding, KeyReach, KeymapDef, KeymapDescription, KeymapRow, KeymapStack, KeymapUnbound, KeymapVerdict, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, MenuDef, MenuHit, MenuHost, MenuOpenRequest, MenuSources, ModeShortcutHandlers, ModifierRole, ModifierRoles, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OpenKeymap, OpenMenu, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedBindingOverrides, ResolvedCandidate, RoleKeys, RoleRebinds, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolEntry, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSet, ToolSlot, TunedBinding, UiOngoingControl, ViewportGestureKind, WalkStep, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, actionShortcuts, actionsTagged, activatesFocusedControl, assembleEntries, bindingId, buildDepsFromRequires, buildRuleCtx, captureGesture, captureKey, clientToCanvas, createDepRegistry, createDispatcher, createKeymapStack, createLongPressStore, defineTool, deleteScratch, describeKeymap, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, isDebugEnabled, isEditableTarget, isInControlWithin, isToolSet, keySpecShortcut, keymapContribution, keymapLeaderBindingId, keymapLeaderId, keymapShortcuts, keysHeld, liveScope, matchActionItem, matchesKeyBinding, modeShortcutSpec, modeShortcuts, modifierStateOf, openPointerSession, overlaysOf, pastDragThreshold, readActionSettings, resolveBindingOverrides, resolveDeviceProfile, resolveParams, resolveSchemaMenu, roleReader, scopeBindings, scratchKey, setScratch, specificity, startCarry, taggedActionItems, toolIdsOf, toolSet, toolSetHas, tuneAction, withoutTools } from '@weasel-js/routing';
+import { R as RectPose, a as SystemLayerSpec, A as AddNodeSpec, b as RegisteredOp, c as SceneRegistry, P as PoseComposition, L as LayoutFrame, N as Node, I as InheritedPaint, d as ScrollOffset, e as PoseAdapter, S as Scene, f as PoseRemoval, g as PoseWrite, h as ScenePoseReports, i as PoseOverrides, j as SerializedScene, D as DerivePoseFn, k as SavedScene, l as SpecsFromSerializedOptions, m as NodeClip, n as DerivePathFn, o as DerivedDep } from './types-DW14eu9B.js';
+export { p as AddLayerSpec, B as Bivariant, C as ClipFromPoseFn, q as CopiesFromPoseFn, G as GroupNode, r as IDENTITY_POSE_COMPOSITION, s as LayerRecord, t as LayoutMove, M as MarkNode, u as PoseClosure, v as PoseHold, w as PoseOverride, x as PoseWriteOrigin, y as RemovedNode, z as SCENE_HISTORY_FORM, E as SceneArrivalHandler, F as SceneBatchOptions, H as SceneDeclaredFieldSetters, J as SceneDoc, K as SceneDocValues, O as SceneEditPass, Q as SceneEditPassOptions, T as SceneEditSummary, U as SceneScroll, V as ScrollOffsets, W as ScrollSource, X as SerializedDoc, Y as SerializedLayer, Z as SerializedNode, _ as SerializedNodeV1, $ as SerializedSceneHistory, a0 as SerializedSceneV1, a1 as SerializedSceneV2, a2 as SkippedKey, a3 as SystemLayerRecord, a4 as UserLayerRecord, a5 as V1Classifier, a6 as asNodeId, a7 as childFrameAt, a8 as composeChildFrame, a9 as composeWorldPose, aa as composesFrames, ab as createScrollOffsets, ac as inheritedPaintIn, ad as inheritedPaintOf, ae as inheritsPaint, af as isSerializedScene, ag as nodeKindOf, ah as rebaseLocalPose, ai as scrolledFrames, aj as specsFromSerialized, ak as viewPoseAdapter, al as withInheritedPaint } from './types-DW14eu9B.js';
+import * as _weasel_js_routing from '@weasel-js/routing';
+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, WorldPoint, GestureBinding, AffordanceHit, ActionDisabledReason, ToolKeybinding, HotkeyTrigger, ModifierState, RuleCtx, Rule, ActionTunings, BindingOverrides, ActionsProp, DebugSink, ToolSet, ToolEntry, Dispatcher, OverlayRole, ResizeAnchor, InvocationCtx, OngoingHandle } from '@weasel-js/routing';
+export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDisabledReasonValue, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionParamSchema, ActionParams, ActionPresentation, ActionSettings, ActionSettingsState, ActionShortcut, ActionTuning, ActionTunings, ActionUnavailable, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingOverrides, BindingScope, BindingSource, BoundGesture, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, CaptureGestureOptions, CaptureKeyOptions, CaptureKind, CapturedSpec, Carried, Carry, CarryCallbacks, CarryPayload, CarryPointer, CarryStage, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepListing, DepName, DepRegistry, DepSchema, DepSource, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, GestureKitSettings, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, ImmediateParams, IngestItem, InputEvent, InvocationCtx, Invoker, KEYMAP_HOLD, KeyBinding, KeyReach, KeymapDef, KeymapDescription, KeymapRow, KeymapStack, KeymapUnbound, KeymapVerdict, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, MenuAccess, MenuCustomAt, MenuDef, MenuHit, MenuHost, MenuOpenRequest, MenuSources, ModeShortcutHandlers, ModifierRole, ModifierRoles, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OpenKeymap, OpenMenu, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedBindingOverrides, ResolvedCandidate, RoleKeys, RoleRebinds, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolEntry, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSet, ToolSlot, TunedBinding, UiOngoingControl, ViewportGestureKind, WalkStep, WorldPoint, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, actionShortcuts, actionsTagged, activatesFocusedControl, assembleEntries, bindingId, buildDepsFromRequires, buildRuleCtx, captureGesture, captureKey, clientToCanvas, createDepRegistry, createDispatcher, createKeymapStack, createLongPressStore, defineTool, deleteScratch, describeKeymap, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, holdPreview, holdPreviewId, isDebugEnabled, isEditableTarget, isInControlWithin, isToolSet, keySpecShortcut, keymapContribution, keymapLeaderBindingId, keymapLeaderId, keymapShortcuts, keysHeld, liveScope, matchActionItem, matchesKeyBinding, modeShortcutSpec, modeShortcuts, modifierStateOf, openPointerSession, overlaysOf, pastDragThreshold, readActionSettings, resolveBindingOverrides, resolveDeviceProfile, resolveParams, resolveSchemaMenu, roleReader, scopeBindings, scratchKey, setScratch, specificity, startCarry, taggedActionItems, toolIdsOf, toolSet, toolSetHas, tuneAction, withoutTools } from '@weasel-js/routing';
 import * as react from 'react';
-import react__default, { Ref, RefObject, ReactNode, MutableRefObject, MouseEvent } from 'react';
+import react__default, { Ref, RefObject, ReactNode, MutableRefObject } from 'react';
 import { Reflection } from '@weasel-js/registry';
 export { MIXED, Mixed, QueryMatch, Reflectable, ReflectedEntry, Reflection, RegisterOptions, Registrant, createReflectable, isPlainObject } from '@weasel-js/registry';
 export { stableStringify } from './json.js';
-import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-DN2yfnq_.js';
-export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-DN2yfnq_.js';
+import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-CvSxVhCd.js';
+export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, T as TranslateLead, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-CvSxVhCd.js';
 import { KitSettingsStore } from '@weasel-js/react';
-export { CanvasFocusReturn, FrameClock, FrameClockOptions, UseCanvasFocusOptions, VisibleRaf, VisibleRafOptions, VisibleRafTarget, useCanvasFocus, useFrameClock, useLatest, useVisibleRaf } from '@weasel-js/react';
+export { CanvasFocusReturn, UseCanvasFocusOptions, VisibleRaf, VisibleRafOptions, VisibleRafTarget, useCanvasFocus, 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, ImageMinification, ShaderProgramHandle, CommandStroke as CommandStroke$1 } from '@weasel-js/renderer';
@@ -29,41 +30,42 @@ import { VertexColorChannel, Target, Animator, ColorOverrideRegistry, TargetAxes
 import { SelectionStore as SelectionStore$1 } from '@weasel-js/select';
 import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1, PointerContextValue, Yoke } from '@weasel-js/routing/react';
 export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, CommandOptions, DepRegistryProvider, DispatcherChannels, InputScope, OngoingAction, PointerContextProvider, PointerContextValue, PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, SelectionContextValue, UseGestureDispatcherOptions, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOngoingAction, useOpenKeymap, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useYoke } from '@weasel-js/routing/react';
-import { Paint, CommandFill, CommandStroke, CommandPaint, Fill, Inherit, Stroke, Palette, SolidPaint, VertexWidth, PaintedFill, PaintedStroke } from '@weasel-js/paint';
-export { ColorInterpolationSpace, ColorSpace, CommandFill, CommandPaint, CommandPaintUnits, CommandStroke, Fill, GradStop, GradientKind, GradientPaint, HalfWidths, HueInterpolation, INHERIT, Inherit, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Paint, PaintUnits, PaintedFill, PaintedStroke, PatternPaint, PatternPlacement, PatternTransform, PatternTransformParts, PosedPaint, Region, STROKE_DASH_RATIOS, ScreenLength, SolidPaint, Stroke, StrokeAlign, StrokeDashStyle, StrokeNib, TILE_KINDS, TextureHandle, TexturePaint, TileKind, TilePaint, TilePatternSpec, VertexWidth, VertexWidthSides, alignedStrokeRect, composePatternTransform, contrastLineColor, contrastRatio, dashForStrokeStyle, decomposePatternTransform, gradientForBounds, gradientGeometry, hexToOklchDeg, hexToRgbBytes, hexToRgba, hslToSrgb, interpolateSrgb, isGradientPaint, isPatternPaint, isSolidPaint, isTileKind, isTilePaint, lerpColorArray, lerpFill, lerpOklab, lerpOklch, lerpPaint, lerpStroke, linearSrgbToOklab, linearToSrgb, normalizeHex, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, parseColor, parseColorToRgba255, parseHexBytes, patternPlacementOf, resolveColor, resolveFill, resolveScreenLength, resolveStroke, rgbaToHex, sampleGradientStops, scaleVertexWidth, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf, tileSpecOf, vertexHalfWidths, vertexWidthFromSides, wcagLevels, widestHalfWidth, withGradientKind } from '@weasel-js/paint';
+import { Paint, CommandFill, CommandStroke, Fill, Inherit, Stroke, CommandPaint, Palette, SolidPaint, VertexWidth, PaintedFill, PaintedStroke } from '@weasel-js/paint';
+export { ColorInterpolationSpace, ColorSpace, CommandFill, CommandPaint, CommandPaintUnits, CommandStroke, Fill, GradStop, GradientKind, GradientPaint, HalfWidths, HueInterpolation, INHERIT, ImagePatternPaint, Inherit, KitMarkerKey, MarkerKey, MarkerRef, OklchDeg, Paint, PaintUnits, PaintedFill, PaintedStroke, PatternPaint, PatternPlacement, PatternTransform, PatternTransformParts, PosedPaint, Region, STROKE_DASH_RATIOS, ScreenLength, SolidPaint, Stroke, StrokeAlign, StrokeDashStyle, StrokeNib, TILE_KINDS, TextureHandle, TexturePaint, TileExtent, TileKind, TilePaint, TilePatternSpec, VertexWidth, VertexWidthSides, alignedStrokeRect, composePatternTransform, contrastLineColor, contrastRatio, dashForStrokeStyle, decomposePatternTransform, gradientForBounds, gradientGeometry, hexToOklchDeg, hexToRgbBytes, hexToRgba, hslToSrgb, interpolateSrgb, isGradientPaint, isImagePatternPaint, isPatternPaint, isSolidPaint, isTileKind, isTilePaint, lerpColorArray, lerpFill, lerpOklab, lerpOklch, lerpPaint, lerpStroke, linearSrgbToOklab, linearToSrgb, normalizeHex, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, parseColor, parseColorToRgba255, parseHexBytes, patternPlacementOf, resolveColor, resolveFill, resolveScreenLength, resolveStroke, rgbaToHex, sampleGradientStops, scaleVertexWidth, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf, tileSpecOf, vertexHalfWidths, vertexWidthFromSides, wcagLevels, widestHalfWidth, withGradientKind } from '@weasel-js/paint';
 import { FontRequest } from '@weasel-js/font';
 export { FaceMetrics, FaceRuleMetrics, FaceScriptMetrics, FontFamilyFaces, FontRequest, FontStyle, FontVariant, LocalFontOutlinesResult, OutlineFaceInfo, OutlineSource, OutlineStatus, OutlineVariant, RegisterFontOptions, canQueryLocalFonts, cssFamilyName, cssFontFamily, cssFontFamilyLoading, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, outlineStatus, refreshCanvasFont, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines, warmFonts } from '@weasel-js/font';
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, CreateHistoryOptions, History, HistorySelection } from '@weasel-js/history';
 export { BeginJournalOptions, CreateHistoryOptions, EvictedEntry, History, HistoryBranch, HistoryEntry, HistoryLogger, HistorySelection, 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-qb2e1F5p.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-qb2e1F5p.js';
-import { d as ResizeHandleLayout, U as UseResizeOptions, T as TargetTransform } from './cornerHandles-CNCb7aTY.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-CNCb7aTY.js';
+import { G as GestureContext, B as BoundsConstraint, R as RotateBehavior, I as InsertBehavior, L as LassoSelectBehavior, M as MoveBehavior } from './clone-Bz4iqGfE.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-Bz4iqGfE.js';
+import { d as ResizeHandleLayout, U as UseResizeOptions, T as TargetTransform } from './cornerHandles-DpmQM_z5.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-DpmQM_z5.js';
 import { ModeRegistry, WorkspaceVisual, ModeDecorations, NodeScope } 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-p2alu-R1.js';
-export { R as RegionPickView, S as SnapTarget } from './types-p2alu-R1.js';
+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-VCtfchp-.js';
+export { R as RegionPickView, S as SnapTarget } from './types-VCtfchp-.js';
 import * as _weasel_js_gestures from '@weasel-js/gestures';
+import { KeySpec } from '@weasel-js/gestures';
 export { BindingOverrideInput, CarrySpec, ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetPredicate, TargetSpec, WheelSpec, bindingSpec, bodyPredicate, held, hitPredicate, key, keySpecRoute, unbound } from '@weasel-js/gestures';
-import { U as UseMoveOptions } from './options-ClEm3SEl.js';
+import { U as UseMoveOptions } from './options-DAjkhbcs.js';
 import { IconRef, IconTable, IconVariantLoader, IconRegistry, IconGlyph, IconEntry, IconVariantState } from '@weasel-js/icons';
 export { IconRef, IconTable, toIconRef } from '@weasel-js/icons';
+import { TextStyle, StyledRun, TextVerticalAlign, TextPaint, TextPose, TextOutlinesError } from '@weasel-js/text';
+export { CacheUse, DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, DecorationKind, FaceMetricsFn, FitTextPoseOptions, FlagKey, FontVariantCaps, LabelOptions, LaidOutCell, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredSpan, MeasuredText, PaintRunsOpts, PaintedRuns, PlacedGlyph, PointInTextPoseOpts, PositionedRun, QUAD_STRIDE, RangeStyle, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, RunSourceMap, RunStylePatch, SCRIPT_METRICS, SMALL_CAPS_SCALE, ScriptPreset, SetFlagResult, ShapedCluster, ShapedGlyph, SmallCapsText, StyleKey, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextNodeSource, TextOutlineSource, TextOutlinesError, TextOutlinesFailure, TextPaint, TextPaintPath, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextShaper, TextStyle, TextToPathOptions, TextTransform, TextVerticalAlign, TransformedRunText, applyStyleToRange, cachedLayoutRuns, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, dropRuns, effectiveRangeStyle, fitTextPose, fontString, halfLeadingFor, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutRuns, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, paragraphDirection, patchRangeStyle, pointInTextPose, rangeWeight, registerBidi, registerShaper, renderLabel, resolveAlign, resolveRunFace, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset } from '@weasel-js/text';
+import { UseTextEditReturn } from '@weasel-js/text-dom';
+export { StartEditOptions, StyleToggle, TEXT_EDIT_FONT_HOLD, TextEditClipRect, TextEditCommit, TextEditScreenPose, TextEditSelection, UseTextEditOptions, UseTextEditReturn, charOffsetToDomPosition, domPositionToCharOffset, domToRuns, runsToDom, useTextEdit } from '@weasel-js/text-dom';
 import * as _weasel_js_prefs from '@weasel-js/prefs';
 import { PrefSection, PrefNumberUnit } from '@weasel-js/prefs';
 import { UnitScope } from '@weasel-js/quantity';
 export { ANGLE_RADIANS, IMPERIAL_INCHES, METRIC_MM, PIXELS, PerAxis, PlaneUnits, PlaneValue, ScopeTree, Unit, UnitEntry, UnitExpr, UnitExprContext, UnitScale, UnitScope, UnitSystem, UnitValue, axisUnits, formatAxes, formatScoped, formatUnit, fromRoot, parseUnitExpr, resolveAxes, resolveScoped, resolveUnit, resolveUnitExpr, scopesOf, toRoot, unitScale } from '@weasel-js/quantity';
-import { TextPose, TextStyle, StyledRun, TextVerticalAlign, TextPaint, TextOutlinesError } from '@weasel-js/text';
-export { DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, DecorationKind, FaceMetricsFn, FitTextPoseOptions, FlagKey, FontVariantCaps, LabelOptions, LaidOutCell, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredSpan, MeasuredText, PaintRunsOpts, PaintedRuns, PlacedGlyph, PointInTextPoseOpts, PositionedRun, QUAD_STRIDE, RangeStyle, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, RunSourceMap, RunStylePatch, SCRIPT_METRICS, SMALL_CAPS_SCALE, ScriptPreset, SetFlagResult, SmallCapsText, StyleKey, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextNodeSource, TextOutlineSource, TextOutlinesError, TextOutlinesFailure, TextPaint, TextPaintPath, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextToPathOptions, TextTransform, TextVerticalAlign, TransformedRunText, applyStyleToRange, cachedLayoutRuns, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, fontString, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutRuns, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, paragraphDirection, patchRangeStyle, pointInTextPose, rangeWeight, registerBidi, renderLabel, resolveAlign, resolveRunFace, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset } from '@weasel-js/text';
-import { UseTextEditReturn } from '@weasel-js/text-dom';
-export { StartEditOptions, StyleToggle, TEXT_EDIT_FONT_HOLD, TextEditClipRect, TextEditCommit, TextEditScreenPose, TextEditSelection, UseTextEditOptions, UseTextEditReturn, charOffsetToDomPosition, domPositionToCharOffset, domToRuns, runsToDom, useTextEdit } from '@weasel-js/text-dom';
 export { BUILTIN_MARKERS, MarkerCtx, MarkerEntry, MarkerPaint, MarkerSite, MarkerSiteRequest, OffsetPathOptions, StrokeToPathOptions, getMarker, listMarkers, markerInset, markerKeyOf, markerRegistry, markerSites, offsetPath, registerMarker, resolveMarkerSize, resolveStrokeWidth, strokeInsets, strokeToPath } from '@weasel-js/stroke';
 export { Polyline, trimPolyline } from '@weasel-js/geom/tessellate';
-export { C as CLIP_NOTHING, a as aabbCenter, c as clipNothing, p as pointInRotatedRect, r as rectCorners, b as rotatePoint, d as rotatedRectCorners } from './math-C_elShP_.js';
+export { C as CLIP_NOTHING, a as aabbCenter, c as clipNothing, p as pointInRotatedRect, r as rectCorners, b as rotatePoint, d as rotatedRectCorners } from './math-B_unOnF4.js';
 export { SnipAtCrossingsOptions, SplitBySegmentOptions, pathDivide, pathExclude, pathIntersect, pathSubtract, pathUnion, snipPathByPolyline, snipPathsAtCrossings, splitPathByPolyline, splitPathBySegment, trianglesToPath } from '@weasel-js/geom/booleans';
 export { CURVE_REPS, CurveRepKind, CurveRepresentation, Discriminator, SharedAnchor, bezierCubic, bezierQuadratic, nurbs, spiro } from '@weasel-js/geom/curves';
 import { O as OriginProjection } from './originProjection-gY0jb4Wb.js';
 export { A as AUTO_ORIGIN_PROJECTION, R as RECT_ORIGIN_PROJECTION } from './originProjection-gY0jb4Wb.js';
-export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-CZ1eXbzY.js';
+export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-C25QVb0W.js';
 export { ClipboardFlavors, UseClipboardOpsOptions, UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './clipboard.js';
 import { Vec, SnapCandidate } from '@weasel-js/geom/nd';
 
@@ -135,8 +137,15 @@ declare function viewZoom(view: View): number;
 declare function normalizeView(view: View): View;
 
 /** Options for `useScene` — the layers the scene has, what it starts out
- *  holding, and how its history behaves. */
-interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
+ *  holding, and how its history behaves. A scene whose `TPose` is not a
+ *  {@link RectPose} has no default composition and must name one. */
+type UseSceneOptions<TData, TLayer extends string, TPose = RectPose> = SceneOptions<TData, TLayer, TPose> & NamesComposition<TPose>;
+/** `composition` is required unless `TPose` is a rect the default can fold. */
+type NamesComposition<TPose> = [TPose] extends [RectPose] ? unknown : {
+    composition: PoseComposition<TPose>;
+};
+/** Everything `useScene` takes, with `composition` optional. */
+interface SceneOptions<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`. */
@@ -155,7 +164,12 @@ interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
     /** Per-scene registry for non-serializable function fields (clipFromPose, etc.).
      *  Required only when serializing/deserializing scenes that use function fields. */
     registry?: SceneRegistry<TPose, TData, TLayer>;
-    /** How a child's pose folds into its container's. Default: it does not, and every pose is world. */
+    /** How a child's pose folds into its container's frame. A stored child pose
+     *  is local to the nearest container that defines a frame, and moving a
+     *  container writes one pose. Default `RIGID_POSE_COMPOSITION`, which reads
+     *  `x`, `y`, `width`, `height`, `rotation` and `transform`; a scene of any
+     *  other pose names its own, or `IDENTITY_POSE_COMPOSITION`, under which every
+     *  pose is world and a container never carries its children. */
     composition?: PoseComposition<TPose>;
     /** How laid-out containers are measured. See {@link LayoutFrame}. */
     layoutFrame?: LayoutFrame<TPose>;
@@ -478,6 +492,17 @@ interface CanvasViewCommonProps {
     /** Which of the surface's layers this view paints. Defaults to all of them —
      *  the same content through a second camera. */
     layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];
+    /**
+     * The id of a view whose layers this one paints, read at every paint and
+     * pick: what that view paints, as a `parent` gives a nested view, narrowed by
+     * this view's own `layers`, `layerVisibility` and `layerOrder`. Where that
+     * view owns a selection and this one does not, this view acts on that
+     * selection and draws its chrome. Its rect and camera are not taken; this
+     * view is still measured on its own frame. A loupe aimed over a panel
+     * follows the panel. `null`, or an id no view has, paints what this view
+     * would without it.
+     */
+    follows?: () => string | null;
     /**
      * Show or hide layers in this view only, by id — the map `<Canvas>` takes,
      * applied after `layers` narrows the stack. A scene layer paints as
@@ -1087,6 +1112,12 @@ declare function composeRigidPose<TPose extends RectPose>(parent: TPose, child:
 /** Inverse of `composeRigidPose` — un-turns about the parent's center, then
  *  subtracts the parent's offset. */
 declare function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose;
+/** `scroll` for `composeRectPose`: the frame moved by minus `offset`. */
+declare function scrollRectPose<TPose extends RectPose>(frame: TPose, offset: ScrollOffset): TPose;
+/** `scroll` for `composeRigidPose`: the frame moved by minus `offset` taken
+ *  through its own rotation and `transform`, so content scrolls along the
+ *  container's axes however it is turned. */
+declare function scrollRigidPose<TPose extends RectPose>(frame: TPose, offset: ScrollOffset): TPose;
 /** Translation-only composition over `RectPose`. What a scene wants when a
  *  container groups its children but never turns them. */
 declare const RECT_POSE_COMPOSITION: PoseComposition<RectPose>;
@@ -1103,6 +1134,22 @@ declare const RIGID_POSE_COMPOSITION: PoseComposition<RectPose>;
  */
 declare function worldPoseLookup<TPose>(adapter: PoseAdapter<TPose>, compose: (parent: TPose, child: TPose) => TPose): (id: string) => TPose | null;
 
+/**
+ * World reads and local writes, paired, for the default actions.
+ *
+ * A container's pose defines a frame, so a node's stored pose is expressed in
+ * its parent's. The geometry an action reasons about is world; every pose it
+ * writes back through `setPose` or a pose op is local. An action that reads
+ * world and writes world looks right for one gesture and drifts on the next,
+ * because the stored pose is then read in the parent's frame again.
+ *
+ * Under `IDENTITY_POSE_COMPOSITION` local and world are the same value.
+ *
+ * A scene-backed frame reads world as the view shows it, a scrolled
+ * container's content moved by its offset, and writes back through the same
+ * fold, so a pose an action stores is the content position.
+ */
+
 /** The two directions an action needs, over one composition strategy. */
 interface PoseFrame<TPose> {
     /** The strategy in force. `closure` says what it can express exactly. */
@@ -1111,8 +1158,11 @@ interface PoseFrame<TPose> {
     world(id: NodeId): TPose;
     /** The node whose frame `id` is stored in, or `null` for the root frame. */
     frame(id: NodeId): NodeId | null;
-    /** World pose of the frame `id` is stored in, or `null` for the root frame. */
+    /** World pose of the frame `id` is stored in, or `null` for the root frame:
+     *  the container's `childFrame`, scrolled where the view scrolls it. */
     parentWorld(id: NodeId): TPose | null;
+    /** The frame `id` gives its children when its own pose folds to `world`. */
+    childFrame(id: NodeId, world: TPose): TPose;
     /** `worldPose` expressed in `id`'s own parent frame — what `setPose` stores. */
     local(id: NodeId, worldPose: TPose): TPose;
     /** `worldPose` expressed under `parentId`'s frame. For a node about to be
@@ -1120,8 +1170,12 @@ interface PoseFrame<TPose> {
     localUnder(parentId: NodeId | null, worldPose: TPose): TPose;
 }
 /** The `poseFrame` a scene-backed action works in, over the scene's own
- *  composition. Under IDENTITY every method is a no-op. */
+ *  composition, read and written through the view's scrolled frames. */
 declare function scenePoseFrame(scene: Scene<unknown, string, unknown>): PoseFrame<unknown>;
+/** Each node's box frame in world, `boxFrameOf` its world pose: where a
+ *  container's children are laid out, and its own grid runs. `null` for a
+ *  node missing from `scene` or whose pose is not a box. */
+declare function sceneBoxFrames(scene: Scene<unknown, string, unknown>): (id: string) => Affine | null;
 
 /**
  * The kit version a build was compiled from, so an app can report what it is
@@ -2011,6 +2065,9 @@ declare function interpolateView(from: View, to: View): (t: number) => View;
 interface AimSource {
     aim(): ViewAim | null;
     setAim?(aim: ViewAim): void;
+    /** Tells a marker drawing this aim that it changed, so the marker repaints. Without it the marker
+     *  repaints only when something else asks for a redraw. Returns an unsubscribe. */
+    subscribe?(listener: () => void): () => void;
 }
 /** How a marker's outline is stroked, in screen px. */
 interface ViewMarkerStyle {
@@ -2029,8 +2086,8 @@ interface ViewMarkerProps {
     /** Screen px. Default: stroke `#ffffff`, width 1, dash [2, 3]. */
     style?: ViewMarkerStyle;
     /** Default true: dragging the marker edits the source's aim. A source with no writer is never interactive.
-     *  A marker grabs its whole interior plus {@link VIEW_MARKER_HIT_SLOP_PX}, so one covering much of its
-     *  frame takes every press there; `false` opts out. */
+     *  A marker grabs its interior plus {@link VIEW_MARKER_HIT_SLOP_PX} while it covers at most three quarters
+     *  of its frame, and past that only a band that wide either side of its rim, so the frame keeps its presses. */
     interactive?: boolean;
 }
 /** The marker style a {@link ViewMarkerProps.style} fills in from: the minimap indicator's. */
@@ -2056,7 +2113,8 @@ declare const VIEW_MARKER_HIT_SLOP_PX = 4;
 /**
  * The grab for a press at frame px `at` in `space`, the marker's target, or
  * `null` when the marker is not interactive, its source has no writer or no
- * aim, or `at` is not on its outline or within {@link VIEW_MARKER_HIT_SLOP_PX} of it. A surface with views
+ * aim, or `at` is not on its outline or within {@link VIEW_MARKER_HIT_SLOP_PX} of it — of its rim alone, for a
+ * marker covering most of its frame (see {@link ViewMarkerProps.interactive}). A surface with views
  * calls this itself; a canvas with none, such as a detached minimap, calls it to route a press to its marker.
  */
 declare function grabViewMarker(props: ViewMarkerProps, host: ViewMarkerHost, space: AimSpace, at: {
@@ -2207,8 +2265,8 @@ declare const VIEW_MARKER_DRAG = "view.marker.drag";
 declare function viewMarkerDragAction(): Action;
 /**
  * The always-on entry (id `'view-marker'`) that binds a drag on any marker to {@link VIEW_MARKER_DRAG}.
- * A `<SceneCanvas>` installs it unless `actions={null}` or a `tools` takeover leaves it out; to turn marker
- * dragging back on there, pass it in `ambient`, or in the takeover's own `useTools` ambient list.
+ * A `<SceneCanvas>` installs it, beside a `tools` takeover too, unless `actions={null}` leaves it out; to turn
+ * marker dragging back on there, pass it in `ambient`.
  */
 declare function createViewMarkerContribution(): SurfaceContribution;
 
@@ -2943,7 +3001,7 @@ declare function DepRegistryProviderIfRoot({ children }: {
  * only `menuHost`, `view` and `worldToClient` on a surface without a scene; `selection`, `scene`,
  * `hitAt` and `kindOfNode` refine the hit and the keyboard anchor where they are supplied.
  */
-declare function openContextMenu(deps: ActionDeps, params?: Record<string, unknown>, anchorOf?: (deps: ActionDeps) => Point$3 | null): boolean;
+declare function openContextMenu(deps: ActionDeps, params?: Record<string, unknown>, anchorOf?: (deps: ActionDeps) => Point | null): boolean;
 /**
  * Opens the context menu: for the pointer on a right-click or an unclaimed
  * long-press, selecting the shape under it first; for the keyboard on
@@ -3081,8 +3139,9 @@ interface UseAlignOptions<TPose> {
     geometry?: PoseDescriptor<TPose>;
     /** Label passed to applyOps. Default 'Align'. */
     label?: string;
-    /** How local poses fold up to world. Default IDENTITY, where the two are
-     *  the same value and the alignment runs entirely in stored coordinates. */
+    /** How local poses fold up to world. Default IDENTITY, which takes every
+     *  pose the adapter answers as world; over a scene's adapter, pass
+     *  `scene.composition`. */
     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.
@@ -3137,8 +3196,9 @@ interface UseDistributeOptions<TPose> {
     defaultMode?: DistributeMode;
     /** Label passed to applyOps. Default 'Distribute'. */
     label?: string;
-    /** How local poses fold up to world. Default IDENTITY, where the two are
-     *  the same value and the spread runs entirely in stored coordinates. */
+    /** How local poses fold up to world. Default IDENTITY, which takes every
+     *  pose the adapter answers as world; over a scene's adapter, pass
+     *  `scene.composition`. */
     composition?: PoseComposition<TPose>;
 }
 /** Return shape of `useDistribute`. */
@@ -3196,8 +3256,7 @@ interface SetAnchorFieldParams {
 /** A point a spatial reference of `'pointer'` resolves to in place of the
  *  pointer dep, when the invocation has one of its own. */
 type AtPoint = {
-    worldX: number;
-    worldY: number;
+    world: WorldPoint;
 };
 type AlignParams = AtPoint & {
     to: AlignReference;
@@ -3505,8 +3564,8 @@ declare const editingLayer: EditedLayerOf;
  *  names. An action in a scene with no `parallax` layer, or invoked with no
  *  scene or view to read a plane from, runs exactly as it would unwrapped.
  *
- *  An immediate action's world point is `params.worldX` / `params.worldY`,
- *  the dispatcher's convention for a click; it is carried when present. */
+ *  An immediate action's points are its params' `world` and `press`; each
+ *  is carried when present. */
 declare function inPlane<A extends Action>(action: A, layerOf: EditedLayerOf): A;
 
 /** Binding params `viewport.dragPan` understands, read at `start`. A bare
@@ -3598,6 +3657,51 @@ declare function makeViewportWheelPanAction(opts?: WheelPanOptions): Action & {
     requires: string[];
 };
 
+/**
+ * Wheel scrolling of a layout container whose content runs past its bounds,
+ * such as `tileGrid({ overflow: 'scroll' })`. The strategy's `contentExtent`
+ * says how far; the offset goes to `scene.scroll`, which moves what the view
+ * shows and leaves the document where it is.
+ */
+
+type AnyScene$2 = Scene<unknown, string, unknown>;
+/** How far a container's content can scroll on each axis, in its own units:
+ *  `[min, max]`, zero included, so an unscrolled container is in range. */
+interface ScrollRange {
+    x: readonly [number, number];
+    y: readonly [number, number];
+}
+/**
+ * How far `id`'s content can scroll: the span its layout's `contentExtent`
+ * reaches past its bounds, read through the document fold the layout pass
+ * arranges it in. Measured in the container's own frame, the axes a scroll
+ * offset runs along, so a turned container scrolls by its own length rather
+ * than its box's. `null` for a node whose layout reports no extent, one whose
+ * pose is not a frame, and under a composition that cannot scroll.
+ */
+declare function scrollRange(scene: AnyScene$2, id: NodeId, descriptor: PoseDescriptor<unknown>): ScrollRange | null;
+interface Scrollable {
+    id: NodeId;
+    range: ScrollRange;
+}
+/** The innermost shown container under the world point `at` whose content
+ *  can scroll, with its range. */
+declare function scrollableAt(scene: AnyScene$2, at: {
+    x: number;
+    y: number;
+}, descriptor: PoseDescriptor<unknown>): Scrollable | null;
+/**
+ * Wheel over a container whose content runs past its bounds scrolls that
+ * content along the container's own axes, clamped to the strategy's
+ * `contentExtent`; Shift+wheel scrolls it across. A container already at the
+ * end of its range in the wheel's direction hands the wheel to the scrollable
+ * container holding it, and past the outermost one the action passes, so the
+ * wheel pans the viewport. Anywhere else it declines.
+ */
+declare const containerScrollAction: Action & {
+    requires: string[];
+};
+
 /**
  * `editAnchorsAction` — ongoing Action descriptor for editing polygon anchors.
  *
@@ -4065,15 +4169,15 @@ declare function useKeybindings(tools: ToolsApi, options?: UseKeybindingsOptions
 /** Options for `useSelectTool`: how a point resolves to nodes, how a click
  *  chooses among them, and the appearance of the marquee. */
 interface UseSelectToolOptions<TPose> {
-    /** Return ids of all objects whose painted body covers (worldX, worldY).
+    /** Return ids of all objects whose painted body covers `world`.
      *  Order doesn't matter — the tool collapses parent/child overlap via
      *  `pickTopMostHit`. When omitted, defaults to an AABB-vs-point walk of
      *  the adapter's tree using the pose descriptor. Override for tighter
      *  shapes (path / polygon hit-tests). */
-    pickEvery?: (worldX: number, worldY: number) => string[];
+    pickEvery?: (world: WorldPoint) => string[];
     /** Optional alt-aware selection-update hit returning the single id the
      *  click should act on. */
-    pickBest?: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
+    pickBest?: (world: WorldPoint, alt: boolean, selection: readonly string[]) => string | null;
     /** How to read poses for the default `pickEvery`. Default
      *  `AUTO_POSE_DESCRIPTOR`. */
     poseDescriptor?: PoseDescriptor<TPose>;
@@ -4243,6 +4347,43 @@ declare const onEmptyCanvas: _weasel_js_gestures.TargetPredicate & {
  *  tool adds this to its ambient list. */
 declare function areaSelectContribution(): Contribution;
 
+/** The reads `pressTarget` makes: the tree, and each node's kind. */
+interface PressTargetTree {
+    getParent(id: string): string | null;
+    getNode(id: string): unknown;
+}
+
+type Box = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** What `group.enter` reads: the node under a point and the tree above it. */
+interface EnterGroupOptions {
+    /** The node under the point, before any group above it is considered. */
+    pickHit: (world: WorldPoint) => string | null;
+    tree: PressTargetTree;
+}
+/** What `group.leave` reads: where a group's box is. */
+interface LeaveGroupOptions {
+    boxOf: (id: string) => Box | null;
+}
+
+/** Id of the entry {@link createGroupEntryContribution} builds. */
+declare const GROUP_ENTRY_ID = "group.entry";
+/**
+ * `group.enter` and `group.leave`, bound under any tool that leaves the gesture unclaimed. A
+ * double-click on a body enters the group a press there would select, and declines where that is
+ * no group, so text and path editing keep their double-click. Escape leaves one level, carrying
+ * the phase `escape` does and declining with nothing entered, which leaves Escape to `escape`.
+ * Leaving on a press is the select tool's ({@link GROUP_LEAVE_PRESS_BINDING}): under a drawing
+ * tool a press outside the group draws into it.
+ */
+declare function createGroupEntryContribution(opts: EnterGroupOptions & LeaveGroupOptions): Contribution;
+/** {@link createGroupEntryContribution} for the life of a canvas, reading its pickers live. */
+declare function useGroupEntryContribution(opts: EnterGroupOptions & LeaveGroupOptions): Contribution;
+
 /** What `pickTopMostHit` ranks a hit list by: the tree, and a z signal where
  *  the adapter has one. */
 interface PickTopMostHitAdapter {
@@ -4687,10 +4828,7 @@ interface UseEyedropperToolOptions {
 declare function useEyedropperTool(opts: UseEyedropperToolOptions): Tool;
 
 /** An endpoint of a line, in world coordinates. */
-interface LinePoint {
-    x: number;
-    y: number;
-}
+type LinePoint = WorldPoint;
 /**
  * Drag-to-draw line tool. The `drag` binding routes to `insertAction`, which
  * commits through the `insert` dep with `{ kind: 'line', a, b }` endpoints
@@ -4733,10 +4871,7 @@ interface UseLassoToolOptions extends UseLassoSelectOptions {
 declare function useLassoTool(options?: UseLassoToolOptions): Tool;
 
 /** A point in world coordinates. */
-interface PolygonPoint {
-    x: number;
-    y: number;
-}
+type PolygonPoint = WorldPoint;
 /** Options for `usePolygonTool`. */
 interface UsePolygonToolOptions extends InsertToolOptions {
     label?: string;
@@ -4763,10 +4898,7 @@ declare function usePolygonTool<TNode extends {
 }>(options?: UsePolygonToolOptions): Tool;
 
 /** A point in world coordinates. */
-interface StarPoint {
-    x: number;
-    y: number;
-}
+type StarPoint = WorldPoint;
 /** Options for `useStarTool`. */
 interface UseStarToolOptions extends InsertToolOptions {
     label?: string;
@@ -4853,10 +4985,7 @@ interface SliceScratch {
 declare function useSliceTool(options?: UseSliceToolOptions): Tool;
 
 /** A world-space point. */
-interface MeasurePoint {
-    x: number;
-    y: number;
-}
+type MeasurePoint = Point;
 /**
  * The offset from `start` to `end`, in world units. `dx` and `dy` are on the
  * world's own axes, where y grows downward; `angle` reads like a protractor
@@ -4930,10 +5059,10 @@ declare function createMeasurements(options: {
     layer: string;
 }): Measurements;
 /** The measurement nodes on `ms.layer`, oldest first. */
-declare function measureIds(scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes'>, ms: Pick<Measurements, 'layer'>): NodeId[];
+declare function measureIds(scene: Pick<Scene<unknown, string, unknown>, 'nodesOnLayer'>, ms: Pick<Measurements, 'layer'>): NodeId[];
 /** The measurement commands act on: the picked one while it is still in the
  *  scene, else the newest. */
-declare function currentMeasureId(scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes' | 'get'>, ms: Pick<Measurements, 'layer' | 'picked'>): NodeId | null;
+declare function currentMeasureId(scene: Pick<Scene<unknown, string, unknown>, 'nodesOnLayer' | 'get'>, ms: Pick<Measurements, 'layer' | 'picked'>): NodeId | null;
 
 /** Options for `useMeasureTool`. */
 interface UseMeasureToolOptions {
@@ -5032,790 +5161,970 @@ type ChromeId = 'selection.outline' | 'selection.resize-handles' | 'selection.ro
 type VisibilityRules = Partial<Record<ChromeId, Condition | Rule>>;
 
 /**
- * Promote a Rule tree to a fluent Condition.
- *
- * **Chain semantics: strict left-to-right.** No boolean precedence.
- * `focused.or(hovering).and(selectionIs(1))` evaluates
- * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use
- * the top-level `or` / `and` / `not` helpers or name intermediates.
- *
- * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
- * produces `{ all: [a, b, c] }`.
+ * The selection overlay's resize handles: their style, where the kit puts
+ * them, and the commands that paint them.
  */
-declare function cond(rule: Rule): Condition;
-/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
-declare function when(fn: (ctx: RuleCtx) => boolean): Condition;
-/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
- *  semantics ambiguous. */
-declare function and(...cs: (Condition | Rule)[]): Condition;
-/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
- *  `.and` to make grouping explicit. */
-declare function or(...cs: (Condition | Rule)[]): Condition;
-/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
- *  instead; this is for the lead-with-negation case. */
-declare function not(c: Condition | Rule): Condition;
-/** Always true. The fallback for any chrome id without a registered rule. */
-declare const always: Condition;
-/** Always false. Useful for "turn this chrome off entirely":
- *  `chromeVisibility={{ 'snap.guides': never }}`. */
-declare const never: Condition;
-/** Canvas surface currently focused. */
-declare const focused: Condition;
-/** Any action currently in flight (read: user is gesturing). */
-declare const gesturing: Condition;
-/** A path is currently in anchor-edit mode. */
-declare const editingAnchors: Condition;
-/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
-declare const actionIs: (kind: string) => Condition;
-/** Nothing selected. */
-declare const selectionEmpty: Condition;
-/** Exactly `n` items selected. */
-declare const selectionIs: (n: number) => Condition;
-/** At least `n` items selected. `selectionAtLeast(1)` is the common
- *  "something is selected" check. */
-declare const selectionAtLeast: (n: number) => Condition;
-/** Multi-mode handle behavior active (single shared union-bounds
- *  handle vs per-item handles). */
-declare const multiActive: Condition;
-/** Pointer is hovering some node. */
-declare const hovering: Condition;
-/** Pointer is hovering a node that is currently selected. */
-declare const hoveringSelected: Condition;
-/** Named modifier key currently held. */
-declare const modifierHeld: (m: keyof ModifierState) => Condition;
-/** View scale (uniform or geometric mean for non-uniform) is at least
- *  `z`. Useful for "hide hairline chrome at low zoom" rules. */
-declare const zoomAtLeast: (z: number) => Condition;
-/** Active mode equals `m`. */
-declare const modeIs: (m: string) => Condition;
-/** Active mode is one of `modes`. */
-declare const modeIn: (modes: readonly string[]) => Condition;
-/** Active mode is NOT `m`. */
-declare const modeNot: (m: string) => Condition;
-/** Active mode's `allows` includes capability `cap`. */
-declare const capabilityIs: (cap: string) => Condition;
-/** Active mode's `allows` includes ANY of `caps` (OR). */
-declare const capabilityIn: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` includes ALL of `caps` (AND). */
-declare const capabilityAll: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` does NOT include capability `cap`. */
-declare const capabilityNot: (cap: string) => Condition;
-/** Primary pointer is imprecise (touch, most styluses). Absent device
- *  profile → false. */
-declare const coarsePointer: Condition;
-/** Primary pointer can hover. Absent device profile → true. */
-declare const canHover: Condition;
+
+/** Handle visuals, as a consumer supplies them. */
+interface SelectionHandleStyle {
+    size?: number;
+    fill?: CommandFill;
+    outline?: CommandStroke;
+}
 
 /**
- * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
- * at resolve time; consumer entries take precedence per id.
- *
- * Gating is written in terms of **capabilities, not mode ids**. A
- * capability rule keeps holding when a new mode is added that permits the
- * same thing; a mode rule has to be found and edited every time.
+ * The pose and box a selection's chrome is drawn around: precedence between
+ * the in-flight overlays and the stored pose, a container's union over its
+ * leaves, and the drawn box a scene supplies.
  */
-declare const defaultVisibilityRules: VisibilityRules;
 
+/** Options for `composeSelectionPose`. */
+interface ComposeSelectionPoseOpts<TPose> {
+    /** Move overlay; when present its `poses` map wins over everything else. */
+    moveOverlay?: {
+        poses: Map<string, TPose>;
+    } | null;
+    /**
+     * Resize overlay; consulted only when move overlay does not own the id.
+     * For container resize, `leafPoses` (when present) maps each leaf id under
+     * the container to its overlay pose. If absent the container falls back to
+     * stored leaf poses.
+     */
+    resizeOverlay?: {
+        id: string;
+        currentPose: TPose;
+        leafPoses?: Map<string, TPose>;
+    } | null;
+    /** Fallback pose lookup (typically the stored/committed pose). */
+    getStoredPose: (id: string) => TPose;
+    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
+    /** Walk a container's direct children (e.g. `scene.childrenOf`). With
+     *  `isContainer`, a selected container resolves to the union AABB of its
+     *  transitive leaf poses instead of its own stored pose. */
+    getChildren?: (id: string) => readonly string[];
+    /** True when `id` is a structural container. */
+    isContainer?: (id: string) => boolean;
+    /** The nodes behind the ids. With it, a container's union takes each leaf
+     *  as drawn, stroke included (`drawnBoundsOf`); without, its pose box. */
+    scene?: DrawnBoundsScene;
+    /** View scale a screen-pixel stroke is resolved at. Default 1. */
+    viewScale?: () => number | Scale2;
+}
 /**
- * Build the per-frame visibility check: consumer rules merged on top of
- * the kit defaults, evaluated against `ctx`.
- *
- * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
- * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
- * opted into modality behaves exactly like one sitting in normal mode.
+ * Build a pose resolver for a selection. Precedence per id:
+ * move overlay > resize overlay > stored. When `getChildren`/`isContainer`
+ * are supplied and the id resolves to a container, the resolver returns the
+ * union AABB of all transitive leaf poses (each leaf still subject to the
+ * precedence rules). Containers with no leaves resolve to `null`.
  */
-declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
+declare function composeSelectionPose<TPose>(opts: ComposeSelectionPoseOpts<TPose>): (id: string) => TPose | null;
 
 /**
- * Pure assembler for {@link ChromeCtx}. Sources are passed as plain values
- * rather than the live objects they come from, which keeps `chrome-caps`
- * from depending on React or the dispatcher's concrete type.
+ * Selection overlay primitives — render layers for drawing selection
+ * outlines and resize handles.
+ *
+ * **Pose shape:** TPose is generic; callers pass `poseDescriptor` for poses
+ * `AUTO_POSE_DESCRIPTOR` can't read. Container ids reduce via `unionAABB`
+ * over the projected AABBs.
  */
 
-/** The pieces of live canvas state a `ChromeCtx` is assembled from. */
-interface BuildChromeCtxArgs {
-    focused: boolean;
-    selection: readonly NodeId[];
-    multiActive: boolean;
-    modifiers: ModifierState;
-    action: {
-        kind: string | null;
-        id: string | null;
-    };
-    hover: NodeId | null;
-    view: View;
-}
-/** Gather the current canvas state into the context that chrome-visibility
- *  rules are evaluated against. Rebuilt per frame. */
-declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
-
-/** Last-hovered NodeId for chrome-caps rules. */
-
-/** Options for `useHoverTracking`. */
-interface UseHoverTrackingArgs {
-    /** Topmost id under a client point, or null. */
-    nodeAtClientPoint: (clientX: number, clientY: number) => {
-        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 {
-    /** The node the pointer is over, or null. */
-    getHover: () => NodeId | null;
-    /** Hand it the element to track, or null to stop: a callback ref, so an
-     *  element that mounts after the hook is tracked from the moment it arrives. */
-    canvasRef: (element: HTMLElement | null) => void;
+/** Options every selection layer shares. `getSelection` and `getPose` are
+ *  declared on {@link SelectionOverlayLayerOpts}, which makes both optional —
+ *  omitted, they come off the draw envelope. */
+interface SelectionLayerCommon<TPose> {
+    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<TPose>;
+    /** Walk a container's direct children (e.g. `scene.childrenOf`). When
+     *  supplied with `isContainer`, any id that resolves to a container is
+     *  rendered using the union bounds of all its transitive leaves. */
+    getChildren?: (id: string) => readonly string[];
+    /** True when `id` is a structural container. */
+    isContainer?: (id: string) => boolean;
+    /** The nodes behind the ids `getPose` answers for. With it, a stroked
+     *  node's chrome sits on its stroke (`drawnBoundsOf`); without, on its
+     *  pose box. Ignored when bounds come off the draw envelope. */
+    scene?: DrawnBoundsScene;
 }
-/** Track which node the pointer is over. Returns a getter rather than state,
- *  so a pointer move does not re-render the component. Cleared on
- *  `pointerleave`. */
-declare function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking;
-
-/** `<SceneCanvas geometry>`: hit-test and bounds overrides, consumed by the
- *  internal select tool. Ignored if the consumer passes their own `tools`. */
-interface SceneCanvasGeometry {
-    /** Hit-test override. Return the topmost id, the full back-to-front hit
-     *  stack (`string[]`), or `null` for empty space. The stack form lets a
-     *  consumer with domain overlap ordering (e.g. children over their
-     *  container) feed the kit's `pickTopMostHit` the true order instead of
-     *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */
-    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;
-    boundsOf?: (id: string) => FramedBox | null;
-    /**
-     * What "the pointer is on this node" means for the default body-pick.
-     *
-     * - `'pose'` — the node's pose rect, rotation honored.
-     * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter
-     *   actually lays down: its silhouette filled or not per the painter's `ink`, plus
-     *   its outline widened by the stroke half-width and `pickTolerancePx`.
-     *
-     * Painters with no silhouette keep the pose-rect answer either way. Ignored when
-     * `pickEvery` is supplied: that override owns the test.
-     */
-    picking?: 'pose' | 'shape';
+/** Options for `createSelectionOutlineLayer`. The overlay layer's options
+ *  minus the handle visuals — the two run the same body. */
+type SelectionOutlineLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'handles' | 'handlesOf' | 'resizeHandles' | 'rotationHandle'>;
+/** Options for `createSelectionHandlesLayer`. The overlay layer's options
+ *  minus the outline stroke — the two run the same body. */
+type SelectionHandlesLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'outline'>;
+/** Options for `createSelectionOverlayLayer`. */
+interface SelectionOverlayLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
     /**
-     * Grab slop around a shape's outline, in **screen** pixels, so the target keeps
-     * its apparent size at any zoom. Default 4. It widens the outline test under
-     * `picking: 'shape'` and grows the pose-rect pre-filter so those outline hits
-     * survive it. Set `0` for exact geometry.
+     * Which ids to draw chrome for. Omit to take them from the `ChromeState` on
+     * the draw envelope, which is what makes one canvas's several views each
+     * outline their own selection — the layer is shared, the envelope is not.
      */
-    pickTolerancePx?: number;
+    getSelection?: () => readonly NodeId[];
     /**
-     * Whether a shape's box includes its stroke as drawn — align, joins, and
-     * markers counted — or is the pose's geometry alone. Default `true`. The
-     * selection outline and handles sit on it, resize keeps the stroke's
-     * outer edge under the pointer without scaling the stroke, and rotate,
-     * flip, align, and distribute measure it. Stored geometry is unaffected.
+     * Resolve an id to the pose to draw chrome around. Return null to skip an
+     * id. Omit to take bounds from the same envelope `getSelection` omitted
+     * takes ids from.
+     *
+     * Takes `string` rather than `NodeId` because the container-aware resolver
+     * walks expanded leaf ids via `getChildren`, which is generic over strings.
      */
-    boundsIncludeStroke?: boolean;
+    getPose?: (id: string) => TPose | null;
+    outline?: CommandStroke & {
+        pad?: number;
+    };
+    /** Pass `false` to render outlines only. */
+    handles?: SelectionHandleStyle | false;
+    /** Where to paint handles, in the bounds' own frame. Replaces the kit's
+     *  layout, `resizeHandles` included. */
+    handlesOf?: (bounds: FramedBox) => {
+        x: number;
+        y: number;
+    }[];
+    /** The layout the resize affordance hits by: its `hitRadiusPx`, never
+     *  `handles.size`, decides which edge handles are painted. Default: edges on,
+     *  at the kit's default hit radius. */
+    resizeHandles?: Partial<ResizeHandleLayout>;
+    /** Draw a rotate badge above the selection's top edge. `true` places it at
+     *  the default offset; `distance` sets the offset in screen pixels. Off by
+     *  default. */
+    rotationHandle?: boolean | {
+        distance?: number;
+    };
+    /** Optional separate id list for the per-item outline pass, for a
+     *  multi-selection whose handle pass works against a synthetic union id
+     *  (e.g. `MULTI_RESIZE_TARGET_ID`) while each real member is outlined.
+     *  When omitted, the outline pass uses the handle pass's ids. */
+    getOutlineIds?: () => readonly NodeId[];
+    /** Optional set of ids to suppress entirely — both outline and handles
+     *  are skipped. */
+    getSuppressedIds?: () => ReadonlySet<string>;
 }
+/**
+ * `RenderLayer` that draws selection outlines only. Stack alongside
+ * `createSelectionHandlesLayer` (or use `createSelectionOverlayLayer`, which
+ * runs both passes in one layer) when both are wanted.
+ */
+declare function createSelectionOutlineLayer<TPose>(opts: SelectionOutlineLayerOpts<TPose>): RenderLayer<unknown>;
+/**
+ * `RenderLayer` that draws selection handles only. Stack on top of
+ * `createSelectionOutlineLayer` (handles render on top of the outline).
+ */
+declare function createSelectionHandlesLayer<TPose>(opts: SelectionHandlesLayerOpts<TPose>): RenderLayer<unknown>;
+/**
+ * Draws outlines then handles in a single layer. Exactly equivalent to
+ * stacking `createSelectionOutlineLayer` and `createSelectionHandlesLayer` —
+ * all three run the same body. Pass `handles: false` to render outlines only.
+ */
+declare function createSelectionOverlayLayer<TPose>(opts: SelectionOverlayLayerOpts<TPose>): RenderLayer<unknown>;
 
-/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields
- *  modality dispatch needs; extends as the kit's `Hit` type evolves. */
-interface SceneCanvasHit {
-    id: string;
-    kind: string;
-}
-/** `<SceneCanvas>`'s props for what the pointer can reach and what a click names. */
-interface SceneCanvasPointerProps {
-    /**
-     * Per-id pointer-interactivity predicate: an id it returns `false` for is excluded from
-     * hit-test results. Typical use: suppressing pointer events for dimmed nodes.
-     */
-    isPointerInteractive?: (id: string) => boolean;
-    /**
-     * The entered group: the group a press resolves inside of, and which a double-click drills down
-     * from. Nodes outside it take no hits. Pass one from `useEnteredGroup(scene)` to read or drive it
-     * from outside the canvas, as `selection` is passed; without it the canvas keeps its own.
-     */
-    enteredGroup?: EnteredGroupApi;
-    /**
-     * Called when the user double-clicks the canvas, with the hit node (id + kind) at that
-     * position, or `null` on empty canvas. A notification, not a binding: it fires whatever the
-     * double-click does. Entering a mode on the node belongs to `modeTriggers` instead.
-     */
-    onDoubleClick?: (hit: SceneCanvasHit | null) => void;
-    /** Called on every click — a press and release without a drag — with the
-     *  node under it, or `null` on empty canvas. Fires after the click's own
-     *  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 scene slot: an adapter's tree as render layers, one per scene layer.
+ */
 
-/** The `<SceneCanvas>` props that change the actions and bindings a canvas has. */
-interface SceneCanvasActionProps {
+/** Scene slot config — describes how to draw one object with its effective pose. */
+interface SceneSlotConfig<TNode extends {
+    id: string;
+}, TPose> {
+    /** Paint these, in this order, in place of the adapter's tree: one flat run with no
+     *  scene layers, no container clips, and no pose composition. */
+    objects?: TNode[];
+    /** The pose an object is painted at. Defaults to `adapter.getPose(obj.id)`. `<SceneCanvas>`
+     *  hands it each node as the scene shows it, its `pose` an override's or a derived one,
+     *  and carries an override's `path` into the box it answers; return a pose placed from
+     *  `obj.pose`, or a drag in flight and a rig's motion do not show in this view. */
+    toPose?: (obj: TNode) => TPose;
+    /** Draw a single object as a `DrawCommand` tree. `ctx` carries a derived
+     *  node's path: `<SceneCanvas>` resolves it from the scene, and
+     *  `buildSceneLayer` called without one from its adapter. */
+    drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];
+    /** The path a container derives from its dependencies' poses, for the clip
+     *  it imposes on its subtree — `drawOne`'s `ctx` carries the derived path a
+     *  node *paints*, this one the clip it *imposes*. A scene-aware caller
+     *  supplies it; left out, both are resolved off the adapter. */
+    derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;
+    /** Default ghost alpha for the move-overlay slot. Default 0.85. */
+    ghostAlpha?: number;
+    /** Per-id alpha multiplier. A node's emitted `DrawCommand[]` is wrapped in a
+     *  `{ kind: 'group', alpha }` when the returned value is not 1. */
+    alphaFor?: (id: string) => number;
     /**
-     * Tune actions on this canvas without restating them, keyed by action id:
-     * `params` every invocation starts from, and `bindings` added beside the
-     * action's own. A tuning applies to whichever descriptor holds the id, a
-     * preset's or a tool's. Pass a stable object; a params thunk is read on
-     * every call. See the core README ("Tuning an action").
+     * Post-processor for the scene slot's emitted commands: called with the final
+     * world-space `DrawCommand[]` each time a scene canvas layer draws (after per-node
+     * rotation wrapping and `alphaFor`), once per layer when the slot is split into
+     * `scene:<layerId>` layers. Its return value replaces the array handed to the renderer.
+     *
+     * Commands are world-space — `drawLayers` applies the view transform afterward. Clip
+     * nesting is capped at 7 levels; a wrapping group with `clip` consumes one. The
+     * move-overlay ghost (drag preview) is not post-processed.
      */
-    tune?: ActionTunings;
+    postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];
     /**
-     * Replace or remove bindings by binding id, on actions and contributions
-     * alike: a route string (`'[*:*] keyDown(=) +mod'`), a spec (`key('Mod+=')`),
-     * or `null` to unbind. Pass a stable object.
+     * Skip what cannot reach the view. A node `paintBounds` places outside the
+     * `dims` rectangle under `view` is not painted at all; then, after
+     * `postProcess`, `cullDrawCommands` drops any remaining command that cannot
+     * reach it — see there for what it can and cannot bound. So `postProcess`
+     * sees an empty group where a culled node would have painted.
+     *
+     * Off by default because it makes the layer's world-space output depend on
+     * the view: anything that draws this layer once and shows the result under
+     * another view — a cache keyed without `view`, a consumer re-wrapping the
+     * commands — would show the first view's cull.
      */
-    bindingOverrides?: BindingOverrides;
+    cull?: boolean;
     /**
-     * Replace, add or mute whole action descriptors. Pass `null` to disable
-     * all defaults. To change a built-in's params or add a key, use `tune`.
+     * Where `drawOne`'s output for a node can reach, in the frame it paints in
+     * — before the pose rotation the slot wraps it in. `null` for a node it
+     * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a
+     * node whose box misses the view, so it must enclose everything `drawOne`
+     * paints: a box too small makes a node vanish before it leaves the screen.
+     *
+     * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is
+     * `defaultDrawOne`. Omit it with any other `drawOne` and culling only
+     * trims commands after painting.
      */
-    actions?: ActionsProp;
+    paintBounds?: PaintBoundsFn<TNode, TPose>;
 }
 
 /**
- * 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] }}`.
+ * The draw commands path edit paints for the open path, in screen space: its
+ * outline, then each anchor's handles and marker.
  */
-declare const kitTextHandler: ContentHandlerEntry;
 
-/** Options for {@link openFilePicker}. */
-interface OpenFilePickerOptions {
-    /** `<input accept>` filter, e.g. `'image/*'` or `'.csv,text/csv'`. */
-    accept?: string;
-    /** Allow multi-select. Default false. */
-    multiple?: boolean;
+/** Appearance of the outline and of the anchor and handle markers. */
+interface PathEditingOverlayStyle {
+    anchorSizePx?: number;
+    handleDotRadiusPx?: number;
+    anchorFill?: string;
+    anchorStroke?: string;
+    handleStroke?: string;
+    /** Fill of the control-point circle. Defaults to the handleStroke color
+     *  at 50% alpha. */
+    handleDotFill?: string;
+    /** Fill of a selected anchor square. Defaults to the anchor stroke color. */
+    anchorFillSelected?: string;
+    /** The open path's outline, drawn over its own fill and stroke so the path
+     *  shows however its paint and its markers cover it. */
+    outlineStroke?: string;
+    outlineWidthPx?: number;
+    /** Radius of the dot an unselected anchor shrinks to where anchors sit
+     *  closer together on screen than a marker is wide. */
+    denseDotRadiusPx?: number;
+    /** Stroke of the marquee rubber band. */
+    marqueeStroke?: string;
+    /** Fill of the marquee rubber band. */
+    marqueeFill?: string;
 }
-/**
- * Show the browser's file picker and resolve with what the user chose —
- * empty when they cancel. Must be called from a user gesture (a click
- * handler): browsers block programmatic `input.click()` otherwise. Pairs
- * with `CanvasExtensionApi.ingest`:
- *
- * ```ts
- * const files = await openFilePicker({ accept: 'image/*', multiple: true });
- * canvasRef.current?.ingest(files);
- * ```
- */
-declare function openFilePicker(opts?: OpenFilePickerOptions): Promise<File[]>;
+/** The path-edit overlay's look where a {@link PathEditingOverlayStyle} leaves a field out. */
+declare const DEFAULT_OVERLAY_STYLE: Required<PathEditingOverlayStyle>;
 
 /**
- * Ghosts of removed nodes: what a pose transition shows leaving after the
- * scene has let a node go. A ghost is not a scene node, so picking,
- * selection and history never see it; it lives here until its glide ends.
+ * Screen-space render layer for path-editing chrome — the open path's
+ * outline, anchor markers, tangent lines, and control-point dots for a
+ * polygon path that is the current edit target, under them whatever marks
+ * its path-edit extensions draw. Marker sizes stay constant regardless of zoom.
  */
 
-/** A removed node as its ghost shows it now. */
-interface ShownDeparture<TPose, TNode> {
-    removal: PoseRemoval<TPose, TNode>;
-    pose: TPose;
-    alpha: number;
+/** Options for `createPathEditingOverlayLayer`. Everything is read per frame,
+ *  so the layer follows a changing edit target without being rebuilt. */
+interface CreatePathEditingOverlayLayerOptions {
+    /** Returns the id of the polygon currently in anchor-edit mode, or null
+     *  when no node is being edited. */
+    getEditingId(): string | null;
+    /**
+     * Returns the pose for an id, or null if the node has been deleted.
+     * Non-polygon poses are tolerated (the layer no-ops on them).
+     *
+     * `previews` are the drawing view's in-flight preview surfaces, so an
+     * anchor dragged in one panel does not move in the others. Resolve against
+     * them before falling back to the committed pose.
+     *
+     * `view` is the drawing view's camera. Answer in its world: a node whose
+     * layer is a parallax plane stores its path in the plane's.
+     */
+    getPose(id: string, previews: readonly GesturePreviewSource[], view: View): Path | null;
+    /** The marker of each anchor, by flat index, for a node whose path was
+     *  drawn from a form (`PathRepresentation.anchorMarkers`); null, or an
+     *  anchor with none, draws a square. Resolve against `previews` as
+     *  `getPose` does. */
+    getAnchorMarkers?(id: string, previews: readonly GesturePreviewSource[]): readonly (AnchorMarkerShape | null)[] | null;
+    /** Flat indices of the selected anchors. Selected anchors render
+     *  filled; unselected ones hollow. */
+    getSelectedAnchors?(): ReadonlySet<number>;
+    /** In-flight anchor-marquee rect in world coords, or null. Drawn as a
+     *  rubber band while `marqueeAnchorsAction` is dragging. */
+    getMarquee?(view: View): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** The edited node's committed pose and data, which extensions' marks read. */
+    getNode?(id: string): {
+        pose: unknown;
+        data: unknown;
+        layer?: string;
+    } | null;
+    /** The path-edit extensions whose marks are drawn, in order. */
+    getExtensions?(): readonly PathEditExtension[];
+    /** The selected extension mark, or null. */
+    getSelectedMark?(): PathEditMark | null;
+    /** Optional styling overrides. */
+    style?: PathEditingOverlayStyle;
 }
-/** The ghosts one canvas shows. */
-interface Departures<TPose, TNode> {
-    /** See `removal` off from where it was shown toward `exit` of that pose,
-     *  fading out, through `transition`. Does nothing for a transition with no
-     *  `over`, which cannot carry a node the scene no longer holds. */
-    leave(removal: PoseRemoval<TPose, TNode>, exit: (pose: TPose) => TPose, transition: ReflowTransition<TPose>): void;
-    /** Drop `id`'s ghost — its node is back — and answer where it was shown. */
-    recall(id: string): TPose | undefined;
-    shown(): ShownDeparture<TPose, TNode>[];
-    /** Hear each frame a ghost moves, and each one that comes or goes. */
-    subscribe(listener: () => void): () => void;
-    dispose(): void;
+/** Render layer that draws the outline and the anchors and control handles
+ *  of the path currently being anchor-edited. Draws nothing when no path is
+ *  being edited. */
+declare function createPathEditingOverlayLayer(opts: CreatePathEditingOverlayLayerOptions): RenderLayer<unknown>;
+
+/** Standard slot names — render in this canonical order.
+ *  `cellHighlight` is not an anchor for custom layers: it sits between the
+ *  grid and the scene, so anchor to one of those. */
+/** @internal */
+declare const STANDARD_SLOTS: readonly ["grid", "cellHighlight", "scene", "selectionOverlay"];
+/** Names of the slots `<Canvas>` supports out of the box (excluding the implicit cell-highlight overlay). */
+type StandardSlotName = Exclude<(typeof STANDARD_SLOTS)[number], 'cellHighlight'>;
+/** Custom layer entry — any key not in `STANDARD_SLOTS`. The presence of
+ *  `.layer` discriminates this from a slot config. */
+interface CustomLayerEntry {
+    layer: RenderLayer<unknown>;
+    /** Insert immediately after the named standard slot or another custom-layer key. */
+    after?: StandardSlotName | (string & {});
+    /** Insert immediately before the named standard slot or another custom-layer key. */
+    before?: StandardSlotName | (string & {});
 }
-/** An empty set of ghosts, for `bindPoseTransition` to fill and a layer to
- *  draw; `usePoseTransition` makes one per canvas. */
-declare function createDepartures<TPose, TNode>(): Departures<TPose, TNode>;
+/** Selection-overlay slot config — passed through to `createSelectionOverlayLayer`,
+ *  minus the `getSelection`/`getPose` the canvas wires automatically and the
+ *  `resizeHandles` it takes from the hit-test, so the two cannot disagree. */
+type SelectionOverlaySlotConfig<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'getSelection' | 'getPose' | 'resizeHandles'> & {
+    /** Override the auto-wired pose lookup (overlay-aware → adapter fallback). */
+    poseById?: (id: string) => TPose | null;
+};
+/** Path-edit overlay slot config: how `<SceneCanvas>` draws the chrome of the
+ *  path whose anchors are being edited. */
+interface PathEditingOverlaySlotConfig {
+    /** Anchor and handle marker overrides. */
+    style?: PathEditingOverlayStyle;
+}
+/** Per-slot config union. The key narrows it in practice. */
+type StandardSlotConfig<TNode extends {
+    id: string;
+}, TPose> = SceneSlotConfig<TNode, TPose> | SelectionOverlaySlotConfig<TPose> | PathEditingOverlaySlotConfig;
+/** What may fill one of the canvas's named layer slots: a config the canvas
+ *  builds the layer from, a pre-built layer, or `null` to leave the slot
+ *  empty. */
+type LayerSlotValue<TNode extends {
+    id: string;
+}, TPose> = StandardSlotConfig<TNode, TPose> | CustomLayerEntry | null;
+/** The canvas's render stack, as named slots. The standard slots (grid,
+ *  scene, selection overlay, cell highlight) fix where a layer sits in the
+ *  stack; scene and selection overlay can be configured, and every one can be
+ *  given a layer of your own or switched off. Further keys add custom layers.
+ *  `TSceneSlot` is what the scene slot accepts: `<SceneCanvas>` takes a
+ *  partial config and fills the rest from its defaults. */
+type LayersMap<TNode extends {
+    id: string;
+}, TPose, TSceneSlot = SceneSlotConfig<TNode, TPose>> = {
+    /** Grid slot, beneath the scene. Takes a pre-built layer (`{ layer }`) —
+     *  e.g. `createGridLayer` from `@weasel-js/guides` — or `null`. */
+    grid?: CustomLayerEntry | null;
+    /** Scene slot: the config `<SceneCanvas>` builds its layers from, a
+     *  pre-built layer that paints the scene in their place, or `null`. A
+     *  pre-built layer gets no ghost of a node in flight, which needs `drawOne`. */
+    scene?: TSceneSlot | CustomLayerEntry | null;
+    /** Selection-overlay slot: the config `<SceneCanvas>` builds the layer
+     *  from, a pre-built layer that paints in its place, or `null` for no
+     *  selection chrome. */
+    selectionOverlay?: SelectionOverlaySlotConfig<TPose> | CustomLayerEntry | null;
+    /** Cell-highlight overlay slot, drawn immediately after the grid. Takes a
+     *  pre-built layer (`{ layer }`) — e.g. `createCellHighlightLayer` from
+     *  `@weasel-js/guides` — or `null`. */
+    cellHighlight?: CustomLayerEntry | null;
+    /** `<SceneCanvas>`'s anchor-editing overlay, above the selection overlay:
+     *  the config it builds the layer from, a pre-built layer, or `null`. */
+    pathEditingOverlay?: PathEditingOverlaySlotConfig | CustomLayerEntry | null;
+} & {
+    [customKey: string]: LayerSlotValue<TNode, TPose> | TSceneSlot | undefined;
+};
+/** The scene slot once built: its canvas layers, bottom first. Each `key` is
+ *  an anchor a custom layer can name (`scene`, or `scene:<layerId>`). */
+interface SceneSlotLayers {
+    layers: ReadonlyArray<{
+        key: string;
+        layer: RenderLayer<unknown>;
+    }>;
+}
+/** What `<Canvas>` composes: a {@link LayersMap} with every slot already a
+ *  layer. `<SceneCanvas>` builds one from its `layers` prop. */
+type CanvasLayers = {
+    grid?: CustomLayerEntry | null;
+    cellHighlight?: CustomLayerEntry | null;
+    scene?: SceneSlotLayers | null;
+    selectionOverlay?: CustomLayerEntry | null;
+} & {
+    [customKey: string]: CustomLayerEntry | SceneSlotLayers | null | undefined;
+};
 
 /**
- * Which pose writes a canvas glides, and through what: `<SceneCanvas
- * poseTransition>`. The transition is the kind `reflowTransition` takes, and
- * one object can serve both.
+ * Promote a Rule tree to a fluent Condition.
+ *
+ * **Chain semantics: strict left-to-right.** No boolean precedence.
+ * `focused.or(hovering).and(selectionIs(1))` evaluates
+ * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use
+ * the top-level `or` / `and` / `not` helpers or name intermediates.
+ *
+ * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
+ * produces `{ all: [a, b, c] }`.
  */
-interface PoseTransitionSeat<TPose> {
-    /** Shows each glide through a pose override; writes nothing. */
-    transition: ReflowTransition<TPose>;
-    /** Whether `write` glides. Default {@link glidesByDefault}. */
-    glides?: (write: PoseWrite<TPose>) => boolean;
-    /** Where a node the scene adds is first shown, given the pose it was added
-     *  at. Absent, an added node appears in place. */
-    enter?: (pose: TPose) => TPose;
-    /** Where a node the scene removes is seen off to, given the pose it was
-     *  shown at: a ghost of it glides there fading out, drawn but never picked,
-     *  selected or recorded. Absent, a removed node vanishes. Needs a
-     *  transition from `useAnimatedReflow` or `createReflowTransition`. */
-    exit?: (pose: TPose) => TPose;
-    /** Whether a removal is seen off through `exit`. Default: every one but
-     *  an untracked removal. */
-    exits?: (removal: PoseRemoval<TPose>) => boolean;
-}
+declare function cond(rule: Rule): Condition;
+/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
+declare function when(fn: (ctx: RuleCtx) => boolean): Condition;
+/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
+ *  semantics ambiguous. */
+declare function and(...cs: (Condition | Rule)[]): Condition;
+/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
+ *  `.and` to make grouping explicit. */
+declare function or(...cs: (Condition | Rule)[]): Condition;
+/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
+ *  instead; this is for the lead-with-negation case. */
+declare function not(c: Condition | Rule): Condition;
+/** Always true. The fallback for any chrome id without a registered rule. */
+declare const always: Condition;
+/** Always false. Useful for "turn this chrome off entirely":
+ *  `chromeVisibility={{ 'snap.guides': never }}`. */
+declare const never: Condition;
+/** Canvas surface currently focused. */
+declare const focused: Condition;
+/** Any action currently in flight (read: user is gesturing). */
+declare const gesturing: Condition;
+/** A path is currently in anchor-edit mode. */
+declare const editingAnchors: Condition;
+/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
+declare const actionIs: (kind: string) => Condition;
+/** Nothing selected. */
+declare const selectionEmpty: Condition;
+/** Exactly `n` items selected. */
+declare const selectionIs: (n: number) => Condition;
+/** At least `n` items selected. `selectionAtLeast(1)` is the common
+ *  "something is selected" check. */
+declare const selectionAtLeast: (n: number) => Condition;
+/** Multi-mode handle behavior active (single shared union-bounds
+ *  handle vs per-item handles). */
+declare const multiActive: Condition;
+/** Pointer is hovering some node. */
+declare const hovering: Condition;
+/** Pointer is hovering a node that is currently selected. */
+declare const hoveringSelected: Condition;
+/** Named modifier key currently held. */
+declare const modifierHeld: (m: keyof ModifierState) => Condition;
+/** View scale (uniform or geometric mean for non-uniform) is at least
+ *  `z`. Useful for "hide hairline chrome at low zoom" rules. */
+declare const zoomAtLeast: (z: number) => Condition;
+/** Active mode equals `m`. */
+declare const modeIs: (m: string) => Condition;
+/** Active mode is one of `modes`. */
+declare const modeIn: (modes: readonly string[]) => Condition;
+/** Active mode is NOT `m`. */
+declare const modeNot: (m: string) => Condition;
+/** Active mode's `allows` includes capability `cap`. */
+declare const capabilityIs: (cap: string) => Condition;
+/** Active mode's `allows` includes ANY of `caps` (OR). */
+declare const capabilityIn: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` includes ALL of `caps` (AND). */
+declare const capabilityAll: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` does NOT include capability `cap`. */
+declare const capabilityNot: (cap: string) => Condition;
+/** Primary pointer is imprecise (touch, most styluses). Absent device
+ *  profile → false. */
+declare const coarsePointer: Condition;
+/** Primary pointer can hover. Absent device profile → true. */
+declare const canHover: Condition;
+
+/**
+ * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
+ * at resolve time; consumer entries take precedence per id.
+ *
+ * Gating is written in terms of **capabilities, not mode ids**. A
+ * capability rule keeps holding when a new mode is added that permits the
+ * same thing; a mode rule has to be found and edited every time.
+ */
+declare const defaultVisibilityRules: VisibilityRules;
+
 /**
- * The writes a {@link PoseTransitionSeat} glides unless told otherwise: a
- * direct scene call, an undo, and a redo. An action's commit (`'ops'`) is
- * left out because most show their own result — a drag's release is already
- * where it is written — and `tweenPose` records its op before it animates.
- * Layout writes belong to `reflowTransition`.
+ * Build the per-frame visibility check: consumer rules merged on top of
+ * the kit defaults, evaluated against `ctx`.
+ *
+ * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
+ * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
+ * opted into modality behaves exactly like one sitting in normal mode.
  */
-declare function glidesByDefault(write: PoseWrite<unknown>): boolean;
-/** The part of a scene a pose transition hears and reads. */
-interface PoseTransitionScene<TPose, TNode = unknown> extends Pick<ScenePoseReports<TPose, TNode>, 'onPoseWrite'> {
-    readonly overrides: Pick<PoseOverrides<TPose>, 'read'>;
-}
-/** Hand `scene`'s pose writes to the seat's transition, each gliding from the
- *  pose it was shown at. A node something else poses through an override — a
- *  drag's preview, another animation — is left to it. With `departures`,
- *  removals leave as ghosts there, and a node that comes back while its ghost
- *  is leaving returns from where the ghost was. */
-declare function bindPoseTransition<TPose, TNode = unknown>(scene: PoseTransitionScene<TPose, TNode>, seat: () => PoseTransitionSeat<TPose> | null | undefined, departures?: Departures<TPose, TNode>): () => void;
-/** {@link bindPoseTransition} for a component's life, following the latest
- *  seat. Subscribes only while there is one. Answers the ghosts it shows. */
-declare function usePoseTransition<TPose, TNode = unknown>(scene: PoseTransitionScene<TPose, TNode>, seat: PoseTransitionSeat<TPose> | null | undefined): Departures<TPose, TNode>;
+declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
 
 /**
- * A routing-trait classifier entry. Other traits (shape, label, icon, …)
- * are independent registries — fields like `label` or `icon` do NOT belong
- * on this interface.
+ * Pure assembler for {@link ChromeCtx}. Sources are passed as plain values
+ * rather than the live objects they come from, which keeps `chrome-caps`
+ * from depending on React or the dispatcher's concrete type.
  */
-interface NodeRoutingEntry {
-    /** Unique kind name. Routing tables key on this string. Consumer-defined;
-     *  the kit places no constraint beyond uniqueness within a registry. */
-    name: string;
-    /** Predicate over a node's `data` payload, and the node itself where the caller has one, for
-     *  a kind its data cannot show (`'group'`). First registered kind whose `matches` returns
-     *  true claims the node. */
-    matches: (data: unknown, node?: RoutedNode) => boolean;
+
+/** The pieces of live canvas state a `ChromeCtx` is assembled from. */
+interface BuildChromeCtxArgs {
+    focused: boolean;
+    selection: readonly NodeId[];
+    multiActive: boolean;
+    modifiers: ModifierState;
+    action: {
+        kind: string | null;
+        id: string | null;
+    };
+    hover: NodeId | null;
+    view: View;
 }
-/** What a routing entry may read of a node beside its data. */
-interface RoutedNode {
-    /** The node's structural kind: `'mark'` or `'group'`. */
-    readonly kind?: string;
+/** Gather the current canvas state into the context that chrome-visibility
+ *  rules are evaluated against. Rebuilt per frame. */
+declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
+
+/** Last-hovered NodeId for chrome-caps rules. */
+
+/** Options for `useHoverTracking`. */
+interface UseHoverTrackingArgs {
+    /** Topmost id under a client point, or null. */
+    nodeAtClientPoint: (clientX: number, clientY: number) => {
+        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 {
+    /** The node the pointer is over, or null. */
+    getHover: () => NodeId | null;
+    /** Hand it the element to track, or null to stop: a callback ref, so an
+     *  element that mounts after the hook is tracked from the moment it arrives. */
+    canvasRef: (element: HTMLElement | null) => void;
+}
+/** Track which node the pointer is over. Returns a getter rather than state,
+ *  so a pointer move does not re-render the component. Cleared on
+ *  `pointerleave`. */
+declare function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking;
+
+/** `<SceneCanvas geometry>`: hit-test and bounds overrides, consumed by the
+ *  internal select tool. Ignored if the consumer passes their own `tools`. */
+interface SceneCanvasGeometry {
+    /** Hit-test override. Return the topmost id, the full back-to-front hit
+     *  stack (`string[]`), or `null` for empty space. The stack form lets a
+     *  consumer with domain overlap ordering (e.g. children over their
+     *  container) feed the kit's `pickTopMostHit` the true order instead of
+     *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */
+    pickEvery?: (world: WorldPoint) => string | string[] | null;
+    boundsOf?: (id: string) => FramedBox | null;
+    /**
+     * What "the pointer is on this node" means for the default body-pick.
+     *
+     * - `'pose'` — the node's pose rect, rotation honored.
+     * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter
+     *   actually lays down: its silhouette filled or not per the painter's `ink`, plus
+     *   its outline widened by the stroke half-width and `pickTolerancePx`.
+     *
+     * Painters with no silhouette keep the pose-rect answer either way. Ignored when
+     * `pickEvery` is supplied: that override owns the test.
+     */
+    picking?: 'pose' | 'shape';
+    /**
+     * Grab slop around a shape's outline, in **screen** pixels, so the target keeps
+     * its apparent size at any zoom. Default 4. It widens the outline test under
+     * `picking: 'shape'` and grows the pose-rect pre-filter so those outline hits
+     * survive it. Set `0` for exact geometry.
+     */
+    pickTolerancePx?: number;
+    /**
+     * Whether a shape's box includes its stroke as drawn — align, joins, and
+     * markers counted — or is the pose's geometry alone. Default `true`. The
+     * selection outline and handles sit on it, resize keeps the stroke's
+     * outer edge under the pointer without scaling the stroke, and rotate,
+     * flip, align, and distribute measure it. Stored geometry is unaffected.
+     */
+    boundsIncludeStroke?: boolean;
 }
+
+/** A scene `drawOne` that leaves out one node's glyphs. */
+type EditingDrawOne = <TNode extends Node<unknown, string, unknown>>(node: TNode, pose: unknown, view?: View, ctx?: NodePaintCtx) => DrawCommand[];
+
 /**
- * The **routing trait's** registry: answers "what routing-kind string does
- * this node's data map to?" The result flows into declarative tool-routing
- * tables (`{ target: 'rect', actionId: 'move' }`).
+ * Union math over rect-shaped poses.
+ *
+ * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*
+ * boxes and is what commit-time actions want, because they go on to write
+ * poses back in that same frame. `unionAABB` expands each rotated member to
+ * the extent of its ink first, and is what anything a user looks at or clicks
+ * wants — selection chrome, gesture bounds, an export viewBox. Folding the
+ * unrotated box there under-reports the extent of a rotated member exactly
+ * when the consumer is watching it move.
  */
-interface NodeRouting {
-    /** Register a kind. Order matters: first match wins during `classify`.
-     *  Throws if a kind with this name is already registered. */
-    register(kind: NodeRoutingEntry): void;
-    /** Walk registered kinds in registration order; return the first kind
-     *  whose `matches(data, node)` returns true, or `'unknown'` if none match. */
-    classify(data: unknown, node?: RoutedNode): string;
-    /** Lookup a kind entry by name. */
-    get(name: string): NodeRoutingEntry | undefined;
-    /** 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;
 
+/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any
+ *  rotation they carry. See the module docstring before reaching for this
+ *  over {@link unionAABB}. */
+declare function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null;
 /**
- * The scene slot: an adapter's tree as render layers, one per scene layer.
+ * Axis-align a pose that carries a `rotation` or a `transform`: returns the
+ * AABB of the box as drawn, its four corners through `poseFrameOf`, with both
+ * fields dropped.
+ *
+ * A pose with neither is returned as-is.
+ */
+declare function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose;
+/**
+ * Fold every part into one world-space AABB, skipping `null` / `undefined`
+ * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;
+ * the result never carries a `rotation` (a union of several oriented boxes
+ * has no single orientation to report).
+ *
+ * Returns `null` when nothing was contributed.
  */
+declare function unionAABB<TPose extends RectPose>(parts: Iterable<TPose | null | undefined>): RectPose | null;
 
-/** Scene slot config — describes how to draw one object with its effective pose. */
-interface SceneSlotConfig<TNode extends {
-    id: string;
-}, TPose> {
-    /** Paint these, in this order, in place of the adapter's tree: one flat run with no
-     *  scene layers, no container clips, and no pose composition. */
-    objects?: TNode[];
-    /** The pose an object is painted at. Defaults to `adapter.getPose(obj.id)`. `<SceneCanvas>`
-     *  hands it each node as the scene shows it, its `pose` an override's or a derived one,
-     *  and carries an override's `path` into the box it answers; return a pose placed from
-     *  `obj.pose`, or a drag in flight and a rig's motion do not show in this view. */
-    toPose?: (obj: TNode) => TPose;
-    /** Draw a single object as a `DrawCommand` tree. `ctx` carries a derived
-     *  node's path: `<SceneCanvas>` resolves it from the scene, and
-     *  `buildSceneLayer` called without one from its adapter. */
-    drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];
-    /** The path a container derives from its dependencies' poses, for the clip
-     *  it imposes on its subtree — `drawOne`'s `ctx` carries the derived path a
-     *  node *paints*, this one the clip it *imposes*. A scene-aware caller
-     *  supplies it; left out, both are resolved off the adapter. */
-    derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;
-    /** Default ghost alpha for the move-overlay slot. Default 0.85. */
-    ghostAlpha?: number;
-    /** Per-id alpha multiplier. A node's emitted `DrawCommand[]` is wrapped in a
-     *  `{ kind: 'group', alpha }` when the returned value is not 1. */
-    alphaFor?: (id: string) => number;
+/** Shape the default projections expect `data` to satisfy. All fields
+ *  optional so any object satisfies the constraint — projections fill in
+ *  the gaps for non-default shapes. */
+interface DefaultTextData {
+    text?: string;
+    style?: TextStyle;
+    runs?: readonly StyledRun[];
+    fill?: Fill | Inherit | null;
+    stroke?: Stroke | Inherit | null;
+    verticalAlign?: TextVerticalAlign;
+    padding?: number;
+    overflow?: TextOverflow;
+}
+/** All-optional projections + fontSize fallback. */
+interface UseSceneTextEditOptions<TData> {
     /**
-     * Post-processor for the scene slot's emitted commands: called with the final
-     * world-space `DrawCommand[]` each time a scene canvas layer draws (after per-node
-     * rotation wrapping and `alphaFor`), once per layer when the slot is split into
-     * `scene:<layerId>` layers. Its return value replaces the array handed to the renderer.
+     * Is this node text? A double-click opens an edit only on a node that
+     * answers yes, and passes through any other to the text under it. Default:
+     * `isTextData`, the test `inferredNodeRouting` classifies a text node by. Pass one when `getText` reads some other shape.
+     */
+    isText?: (data: TData) => boolean;
+    /** Read plain text from `data`. Default: `data.text ?? ''`. */
+    getText?: (data: TData) => string;
+    /** Read style from `data`. Default: `data.style`. */
+    getStyle?: (data: TData) => TextStyle | undefined;
+    /** Read the node's paint from `data`. Default: `data.fill` / `data.stroke`. */
+    getPaint?: (data: TData) => TextPaint | undefined;
+    /** Read rich-text runs from `data`. Default: `data.runs`. */
+    getRuns?: (data: TData) => readonly StyledRun[] | undefined;
+    /** Read the box vertical alignment from `data`. Default: `data.verticalAlign`. */
+    getVerticalAlign?: (data: TData) => TextVerticalAlign | undefined;
+    /** Read the inset from the node's box to its text from `data`. Default: `data.padding`. */
+    getPadding?: (data: TData) => number | undefined;
+    /** Read whether the node cuts its text at its box from `data`, which the
+     *  overlay then does too. Default: `data.overflow`. */
+    getOverflow?: (data: TData) => TextOverflow | undefined;
+    /** Produce updated data with new text. Default: `{ ...data, text }`. */
+    setText?: (data: TData, text: string) => TData;
+    /** Produce updated data with new runs. Default: `{ ...data, runs }`. */
+    setRuns?: (data: TData, runs: StyledRun[]) => TData;
+    /**
+     * Produce updated data with a new node-wide style. Default:
+     * `{ ...data, style }`. Written only when a range toggle has to *clear* a
+     * flag the node itself sets — the run algebra is additive, so that edit
+     * lowers the node flag and raises it on the runs outside the range. See
+     * `useTextEdit`'s `setStyle`.
      *
-     * Commands are world-space — `drawLayers` applies the view transform afterward. Clip
-     * nesting is capped at 7 levels; a wrapping group with `clip` consumes one. The
-     * move-overlay ghost (drag preview) is not post-processed.
+     * An edit's text, runs, and style are folded through these three and
+     * written as one `scene.update`, so a commit is one undo step.
      */
-    postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];
+    setStyle?: (data: TData, style: TextStyle) => TData;
+    /** Fallback fontSize when `style.fontSize` is unset. Default `16`. */
+    defaultFontSize?: number;
     /**
-     * Skip what cannot reach the view. A node `paintBounds` places outside the
-     * `dims` rectangle under `view` is not painted at all; then, after
-     * `postProcess`, `cullDrawCommands` drops any remaining command that cannot
-     * reach it — see there for what it can and cannot bound. So `postProcess`
-     * sees an empty group where a culled node would have painted.
+     * The view to project through. Omit it and the view is read live from the
+     * weasel canvas mounted inside `container` (the one a double-click landed
+     * on, when there are several). With no canvas there, the node's world box
+     * is passed through as screen pixels.
      *
-     * Off by default because it makes the layer's world-space output depend on
-     * the view: anything that draws this layer once and shows the result under
-     * another view — a cache keyed without `view`, a consumer re-wrapping the
-     * commands — would show the first view's cull.
+     * A thunk is re-read on every projection; a plain `View` is the value from
+     * the render that supplied it.
      */
-    cull?: boolean;
+    view?: View | (() => View);
     /**
-     * Where `drawOne`'s output for a node can reach, in the frame it paints in
-     * — before the pose rotation the slot wraps it in. `null` for a node it
-     * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a
-     * node whose box misses the view, so it must enclose everything `drawOne`
-     * paints: a box too small makes a node vanish before it leaves the screen.
-     *
-     * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is
-     * `defaultDrawOne`. Omit it with any other `drawOne` and culling only
-     * trims commands after painting.
+     * Forwarded to `useTextEdit`: is `el` part of the editor's own chrome?
+     * Focus moving into it does not end the edit. Wire it to whatever renders
+     * the character controls.
      */
-    paintBounds?: PaintBoundsFn<TNode, TPose>;
-}
-
-/**
- * The selection overlay's resize handles: their style, where the kit puts
- * them, and the commands that paint them.
- */
-
-/** Handle visuals, as a consumer supplies them. */
-interface SelectionHandleStyle {
-    size?: number;
-    fill?: CommandFill;
-    outline?: CommandStroke;
+    isEditorChrome?: (el: Element) => boolean;
+    /** Forwarded to `useTextEdit`: what Escape does to the edit. */
+    escape?: 'cancel' | 'commit';
+    /** Forwarded to `useTextEdit`: how long an edit waits for its face. */
+    fontHold?: number;
+    /** Forwarded to `useTextEdit`: called as an edit of the node `id` opens,
+     *  whichever way it was started. */
+    onStart?: (id: string) => void;
+    /** Forwarded to `useTextEdit`: called as the edit of `id` closes, after
+     *  any commit has been written to the scene. */
+    onEnd?: (id: string) => void;
 }
-
-/**
- * The pose and box a selection's chrome is drawn around: precedence between
- * the in-flight overlays and the stored pose, a container's union over its
- * leaves, and the drawn box a scene supplies.
- */
-
-/** Options for `composeSelectionPose`. */
-interface ComposeSelectionPoseOpts<TPose> {
-    /** Move overlay; when present its `poses` map wins over everything else. */
-    moveOverlay?: {
-        poses: Map<string, TPose>;
-    } | null;
+/** What `onDoubleClick` reads of the event: a React or a DOM `MouseEvent`. */
+type TextEditDoubleClick = Pick<MouseEvent, 'target' | 'clientX' | 'clientY'>;
+/** Return shape extends `UseTextEditReturn` with an `onDoubleClick`
+ *  binding for the canvas container. Double-clicking inside a text
+ *  node enters edit mode with the caret seeded at the clicked glyph. */
+interface UseSceneTextEditReturn extends UseTextEditReturn {
+    /** Bind to the element wrapping `<SceneCanvas>` (the same element
+     *  passed as `container`, or any ancestor that receives the dblclick
+     *  bubble). Starts an edit on the top-most text node under the cursor. */
+    onDoubleClick: (e: TextEditDoubleClick) => void;
+    /** The `isText` option asked of the node with this id: what
+     *  `TextEditDep.isTextNode` wants, so both ways into an edit agree. */
+    isTextNode: (id: string) => boolean;
     /**
-     * Resize overlay; consulted only when move overlay does not own the id.
-     * For container resize, `leafPoses` (when present) maps each leaf id under
-     * the container to its overlay pose. If absent the container falls back to
-     * stored leaf poses.
+     * `defaultDrawOne`, less the glyphs of the node being edited: the overlay
+     * stands in for its text, and the rest of the node, a `background` among
+     * it, goes on painting. Pass it as `layers.scene.drawOne`, with
+     * `paintBounds: defaultPaintBounds`, in place of an `alphaFor` that hides
+     * the whole node.
      */
-    resizeOverlay?: {
-        id: string;
-        currentPose: TPose;
-        leafPoses?: Map<string, TPose>;
-    } | null;
-    /** Fallback pose lookup (typically the stored/committed pose). */
-    getStoredPose: (id: string) => TPose;
-    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
-    poseDescriptor?: PoseDescriptor<TPose>;
-    /** Walk a container's direct children (e.g. `scene.childrenOf`). With
-     *  `isContainer`, a selected container resolves to the union AABB of its
-     *  transitive leaf poses instead of its own stored pose. */
-    getChildren?: (id: string) => readonly string[];
-    /** True when `id` is a structural container. */
-    isContainer?: (id: string) => boolean;
-    /** The nodes behind the ids. With it, a container's union takes each leaf
-     *  as drawn, stroke included (`drawnBoundsOf`); without, its pose box. */
-    scene?: DrawnBoundsScene;
-    /** View scale a screen-pixel stroke is resolved at. Default 1. */
-    viewScale?: () => number | Scale2;
+    drawOne: EditingDrawOne;
 }
-/**
- * Build a pose resolver for a selection. Precedence per id:
- * move overlay > resize overlay > stored. When `getChildren`/`isContainer`
- * are supplied and the id resolves to a container, the resolver returns the
- * union AABB of all transitive leaf poses (each leaf still subject to the
- * precedence rules). Containers with no leaves resolve to `null`.
- */
-declare function composeSelectionPose<TPose>(opts: ComposeSelectionPoseOpts<TPose>): (id: string) => TPose | null;
+/** Wire double-click-to-edit text on a scene: mounts a DOM editing overlay
+ *  over the node being edited and writes the result back as an undoable op.
+ *  `<SceneCanvas>`'s own editor stands down for any canvas inside `container`. */
+declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends string, TPose extends RectPose = RectPose>(scene: Scene<TData, TLayer, TPose>, container: HTMLElement | null, options?: UseSceneTextEditOptions<TData>): UseSceneTextEditReturn;
 
 /**
- * Selection overlay primitives — render layers for drawing selection
- * outlines and resize handles.
- *
- * **Pose shape:** TPose is generic; callers pass `poseDescriptor` for poses
- * `AUTO_POSE_DESCRIPTOR` can't read. Container ids reduce via `unionAABB`
- * over the projected AABBs.
+ * `<SceneCanvas>`'s own text editor: the one a text or sticky tool's
+ * `enterTextEdit` reaches, and a double-click on a text node opens, when the
+ * host has wired none of its own. It stands down for a host editor — a
+ * `useSceneTextEdit` whose container holds the canvas, or a `textEdit` dep
+ * registered over it.
  */
 
-/** Options every selection layer shares. `getSelection` and `getPose` are
- *  declared on {@link SelectionOverlayLayerOpts}, which makes both optional —
- *  omitted, they come off the draw envelope. */
-interface SelectionLayerCommon<TPose> {
-    /** How to read poses. Default `AUTO_POSE_DESCRIPTOR`. */
-    poseDescriptor?: PoseDescriptor<TPose>;
-    /** Walk a container's direct children (e.g. `scene.childrenOf`). When
-     *  supplied with `isContainer`, any id that resolves to a container is
-     *  rendered using the union bounds of all its transitive leaves. */
-    getChildren?: (id: string) => readonly string[];
-    /** True when `id` is a structural container. */
-    isContainer?: (id: string) => boolean;
-    /** The nodes behind the ids `getPose` answers for. With it, a stroked
-     *  node's chrome sits on its stroke (`drawnBoundsOf`); without, on its
-     *  pose box. Ignored when bounds come off the draw envelope. */
-    scene?: DrawnBoundsScene;
+/** `<SceneCanvas textEditor>`: its own editor's options, or `false` for none. */
+type SceneCanvasTextEditor<TData> = false | UseSceneTextEditOptions<TData>;
+
+/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields
+ *  modality dispatch needs; extends as the kit's `Hit` type evolves. */
+interface SceneCanvasHit {
+    id: string;
+    kind: string;
 }
-/** Options for `createSelectionOutlineLayer`. The overlay layer's options
- *  minus the handle visuals — the two run the same body. */
-type SelectionOutlineLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'handles' | 'handlesOf' | 'resizeHandles' | 'rotationHandle'>;
-/** Options for `createSelectionHandlesLayer`. The overlay layer's options
- *  minus the outline stroke — the two run the same body. */
-type SelectionHandlesLayerOpts<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'outline'>;
-/** Options for `createSelectionOverlayLayer`. */
-interface SelectionOverlayLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
+/** `<SceneCanvas>`'s props for what the pointer can reach and what a click names. */
+interface SceneCanvasPointerProps<TData = unknown> {
     /**
-     * Which ids to draw chrome for. Omit to take them from the `ChromeState` on
-     * the draw envelope, which is what makes one canvas's several views each
-     * outline their own selection — the layer is shared, the envelope is not.
+     * Per-id pointer-interactivity predicate: an id it returns `false` for is excluded from
+     * hit-test results. Typical use: suppressing pointer events for dimmed nodes.
      */
-    getSelection?: () => readonly NodeId[];
+    isPointerInteractive?: (id: string) => boolean;
     /**
-     * Resolve an id to the pose to draw chrome around. Return null to skip an
-     * id. Omit to take bounds from the same envelope `getSelection` omitted
-     * takes ids from.
+     * The entered group: the group a press resolves inside of, and which a double-click drills down
+     * from. Nodes outside it take no hits. Pass one from `useEnteredGroup(scene)` to read or drive it
+     * from outside the canvas, as `selection` is passed; without it the canvas keeps its own.
+     */
+    enteredGroup?: EnteredGroupApi;
+    /**
+     * Called when the user double-clicks the canvas, with the hit node (id + kind) at that
+     * position, or `null` on empty canvas. A notification, not a binding: it fires whatever the
+     * double-click does. Entering a mode on the node belongs to `modeTriggers` instead.
+     */
+    onDoubleClick?: (hit: SceneCanvasHit | null) => void;
+    /** Called on every click — a press and release without a drag — with the
+     *  node under it, or `null` on empty canvas. Fires after the click's own
+     *  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 canvas's own text editor: what a text or sticky tool's `enterTextEdit`
+     * opens, and, with the `edit` feature, a double-click on a text node. Pass
+     * `useSceneTextEdit`'s options to configure it, or `false` for none.
      *
-     * Takes `string` rather than `NodeId` because the container-aware resolver
-     * walks expanded leaf ids via `getChildren`, which is generic over strings.
+     * It mounts its overlay in the canvas's offset parent, so the canvas wants a
+     * positioned ancestor. It stands down for a host's own editor: a
+     * `useSceneTextEdit` whose container holds the canvas, or a `textEdit` dep
+     * registered by a child. Wire one of those for character controls, which
+     * read the edit's state.
      */
-    getPose?: (id: string) => TPose | null;
-    outline?: CommandStroke & {
-        pad?: number;
-    };
-    /** Pass `false` to render outlines only. */
-    handles?: SelectionHandleStyle | false;
-    /** Where to paint handles, in the bounds' own frame. Replaces the kit's
-     *  layout, `resizeHandles` included. */
-    handlesOf?: (bounds: FramedBox) => {
-        x: number;
-        y: number;
-    }[];
-    /** The layout the resize affordance hits by: its `hitRadiusPx`, never
-     *  `handles.size`, decides which edge handles are painted. Default: edges on,
-     *  at the kit's default hit radius. */
-    resizeHandles?: Partial<ResizeHandleLayout>;
-    /** Draw a rotate badge above the selection's top edge. `true` places it at
-     *  the default offset; `distance` sets the offset in screen pixels. Off by
-     *  default. */
-    rotationHandle?: boolean | {
-        distance?: number;
-    };
-    /** Optional separate id list for the per-item outline pass, for a
-     *  multi-selection whose handle pass works against a synthetic union id
-     *  (e.g. `MULTI_RESIZE_TARGET_ID`) while each real member is outlined.
-     *  When omitted, the outline pass uses the handle pass's ids. */
-    getOutlineIds?: () => readonly NodeId[];
-    /** Optional set of ids to suppress entirely — both outline and handles
-     *  are skipped. */
-    getSuppressedIds?: () => ReadonlySet<string>;
+    textEditor?: SceneCanvasTextEditor<TData>;
 }
-/**
- * `RenderLayer` that draws selection outlines only. Stack alongside
- * `createSelectionHandlesLayer` (or use `createSelectionOverlayLayer`, which
- * runs both passes in one layer) when both are wanted.
- */
-declare function createSelectionOutlineLayer<TPose>(opts: SelectionOutlineLayerOpts<TPose>): RenderLayer<unknown>;
-/**
- * `RenderLayer` that draws selection handles only. Stack on top of
- * `createSelectionOutlineLayer` (handles render on top of the outline).
- */
-declare function createSelectionHandlesLayer<TPose>(opts: SelectionHandlesLayerOpts<TPose>): RenderLayer<unknown>;
-/**
- * Draws outlines then handles in a single layer. Exactly equivalent to
- * stacking `createSelectionOutlineLayer` and `createSelectionHandlesLayer` —
- * all three run the same body. Pass `handles: false` to render outlines only.
- */
-declare function createSelectionOverlayLayer<TPose>(opts: SelectionOverlayLayerOpts<TPose>): RenderLayer<unknown>;
+
+/** The `<SceneCanvas>` props that change the actions and bindings a canvas has. */
+interface SceneCanvasActionProps {
+    /**
+     * Tune actions on this canvas without restating them, keyed by action id:
+     * `params` every invocation starts from, and `bindings` added beside the
+     * action's own. A tuning applies to whichever descriptor holds the id, a
+     * preset's or a tool's. Pass a stable object; a params thunk is read on
+     * every call. See the core README ("Tuning an action").
+     */
+    tune?: ActionTunings;
+    /**
+     * Replace or remove bindings by binding id, on actions and contributions
+     * alike: a route string (`'[*:*] keyDown(=) +mod'`), a spec (`key('Mod+=')`),
+     * or `null` to unbind. Pass a stable object.
+     */
+    bindingOverrides?: BindingOverrides;
+    /**
+     * Replace, add or mute whole action descriptors. Pass `null` to disable
+     * all defaults. To change a built-in's params or add a key, use `tune`.
+     */
+    actions?: ActionsProp;
+}
+
+/** Turns pasted or dropped plain text into a text node sized to the string. A kit handler, so a
+ *  canvas with the `ingest` feature takes text unless its `ingestion.kitHandlers` omits it. */
+declare const kitTextHandler: ContentHandlerEntry;
 
 /**
- * The draw commands path edit paints for the open path, in screen space: its
- * outline, then each anchor's handles and marker.
+ * The kit's default content handlers, which every `<SceneCanvas>` routes through unless its
+ * `ingestion.kitHandlers` turns some or all of them off. They belong to the canvas, not to
+ * the page-wide registry, so one canvas turning one off leaves the others alone.
  */
 
-/** Appearance of the outline and of the anchor and handle markers. */
-interface PathEditingOverlayStyle {
-    anchorSizePx?: number;
-    handleDotRadiusPx?: number;
-    anchorFill?: string;
-    anchorStroke?: string;
-    handleStroke?: string;
-    /** Fill of the control-point circle. Defaults to the handleStroke color
-     *  at 50% alpha. */
-    handleDotFill?: string;
-    /** Fill of a selected anchor square. Defaults to the anchor stroke color. */
-    anchorFillSelected?: string;
-    /** The open path's outline, drawn over its own fill and stroke so the path
-     *  shows however its paint and its markers cover it. */
-    outlineStroke?: string;
-    outlineWidthPx?: number;
-    /** Radius of the dot an unselected anchor shrinks to where anchors sit
-     *  closer together on screen than a marker is wide. */
-    denseDotRadiusPx?: number;
-    /** Stroke of the marquee rubber band. */
-    marqueeStroke?: string;
-    /** Fill of the marquee rubber band. */
-    marqueeFill?: string;
+/** `<SceneCanvas ingestion={{ kitHandlers }}>`: `true` (the default) keeps every kit handler,
+ *  `false` none, and `{ omit }` all but the ids named (`'kit:image'`, `'kit:svg'`,
+ *  `'kit:weasel-json'`, `'kit:text'`). */
+type KitHandlersOption = boolean | {
+    omit: readonly string[];
+};
+
+/** Options for {@link openFilePicker}. */
+interface OpenFilePickerOptions {
+    /** `<input accept>` filter, e.g. `'image/*'` or `'.csv,text/csv'`. */
+    accept?: string;
+    /** Allow multi-select. Default false. */
+    multiple?: boolean;
 }
-/** The path-edit overlay's look where a {@link PathEditingOverlayStyle} leaves a field out. */
-declare const DEFAULT_OVERLAY_STYLE: Required<PathEditingOverlayStyle>;
+/**
+ * Show the browser's file picker and resolve with what the user chose —
+ * empty when they cancel. Must be called from a user gesture (a click
+ * handler): browsers block programmatic `input.click()` otherwise. Pairs
+ * with `CanvasExtensionApi.ingest`:
+ *
+ * ```ts
+ * const files = await openFilePicker({ accept: 'image/*', multiple: true });
+ * canvasRef.current?.ingest(files);
+ * ```
+ */
+declare function openFilePicker(opts?: OpenFilePickerOptions): Promise<File[]>;
 
 /**
- * Screen-space render layer for path-editing chrome — the open path's
- * outline, anchor markers, tangent lines, and control-point dots for a
- * polygon path that is the current edit target, under them whatever marks
- * its path-edit extensions draw. Marker sizes stay constant regardless of zoom.
+ * Ghosts of removed nodes: what a pose transition shows leaving after the
+ * scene has let a node go. A ghost is not a scene node, so picking,
+ * selection and history never see it; it lives here until its glide ends.
  */
 
-/** Options for `createPathEditingOverlayLayer`. Everything is read per frame,
- *  so the layer follows a changing edit target without being rebuilt. */
-interface CreatePathEditingOverlayLayerOptions {
-    /** Returns the id of the polygon currently in anchor-edit mode, or null
-     *  when no node is being edited. */
-    getEditingId(): string | null;
-    /**
-     * Returns the pose for an id, or null if the node has been deleted.
-     * Non-polygon poses are tolerated (the layer no-ops on them).
-     *
-     * `previews` are the drawing view's in-flight preview surfaces, so an
-     * anchor dragged in one panel does not move in the others. Resolve against
-     * them before falling back to the committed pose.
-     *
-     * `view` is the drawing view's camera. Answer in its world: a node whose
-     * layer is a parallax plane stores its path in the plane's.
-     */
-    getPose(id: string, previews: readonly GesturePreviewSource[], view: View): Path | null;
-    /** The marker of each anchor, by flat index, for a node whose path was
-     *  drawn from a form (`PathRepresentation.anchorMarkers`); null, or an
-     *  anchor with none, draws a square. Resolve against `previews` as
-     *  `getPose` does. */
-    getAnchorMarkers?(id: string, previews: readonly GesturePreviewSource[]): readonly (AnchorMarkerShape | null)[] | null;
-    /** Flat indices of the selected anchors. Selected anchors render
-     *  filled; unselected ones hollow. */
-    getSelectedAnchors?(): ReadonlySet<number>;
-    /** In-flight anchor-marquee rect in world coords, or null. Drawn as a
-     *  rubber band while `marqueeAnchorsAction` is dragging. */
-    getMarquee?(view: View): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | null;
-    /** The edited node's committed pose and data, which extensions' marks read. */
-    getNode?(id: string): {
-        pose: unknown;
-        data: unknown;
-        layer?: string;
-    } | null;
-    /** The path-edit extensions whose marks are drawn, in order. */
-    getExtensions?(): readonly PathEditExtension[];
-    /** The selected extension mark, or null. */
-    getSelectedMark?(): PathEditMark | null;
-    /** Optional styling overrides. */
-    style?: PathEditingOverlayStyle;
+/** A removed node as its ghost shows it now. */
+interface ShownDeparture<TPose, TNode> {
+    removal: PoseRemoval<TPose, TNode>;
+    pose: TPose;
+    alpha: number;
 }
-/** Render layer that draws the outline and the anchors and control handles
- *  of the path currently being anchor-edited. Draws nothing when no path is
- *  being edited. */
-declare function createPathEditingOverlayLayer(opts: CreatePathEditingOverlayLayerOptions): RenderLayer<unknown>;
+/** The ghosts one canvas shows. */
+interface Departures<TPose, TNode> {
+    /** See `removal` off from where it was shown toward `exit` of that pose,
+     *  fading out, through `transition`. Does nothing for a transition with no
+     *  `over`, which cannot carry a node the scene no longer holds. */
+    leave(removal: PoseRemoval<TPose, TNode>, exit: (pose: TPose) => TPose, transition: ReflowTransition<TPose>): void;
+    /** Drop `id`'s ghost — its node is back — and answer where it was shown. */
+    recall(id: string): TPose | undefined;
+    shown(): ShownDeparture<TPose, TNode>[];
+    /** Hear each frame a ghost moves, and each one that comes or goes. */
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+}
+/** An empty set of ghosts, for `bindPoseTransition` to fill and a layer to
+ *  draw; `usePoseTransition` makes one per canvas. */
+declare function createDepartures<TPose, TNode>(): Departures<TPose, TNode>;
 
-/** Standard slot names — render in this canonical order.
- *  `cellHighlight` is not an anchor for custom layers: it sits between the
- *  grid and the scene, so anchor to one of those. */
-/** @internal */
-declare const STANDARD_SLOTS: readonly ["grid", "cellHighlight", "scene", "selectionOverlay"];
-/** Names of the slots `<Canvas>` supports out of the box (excluding the implicit cell-highlight overlay). */
-type StandardSlotName = Exclude<(typeof STANDARD_SLOTS)[number], 'cellHighlight'>;
-/** Custom layer entry — any key not in `STANDARD_SLOTS`. The presence of
- *  `.layer` discriminates this from a slot config. */
-interface CustomLayerEntry {
-    layer: RenderLayer<unknown>;
-    /** Insert immediately after the named standard slot or another custom-layer key. */
-    after?: StandardSlotName | (string & {});
-    /** Insert immediately before the named standard slot or another custom-layer key. */
-    before?: StandardSlotName | (string & {});
+/**
+ * Which pose writes a canvas glides, and through what: `<SceneCanvas
+ * poseTransition>`. The transition is the kind `reflowTransition` takes, and
+ * one object can serve both.
+ */
+interface PoseTransitionSeat<TPose> {
+    /** Shows each glide through a pose override; writes nothing. */
+    transition: ReflowTransition<TPose>;
+    /** Whether `write` glides. Default {@link glidesByDefault}. */
+    glides?: (write: PoseWrite<TPose>) => boolean;
+    /** Where a node the scene adds is first shown, given the pose it was added
+     *  at. Absent, an added node appears in place. */
+    enter?: (pose: TPose) => TPose;
+    /** Where a node the scene removes is seen off to, given the pose it was
+     *  shown at: a ghost of it glides there fading out, drawn but never picked,
+     *  selected or recorded. Absent, a removed node vanishes. Needs a
+     *  transition from `useAnimatedReflow` or `createReflowTransition`. */
+    exit?: (pose: TPose) => TPose;
+    /** Whether a removal is seen off through `exit`. Default: every one but
+     *  an untracked removal. */
+    exits?: (removal: PoseRemoval<TPose>) => boolean;
 }
-/** Selection-overlay slot config — passed through to `createSelectionOverlayLayer`,
- *  minus the `getSelection`/`getPose` the canvas wires automatically and the
- *  `resizeHandles` it takes from the hit-test, so the two cannot disagree. */
-type SelectionOverlaySlotConfig<TPose> = Omit<SelectionOverlayLayerOpts<TPose>, 'getSelection' | 'getPose' | 'resizeHandles'> & {
-    /** Override the auto-wired pose lookup (overlay-aware → adapter fallback). */
-    poseById?: (id: string) => TPose | null;
-};
-/** Path-edit overlay slot config: how `<SceneCanvas>` draws the chrome of the
- *  path whose anchors are being edited. */
-interface PathEditingOverlaySlotConfig {
-    /** Anchor and handle marker overrides. */
-    style?: PathEditingOverlayStyle;
+/**
+ * The writes a {@link PoseTransitionSeat} glides unless told otherwise: a
+ * direct scene call, an undo, and a redo. An action's commit (`'ops'`) is
+ * left out because most show their own result — a drag's release is already
+ * where it is written — and `tweenPose` records its op before it animates.
+ * Layout writes belong to `reflowTransition`.
+ */
+declare function glidesByDefault(write: PoseWrite<unknown>): boolean;
+/** The part of a scene a pose transition hears and reads. */
+interface PoseTransitionScene<TPose, TNode = unknown> extends Pick<ScenePoseReports<TPose, TNode>, 'onPoseWrite'> {
+    readonly overrides: Pick<PoseOverrides<TPose>, 'read'>;
 }
-/** Per-slot config union. The key narrows it in practice. */
-type StandardSlotConfig<TNode extends {
-    id: string;
-}, TPose> = SceneSlotConfig<TNode, TPose> | SelectionOverlaySlotConfig<TPose> | PathEditingOverlaySlotConfig;
-/** What may fill one of the canvas's named layer slots: a config the canvas
- *  builds the layer from, a pre-built layer, or `null` to leave the slot
- *  empty. */
-type LayerSlotValue<TNode extends {
-    id: string;
-}, TPose> = StandardSlotConfig<TNode, TPose> | CustomLayerEntry | null;
-/** The canvas's render stack, as named slots. The standard slots (grid,
- *  scene, selection overlay, cell highlight) fix where a layer sits in the
- *  stack; scene and selection overlay can be configured, and every one can be
- *  given a layer of your own or switched off. Further keys add custom layers.
- *  `TSceneSlot` is what the scene slot accepts: `<SceneCanvas>` takes a
- *  partial config and fills the rest from its defaults. */
-type LayersMap<TNode extends {
-    id: string;
-}, TPose, TSceneSlot = SceneSlotConfig<TNode, TPose>> = {
-    /** Grid slot, beneath the scene. Takes a pre-built layer (`{ layer }`) —
-     *  e.g. `createGridLayer` from `@weasel-js/guides` — or `null`. */
-    grid?: CustomLayerEntry | null;
-    /** Scene slot: the config `<SceneCanvas>` builds its layers from, a
-     *  pre-built layer that paints the scene in their place, or `null`. A
-     *  pre-built layer gets no ghost of a node in flight, which needs `drawOne`. */
-    scene?: TSceneSlot | CustomLayerEntry | null;
-    /** Selection-overlay slot: the config `<SceneCanvas>` builds the layer
-     *  from, a pre-built layer that paints in its place, or `null` for no
-     *  selection chrome. */
-    selectionOverlay?: SelectionOverlaySlotConfig<TPose> | CustomLayerEntry | null;
-    /** Cell-highlight overlay slot, drawn immediately after the grid. Takes a
-     *  pre-built layer (`{ layer }`) — e.g. `createCellHighlightLayer` from
-     *  `@weasel-js/guides` — or `null`. */
-    cellHighlight?: CustomLayerEntry | null;
-    /** `<SceneCanvas>`'s anchor-editing overlay, above the selection overlay:
-     *  the config it builds the layer from, a pre-built layer, or `null`. */
-    pathEditingOverlay?: PathEditingOverlaySlotConfig | CustomLayerEntry | null;
-} & {
-    [customKey: string]: LayerSlotValue<TNode, TPose> | TSceneSlot | undefined;
-};
-/** The scene slot once built: its canvas layers, bottom first. Each `key` is
- *  an anchor a custom layer can name (`scene`, or `scene:<layerId>`). */
-interface SceneSlotLayers {
-    layers: ReadonlyArray<{
-        key: string;
-        layer: RenderLayer<unknown>;
-    }>;
+/** Hand `scene`'s pose writes to the seat's transition, each gliding from the
+ *  pose it was shown at. A node something else poses through an override — a
+ *  drag's preview, another animation — is left to it. With `departures`,
+ *  removals leave as ghosts there, and a node that comes back while its ghost
+ *  is leaving returns from where the ghost was. */
+declare function bindPoseTransition<TPose, TNode = unknown>(scene: PoseTransitionScene<TPose, TNode>, seat: () => PoseTransitionSeat<TPose> | null | undefined, departures?: Departures<TPose, TNode>): () => void;
+/** {@link bindPoseTransition} for a component's life, following the latest
+ *  seat. Subscribes only while there is one. Answers the ghosts it shows. */
+declare function usePoseTransition<TPose, TNode = unknown>(scene: PoseTransitionScene<TPose, TNode>, seat: PoseTransitionSeat<TPose> | null | undefined): Departures<TPose, TNode>;
+
+/**
+ * A routing-trait classifier entry. Other traits (shape, label, icon, …)
+ * are independent registries — fields like `label` or `icon` do NOT belong
+ * on this interface.
+ */
+interface NodeRoutingEntry {
+    /** Unique kind name. Routing tables key on this string. Consumer-defined;
+     *  the kit places no constraint beyond uniqueness within a registry. */
+    name: string;
+    /** Predicate over a node's `data` payload, and the node itself where the caller has one, for
+     *  a kind its data cannot show (`'group'`). First registered kind whose `matches` returns
+     *  true claims the node. */
+    matches: (data: unknown, node?: RoutedNode) => boolean;
 }
-/** What `<Canvas>` composes: a {@link LayersMap} with every slot already a
- *  layer. `<SceneCanvas>` builds one from its `layers` prop. */
-type CanvasLayers = {
-    grid?: CustomLayerEntry | null;
-    cellHighlight?: CustomLayerEntry | null;
-    scene?: SceneSlotLayers | null;
-    selectionOverlay?: CustomLayerEntry | null;
-} & {
-    [customKey: string]: CustomLayerEntry | SceneSlotLayers | null | undefined;
-};
+/** What a routing entry may read of a node beside its data. */
+interface RoutedNode {
+    /** The node's structural kind: `'mark'` or `'group'`. */
+    readonly kind?: string;
+    /** Set on a boolean group: see `booleanGroupFields`. */
+    readonly consumesChildren?: boolean;
+}
+/**
+ * The **routing trait's** registry: answers "what routing-kind string does
+ * this node's data map to?" The result flows into declarative tool-routing
+ * tables (`{ target: 'rect', actionId: 'move' }`).
+ */
+interface NodeRouting {
+    /** Register a kind. Order matters: first match wins during `classify`.
+     *  Throws if a kind with this name is already registered. */
+    register(kind: NodeRoutingEntry): void;
+    /** Walk registered kinds in registration order; return the first kind
+     *  whose `matches(data, node)` returns true, or `'unknown'` if none match. */
+    classify(data: unknown, node?: RoutedNode): string;
+    /** Lookup a kind entry by name. */
+    get(name: string): NodeRoutingEntry | undefined;
+    /** 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;
 
 /**
  * A camera: held in a ref when uncontrolled, taken from the `view` option when
@@ -5999,6 +6308,11 @@ interface CanvasRetainOptions {
     /** GPU memory, in bytes, retained layers may hold together:
      *  `WeaselRendererOptions.retainBudget`. 0 retains nothing. */
     budget?: number;
+    /** Round the view's translation to whole device pixels while it moves, so
+     *  a retained layer is composited moved rather than drawn again; it draws
+     *  exactly once the view holds. Drawn and hit positions then differ by up
+     *  to half a device pixel while the view moves. Default `true`. */
+    whole?: boolean;
 }
 /**
  * Props for `<Canvas>`. Canvas is scene-agnostic: it owns the GL surface, view state, hover
@@ -6421,10 +6735,16 @@ declare const DRAW_TOOLS: ToolSet<BuiltinToolId>;
 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. */
+/** The built-in tool sets in palette order: selection, then navigation, then the tools that make
+ *  things. Each set is named for the presentation group its tools sit in. */
+declare const BUILTIN_TOOL_GROUPS: readonly ToolSet<BuiltinToolId>[];
+/** The natural order of palette groups, which `ToolPalette` follows unless given its own. */
+declare const TOOL_GROUP_ORDER: readonly string[];
+/** Every built-in tool, in palette order: {@link BUILTIN_TOOL_GROUPS} one after another, then any
+ *  shape kind in no family. */
 declare const BUILTIN_TOOLS: ToolSet<BuiltinToolId>;
-/** Every built-in tool id, in palette order: {@link BUILTIN_TOOLS} opened. */
+/** Every built-in tool id, in palette order: {@link BUILTIN_TOOLS} opened. A palette orders the
+ *  tools within each group by it. */
 declare const BUILTIN_TOOL_IDS: readonly BuiltinToolId[];
 
 /** Default size in CSS pixels for selection corner-handles AND their
@@ -6438,8 +6758,8 @@ interface SceneCanvasLongPress {
      * Default: a ring that fills around the press point
      * (`createLongPressFeedbackContribution()`), static under
      * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces
-     * it, reading the `longPress` dep. Installed beside `ambient`, so under a
-     * `tools` takeover add it to your own `useTools` call instead.
+     * it, reading the `longPress` dep. Installed beside `ambient` and beside a `tools`
+     * takeover, unless the takeover's ambient holds an entry of the same id.
      */
     feedback?: boolean | SurfaceContribution;
     /** Default true. A long-press some binding handled pulses
@@ -6495,9 +6815,9 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     poseTransition?: PoseTransitionSeat<TPose> | null;
     /**
      * Lets pose-transform actions (move, resize, nudge, flip — NOT rotate) also rewrite a
-     * node's data-held geometry. Given a node and the affine `m` applied to its pose,
-     * `transform(node, m)` returns updated `data`, or `null` for nodes with no data-held
-     * geometry. When absent, the kit emits only the pose op and leaves `data` untouched.
+     * node's data-held geometry: `transform(node, m, change)` returns updated `data`, or
+     * `null` for nodes with no data-held geometry. When absent, the kit emits only the pose
+     * op and leaves `data` untouched.
      *
      * @see GeometryProjection
      */
@@ -6530,7 +6850,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
          *  the live alt state + current selection so consumers can implement
          *  alt-cycling through an overlapping stack. Default: top-most hit
          *  (alt ignored). */
-        pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;
+        pickBest?: (world: _weasel_js_routing.WorldPoint, alt: boolean, sel: readonly string[]) => string | null;
     };
     /** Consumer node factories for the `insert` action, keyed by tool `kind`.
      *  Each factory receives the drag AABB + tool `extras` and returns the
@@ -6547,9 +6867,9 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     insertPaint?: InsertPaint;
     /** External-content ingestion (OS drop / clipboard paste / picker).
      *
-     *  - `handlers` — consumer content handlers registered for this canvas's
-     *    lifetime (priority 0 by default — they beat the kit's `image/*` /
-     *    `image/svg+xml` handlers at -100/-90).
+     *  - `handlers` — content handlers for this canvas alone, priority 0 by default, above
+     *    the kit's. One for every canvas on the page goes through `registerContentHandler`.
+     *  - `kitHandlers` — which kit handlers it keeps (`KitHandlersOption`); default all.
      *  - `resolveSrc` — overrides the image handler's `data:`-URI embed (e.g.
      *    upload to an asset store, return the URL).
      *  - `svg.unpack` — makes the kit SVG handler parse dropped SVG files into
@@ -6561,10 +6881,10 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      *    rather than letting them fall through. Also governs Cmd/Ctrl+V under
      *    the `edit` preset; the rest takes the `ingest` preset.
      *
-     *  Memoize `handlers` and `clipboard.reviver`: an inline array literal
-     *  re-registers the handlers on every render. */
+     *  Memoize `handlers` and `clipboard.reviver`: inline literals rebuild them every render. */
     ingestion?: {
         handlers?: ContentHandlerEntry[];
+        kitHandlers?: KitHandlersOption;
         resolveSrc?: (file: File) => Promise<string>;
         svg?: SvgIngestOptions;
         clipboard?: {
@@ -6829,34 +7149,31 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      * nor picked here. See `CanvasProps.layerOrder`.
      */
     layerOrder?: string[];
-} & SceneCanvasPointerProps & SceneCanvasActionProps;
+} & SceneCanvasPointerProps<TData> & SceneCanvasActionProps;
 
 /**
  * The behavior presets `<SceneCanvas features>` composes. A bare canvas renders
- * its scene and keeps a selection nothing sets; every behavior beyond that is
- * turned on by a preset.
+ * its scene, keeps a selection nothing sets, and undoes and redoes whatever
+ * changed it; every behavior beyond that is turned on by a preset.
  *
  * A preset is a {@link FeaturePreset} object: the actions, tools, bindings,
- * chrome, and contributions one behavior brings. Core's own are named
- * (`'select'`, `'draw'`) and live in `namedPresets.ts`; a package ships its
- * own the same way and an app passes the object. Nothing here imports an
- * action, so a canvas reaches only the presets it is handed.
- *
- * A preset is not one of the `packages/core/src/features/<name>/` source
+ * chrome, and contributions one behavior brings, and the presets it includes.
+ * One that holds only actions, tools, and includes is a bundle, pure grouping;
+ * one with any other role is an atom, whose parts only work together. Core's
+ * own are named (`'select'`, `'draw'`) and live in `namedPresets.ts`; a
+ * package ships its own the same way and an app passes the object. Nothing
+ * here imports an action, so a canvas reaches only the presets it is handed.
+ *
+ * A preset is not one of the `packages/core/src/domains/<name>/` source
  * directories that `docs/taxonomy.md` calls a feature; the two share a word
  * and nothing else.
  */
 
-/** A core preset that names one behavior and abbreviates nothing. */
-type BaseFeature = 'view' | 'select' | 'outline' | 'move' | 'resize' | 'rotate' | 'edit' | 'arrange' | 'paths' | 'ingest';
-/** A core preset that abbreviates others: `pick` is `select` + `outline`,
- *  `transform` is `resize` + `rotate`, and `draw` is every base preset. */
-type CompositeFeature = 'pick' | 'transform' | 'draw';
+/** Every core preset's name `<SceneCanvas features>` accepts, each after the
+ *  presets it includes. */
+declare const SCENE_CANVAS_FEATURES: readonly ["tools:select", "tools:view", "tools:shape", "tools:draw", "tools:type", "tools:page", "view", "select", "outline", "pick", "move", "resize", "rotate", "transform", "escape", "contextMenu", "selectAll", "duplicate", "delete", "group", "nudge", "style", "clipboard", "edit", "flip", "reorder", "align", "distribute", "arrange", "anchorKeys", "pathfinder", "outlines", "pathEdit", "pathCommands", "paths", "ingest", "draw"];
 /** A core preset's name, as `<SceneCanvas features>` takes it. */
-type Feature = BaseFeature | CompositeFeature;
-/** Every name `<SceneCanvas features>` accepts, each composite after the
- *  presets it names. */
-declare const SCENE_CANVAS_FEATURES: readonly Feature[];
+type Feature = (typeof SCENE_CANVAS_FEATURES)[number];
 /** What a preset's ambient bindings are built from: the `selectTool` options
  *  that configure them. */
 interface FeatureBindingOptions {
@@ -6870,6 +7187,8 @@ interface FeatureBindingOptions {
  * passes it to `features`, and an app that does not never loads its code.
  */
 interface FeaturePreset {
+    /** What a person calls it, where one is listed. Absent, the id. */
+    readonly label?: string;
     /** Unique per canvas. `refines` names presets by it, and two different
      *  presets with one id on one canvas throw. */
     readonly id: string;
@@ -6889,6 +7208,10 @@ interface FeaturePreset {
     /** Snap sources every snap session on the canvas asks, after
      *  `<SceneCanvas snap.sources>` and the presets before it. */
     readonly snapSources?: readonly SnapSource[];
+    /** Layers it adds to the render stack, by slot, as `<SceneCanvas layers>`
+     *  takes them: `grid` fills the grid slot, any other key adds a layer. A
+     *  slot `<SceneCanvas layers>` names, `null` included, keeps the consumer's. */
+    readonly layers?: Readonly<Record<string, CustomLayerEntry>>;
     /** The selection chrome that is drawn, and can be grabbed, only while it is on. */
     readonly chrome?: readonly ChromeId[];
     /** Default chrome-caps rules for chrome of its own, under the consumer's
@@ -6901,25 +7224,25 @@ interface FeaturePreset {
      *  declare: deps, overlays, `attach`, views, frame hooks. A `tools` takeover
      *  brings its own ambient and leaves them out. */
     readonly contributions?: readonly SurfaceContribution[];
-    /** Ids of presets whose actions this one's register ahead of, so that where
-     *  both bind one gesture, this one's is tried first: anchor nudging ahead of
-     *  node nudging. A preset named here that is not on is ignored. */
+    /** Ids of presets whose actions, and those of every preset they include,
+     *  this one's register ahead of, so that where both bind one gesture, this
+     *  one's is tried first: anchor nudging ahead of node nudging. A preset named
+     *  here that is not on is ignored. */
     readonly refines?: readonly string[];
     /** Presets it turns on with itself, ahead of its own place in the order. */
     readonly includes?: readonly FeaturePreset[];
 }
 /** What `<SceneCanvas features>` takes: a core preset's name or any preset. */
 type FeatureEntry = Feature | FeaturePreset;
-/** The names a canvas resolves: one preset each, or the presets a composite
- *  abbreviates. */
-interface NamedPresets {
-    readonly base: Readonly<Record<BaseFeature, FeaturePreset>>;
-    readonly composite: Readonly<Record<CompositeFeature, readonly BaseFeature[]>>;
-}
+/** The names a canvas resolves, each to its preset. */
+type NamedPresets = Readonly<Record<string, FeaturePreset>>;
 /** Where a canvas finds presets beyond the objects it is handed: the names it
  *  resolves, if any, and the actions it registers once a tool binds them. */
 interface PresetSource {
     readonly named: NamedPresets | null;
+    /** Actions every canvas registers whatever its presets: undo and redo, since anything that changes
+     *  the scene — a preset's action, a tool, the host — leaves history to step through. */
+    readonly baseline?: readonly Action[];
     /** Actions registered only when a tool or contribution binds them. */
     readonly pool: readonly Action[];
 }
@@ -7143,10 +7466,10 @@ interface PickHudProps {
      *  passes that conversion, so the readout agrees with the picks. */
     toWorld?: (clientX: number, clientY: number) => [number, number];
     /** World-space hit-test. Same shape as `useSelectTool`'s `pickEvery`. */
-    pickEvery: (worldX: number, worldY: number) => readonly string[];
+    pickEvery: (world: WorldPoint) => readonly string[];
     /** Optional single-best resolver — the id this point would select on a
      *  bare click. When supplied, that id is rendered bold in the list. */
-    pickBest?: (worldX: number, worldY: number) => string | null;
+    pickBest?: (world: WorldPoint) => string | null;
     /** Inset from the canvas's top-right corner. Default `{ top: 76, right: 8 }`
      *  so the HUD clears `CursorCoordsHud` (~64 px tall in its 3-line form). */
     offset?: {
@@ -7239,6 +7562,10 @@ type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node<
     /** Present only when a composing strategy is configured; the render
      *  walk feature-detects it. */
     composePose?(parent: TPose, child: TPose): TPose;
+    /** The frame a container gives its children, scrolled by the scene's
+     *  `scroll` offset — see `PoseAdapter.childFrame`. Present only when the
+     *  composition can scroll. */
+    childFrame?(id: string, world: TPose): TPose;
     getSelection(): string[];
     setSelection(ids: string[]): void;
     insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;
@@ -7290,13 +7617,8 @@ interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
 }
 /** Derive the adapter for a scene. Reads go straight to the scene; writes are
  *  ops applied through its history, so anything done through the adapter is
- *  undoable.
- *
- *  Moving a container carries its contents either way the scene composes
- *  poses. Under a frame (`scene.composition`) the one pose written moves them.
- *  Under the absolute-pose model `setPose` on a container translates every
- *  descendant by the same delta, and a batch that poses descendants too undoes
- *  exactly only when it goes through this adapter's `applyOps`. */
+ *  undoable. A container's pose is a frame its children are stored in, so the
+ *  one pose written moves its contents. */
 declare function sceneToAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
 
 /**
@@ -7308,6 +7630,8 @@ declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Sce
 /** Routes a group node as `'group'`, whatever its data holds. `inferredNodeRouting` leads
  *  with it; spread it ahead of `defaultNodeRouting`, which is the shape-kind table alone. */
 declare const groupNodeRouting: NodeRoutingEntry;
+/** Routes a boolean group (`booleanGroupFields`) as `'boolean'`: its data holds no path of its own. */
+declare const booleanGroupRouting: NodeRoutingEntry;
 /**
  * Routing classifiers for the kit's built-in shape kinds
  * (`KIT_SHAPE_KINDS`): each entry matches `data.kind === '<name>'`. Routing
@@ -7334,9 +7658,10 @@ declare const inferredNodeRouting: readonly NodeRoutingEntry[];
  *
  * `schema` is a `PrefSection`, not the `PrefGroup` a preferences schema
  * is: a leaf's own key is its whole dotted node path (`pose.x`,
- * `data.fill`, `data.style.fontSize`), rooted at `pose` or `data`. The
- * sections it nests are headings only; their keys do not contribute to
- * the node path.
+ * `data.fill`, `data.style.fontSize`), rooted at `pose` or `data`, or a
+ * field the node declares for its children (`clip`, `units.unit`), which a
+ * panel writes through `scene.setClip` / `scene.setUnits`. The sections it
+ * nests are headings only; their keys do not contribute to the node path.
  *
  * Kind names share the routing trait's vocabulary — an entry registered
  * as `'rect'` describes nodes `NodeRouting.classify` maps to `'rect'`.
@@ -7417,8 +7742,10 @@ interface PreviewNode<TData, TLayer extends string, TPose> {
     id: NodeId;
     /** The node as committed. */
     node: Node<TData, TLayer, TPose>;
-    /** The pose a source previews, else the node's effective pose — where the
-     *  scene's overrides put it mid-transform. */
+    /** Where the node draws, in world: the pose a source previews, else its
+     *  effective pose — where the scene's overrides put it mid-transform —
+     *  folded through every container's frame, previewed or not, and scrolled
+     *  as the view scrolls it. */
     pose: TPose;
     /** The interim data, or the committed one when only the pose is in flight. */
     data: TData;
@@ -7427,13 +7754,17 @@ interface PreviewNode<TData, TLayer extends string, TPose> {
      * reflowing into its destination slot. It reads better painted settled.
      */
     opaque: boolean;
-    /** Previewed descendants, so a container's ghost brings its children. */
+    /** Previewed descendants, and those a previewed frame carries, so a
+     *  container's ghost brings its children. */
     children: PreviewNode<TData, TLayer, TPose>[];
 }
 /**
  * The previewing subtrees, as roots. A previewed node whose parent is also
  * previewing is a child of that parent's entry rather than a root of its own,
  * which is what lets a caller draw a container and its contents as one thing.
+ * A previewed container whose pose is a frame brings every child it carries,
+ * previewed or not. A source previews a pose in the frame the node is stored
+ * in; each entry's pose is in world.
  *
  * An id with no node is skipped: an insert previews before the node it will
  * create exists.
@@ -7473,10 +7804,6 @@ declare function publishPreviews<TData, TLayer extends string, TPose>(scene: Sce
  * start produces a zero-area drag rect around a trail that swept the page.
  */
 
-type Point$2 = {
-    x: number;
-    y: number;
-};
 /** The fields of an `insertPreview` overlay this needs. `canvas/deps/insert`
  *  passes the equivalent from its own `(bounds, extras)` commit arguments. */
 interface InsertPreviewLike {
@@ -7494,24 +7821,24 @@ type InsertPreviewGeometry = {
     kind: 'box';
 } | {
     kind: 'line';
-    a: Point$2;
-    b: Point$2;
+    a: Point;
+    b: Point;
 } | {
     kind: 'polygon';
-    center: Point$2;
+    center: Point;
     radius: number;
     sides: number;
     rotation: number;
 } | {
     kind: 'star';
-    center: Point$2;
+    center: Point;
     outerRadius: number;
     innerRadius: number;
     points: number;
     rotation: number;
 } | {
     kind: 'pencil';
-    samples: ReadonlyArray<Point$2>;
+    samples: ReadonlyArray<Point>;
 };
 /** An in-flight insert's shape, resolved from its drag rect and `extras`. */
 interface InsertPreviewExtent {
@@ -7542,17 +7869,13 @@ declare function insertPreviewExtent(ov: InsertPreviewLike): InsertPreviewExtent
  * `DrawCommand`, no style, no React, no dispatcher. World coordinates only.
  */
 
-type Point$1 = {
-    x: number;
-    y: number;
-};
 /**
  * The chrome-caps id a surface consults before painting each variant. The
  * gating itself is the painter's — two views of one surface may disagree about
  * whether to show an in-flight marquee — but the id is not something a caller
  * should have to guess.
  */
-type OverlayVisibilityId = 'action.marquee' | 'action.lasso' | 'action.insert-preview' | 'action.polyline' | 'action.brush';
+type OverlayVisibilityId = 'action.marquee' | 'action.lasso' | 'action.insert-preview' | 'action.polyline' | 'action.brush' | 'action.reason';
 /**
  * One in-flight overlay, in world coordinates.
  *
@@ -7573,9 +7896,9 @@ type ResolvedOverlay = {
     visibilityId: 'action.lasso';
     /** The trail so far, at least two long. The region it encloses is the
      *  trail closed back to its first vertex. */
-    vertices: ReadonlyArray<Point$1>;
+    vertices: ReadonlyArray<Point>;
     /** Live pointer position — the trail's last vertex until it advances. */
-    current: Point$1;
+    current: Point;
     shiftHeld: boolean;
 } | {
     kind: 'insertPreview';
@@ -7587,7 +7910,7 @@ type ResolvedOverlay = {
     geometry: InsertPreviewGeometry;
     /** The drag's anchor — a growth axis to mark. Absent for a pencil, which
      *  has none. */
-    anchorPoint?: Point$1;
+    anchorPoint?: Point;
     /** World affines the shape will also be drawn under, as the action gave them. */
     copies?: readonly (readonly [number, number, number, number, number, number])[];
     /** The action's per-shape payload, verbatim. Carries what geometry
@@ -7598,7 +7921,7 @@ type ResolvedOverlay = {
     visibilityId: 'action.polyline';
     /** The run, at least two long, open — the last point does not join the
      *  first. A closed sweep is a `lasso`. */
-    points: ReadonlyArray<Point$1>;
+    points: ReadonlyArray<Point>;
     /** What the run is, for a painter choosing a style. Never defaulted
      *  away: `'chrome'` when the action named none. A role the painter has
      *  no style for is drawn as plain chrome, not dropped. */
@@ -7607,9 +7930,15 @@ type ResolvedOverlay = {
     kind: 'brush';
     visibilityId: 'action.brush';
     /** The brush's path, at least one point; the last is where it is now. */
-    points: ReadonlyArray<Point$1>;
+    points: ReadonlyArray<Point>;
     /** On screen: a painter draws it at this size at every zoom. */
     radiusPx: number;
+} | {
+    kind: 'reason';
+    visibilityId: 'action.reason';
+    /** The pointer, which a painter shows `text` beside. */
+    at: Point;
+    text: string;
 };
 /** The overlays worth painting, in the order the handles published them. */
 declare function resolveOverlays(overlays: Iterable<OngoingOverlay>): ResolvedOverlay[];
@@ -7839,7 +8168,7 @@ declare function useDevtoolsLabel(): string | null;
  */
 declare function createEnteredGroupScope(opts: {
     entered: EnteredGroupApi;
-    scene: Pick<Scene<unknown, string, unknown>, 'ancestorsOf'>;
+    scene: Pick<Scene<unknown, string, unknown>, 'ancestorsOf' | 'get'>;
     /** Alpha for a node outside the entered group. Default `OUT_OF_SCOPE_ALPHA`. */
     dimAlpha?: number;
 }): NodeScope;
@@ -8109,160 +8438,6 @@ interface CreateTextLayerOpts<T> {
 /** Build a `RenderLayer` that emits one `TextDrawCommand` per text node. */
 declare function createTextLayer<T>(opts: CreateTextLayerOpts<T>): RenderLayer<unknown>;
 
-/** A scene `drawOne` that leaves out one node's glyphs. */
-type EditingDrawOne = <TNode extends Node<unknown, string, unknown>>(node: TNode, pose: unknown, view?: View, ctx?: NodePaintCtx) => DrawCommand[];
-
-/**
- * Union math over rect-shaped poses.
- *
- * Two answers, deliberately distinct. `unionBounds` folds the *unrotated*
- * boxes and is what commit-time actions want, because they go on to write
- * poses back in that same frame. `unionAABB` expands each rotated member to
- * the extent of its ink first, and is what anything a user looks at or clicks
- * wants — selection chrome, gesture bounds, an export viewBox. Folding the
- * unrotated box there under-reports the extent of a rotated member exactly
- * when the consumer is watching it move.
- */
-
-/** Compute the AABB envelope of a set of rect-shaped poses, ignoring any
- *  rotation they carry. See the module docstring before reaching for this
- *  over {@link unionAABB}. */
-declare function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): RectPose | null;
-/**
- * Axis-align a pose that carries a `rotation` or a `transform`: returns the
- * AABB of the box as drawn, its four corners through `poseFrameOf`, with both
- * fields dropped.
- *
- * A pose with neither is returned as-is.
- */
-declare function axisAlignedBounds<TPose extends RectPose>(b: TPose): RectPose;
-/**
- * Fold every part into one world-space AABB, skipping `null` / `undefined`
- * entries. Rotated parts are expanded via {@link axisAlignedBounds} first;
- * the result never carries a `rotation` (a union of several oriented boxes
- * has no single orientation to report).
- *
- * Returns `null` when nothing was contributed.
- */
-declare function unionAABB<TPose extends RectPose>(parts: Iterable<TPose | null | undefined>): RectPose | null;
-
-/**
- * `useSceneTextEdit` — scene-aware wrapper around `useTextEdit`: scene
- * lookups for text / style / runs / screen-pose, and
- * `scene.update(id, { data })` for commits. The overlay and a double-click
- * both read the pose a node is painted at, so text inside a container whose
- * pose is a frame is edited where it is drawn.
- *
- * Defaults assume the node's `data` carries `text` / `style` / `runs`
- * directly. For custom data shapes, override any of the optional projections.
- * Consumers with non-rect poses should drop down to raw `useTextEdit` and
- * supply their own `getScreenPose`.
- */
-
-/** Shape the default projections expect `data` to satisfy. All fields
- *  optional so any object satisfies the constraint — projections fill in
- *  the gaps for non-default shapes. */
-interface DefaultTextData {
-    text?: string;
-    style?: TextStyle;
-    runs?: readonly StyledRun[];
-    fill?: Fill | Inherit | null;
-    stroke?: Stroke | Inherit | null;
-    verticalAlign?: TextVerticalAlign;
-    padding?: number;
-    overflow?: TextOverflow;
-}
-/** All-optional projections + fontSize fallback. */
-interface UseSceneTextEditOptions<TData> {
-    /**
-     * Is this node text? A double-click opens an edit only on a node that
-     * answers yes, and passes through any other to the text under it. Default:
-     * `isTextData`, the test `inferredNodeRouting` classifies a text node by. Pass one when `getText` reads some other shape.
-     */
-    isText?: (data: TData) => boolean;
-    /** Read plain text from `data`. Default: `data.text ?? ''`. */
-    getText?: (data: TData) => string;
-    /** Read style from `data`. Default: `data.style`. */
-    getStyle?: (data: TData) => TextStyle | undefined;
-    /** Read the node's paint from `data`. Default: `data.fill` / `data.stroke`. */
-    getPaint?: (data: TData) => TextPaint | undefined;
-    /** Read rich-text runs from `data`. Default: `data.runs`. */
-    getRuns?: (data: TData) => readonly StyledRun[] | undefined;
-    /** Read the box vertical alignment from `data`. Default: `data.verticalAlign`. */
-    getVerticalAlign?: (data: TData) => TextVerticalAlign | undefined;
-    /** Read the inset from the node's box to its text from `data`. Default: `data.padding`. */
-    getPadding?: (data: TData) => number | undefined;
-    /** Read whether the node cuts its text at its box from `data`, which the
-     *  overlay then does too. Default: `data.overflow`. */
-    getOverflow?: (data: TData) => TextOverflow | undefined;
-    /** Produce updated data with new text. Default: `{ ...data, text }`. */
-    setText?: (data: TData, text: string) => TData;
-    /** Produce updated data with new runs. Default: `{ ...data, runs }`. */
-    setRuns?: (data: TData, runs: StyledRun[]) => TData;
-    /**
-     * Produce updated data with a new node-wide style. Default:
-     * `{ ...data, style }`. Written only when a range toggle has to *clear* a
-     * flag the node itself sets — the run algebra is additive, so that edit
-     * lowers the node flag and raises it on the runs outside the range. See
-     * `useTextEdit`'s `setStyle`.
-     *
-     * An edit's text, runs, and style are folded through these three and
-     * written as one `scene.update`, so a commit is one undo step.
-     */
-    setStyle?: (data: TData, style: TextStyle) => TData;
-    /** Fallback fontSize when `style.fontSize` is unset. Default `16`. */
-    defaultFontSize?: number;
-    /**
-     * The view to project through. Omit it and the view is read live from the
-     * weasel canvas mounted inside `container` (the one a double-click landed
-     * on, when there are several). With no canvas there, the node's world box
-     * is passed through as screen pixels.
-     *
-     * A thunk is re-read on every projection; a plain `View` is the value from
-     * the render that supplied it.
-     */
-    view?: View | (() => View);
-    /**
-     * Forwarded to `useTextEdit`: is `el` part of the editor's own chrome?
-     * Focus moving into it does not end the edit. Wire it to whatever renders
-     * the character controls.
-     */
-    isEditorChrome?: (el: Element) => boolean;
-    /** Forwarded to `useTextEdit`: what Escape does to the edit. */
-    escape?: 'cancel' | 'commit';
-    /** Forwarded to `useTextEdit`: how long an edit waits for its face. */
-    fontHold?: number;
-    /** Forwarded to `useTextEdit`: called as an edit of the node `id` opens,
-     *  whichever way it was started. */
-    onStart?: (id: string) => void;
-    /** Forwarded to `useTextEdit`: called as the edit of `id` closes, after
-     *  any commit has been written to the scene. */
-    onEnd?: (id: string) => void;
-}
-/** Return shape extends `UseTextEditReturn` with an `onDoubleClick`
- *  binding for the canvas container. Double-clicking inside a text
- *  node enters edit mode with the caret seeded at the clicked glyph. */
-interface UseSceneTextEditReturn extends UseTextEditReturn {
-    /** Bind to the element wrapping `<SceneCanvas>` (the same element
-     *  passed as `container`, or any ancestor that receives the dblclick
-     *  bubble). Starts an edit on the top-most text node under the cursor. */
-    onDoubleClick: (e: MouseEvent<HTMLElement>) => void;
-    /** The `isText` option asked of the node with this id: what
-     *  `TextEditDep.isTextNode` wants, so both ways into an edit agree. */
-    isTextNode: (id: string) => boolean;
-    /**
-     * `defaultDrawOne`, less the glyphs of the node being edited: the overlay
-     * stands in for its text, and the rest of the node, a `background` among
-     * it, goes on painting. Pass it as `layers.scene.drawOne`, with
-     * `paintBounds: defaultPaintBounds`, in place of an `alphaFor` that hides
-     * the whole node.
-     */
-    drawOne: EditingDrawOne;
-}
-/** Wire double-click-to-edit text on a scene: mounts a DOM editing overlay
- *  over the node being edited and writes the result back as an undoable op. */
-declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends string, TPose extends RectPose = RectPose>(scene: Scene<TData, TLayer, TPose>, container: HTMLElement | null, options?: UseSceneTextEditOptions<TData>): UseSceneTextEditReturn;
-
 /** How Outline Stroke and a Boolean operation counting strokes measure one. */
 interface StrokeRegionOptions {
     /** The view scale a `{ px }` width resolves against: one number, or the
@@ -8325,9 +8500,9 @@ declare function useCreateOutlinesAdapter(adapter: CreateOutlinesAdapter): void;
  *  only round-trips the 6-char form, so call-sites pad the saved alpha back on
  *  when the user picks via the native widget. */
 /** Expand `#rgb` / `#rgba` / `#rrggbb` to `#rrggbbaa`. Pads `ff` when no alpha
- *  channel is present. Non-hex inputs (named colors, `rgba(...)`) are
- *  returned unchanged — the kit's renderer accepts arbitrary CSS, and
- *  we only normalize the hex shapes we actually persist. */
+ *  channel is present. Anything else — named colors, `rgba(...)`, a malformed
+ *  `#` value — is returned unchanged: the kit's renderer accepts arbitrary CSS,
+ *  and we only normalize the hex shapes we actually persist. */
 declare function toHex8(color: string): string;
 /** Return the alpha channel of `color` as 0..1. Defaults to 1 when the
  *  color is not in 8-char hex form. */
@@ -8789,12 +8964,18 @@ declare function registeredOpNames(): readonly string[];
  *  `getParent` returns the live parent at call time so mid-batch
  *  parent updates compose correctly. */
 declare function scenePoseAdapter(scene: Scene<unknown, string, unknown>): PoseAdapter<unknown>;
+/** `scenePoseAdapter` read as the view shows it: each scrolled container's
+ *  children moved by its offset. For a gesture, which reads the world it
+ *  writes back through the same fold, so what it stores is the content
+ *  position; the layout pass and other document writers use
+ *  `scenePoseAdapter`. */
+declare function sceneViewPoseAdapter(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.
+ * one, a page move. A descendant stored in a frame that moves rides it; one
+ * stored above it, under an envelope, stays behind unless it is written too.
  */
 
 /** What carrying reads: the tree, every stored pose, and how poses compose. */
@@ -8814,6 +8995,15 @@ declare function sceneCarrySource(scene: Scene<unknown, string, unknown>): Carry
  * 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>;
+/** The nodes whose stored pose is in `id`'s frame: its children, and through
+ *  a child that is an envelope, that child's own. */
+declare function heldInFrame(scene: {
+    childrenOf(id: NodeId): readonly NodeId[];
+    get(id: NodeId): {
+        dependsOn?: unknown;
+        derivePose?: unknown;
+    } | undefined;
+}, id: NodeId): NodeId[];
 
 /** @internal */
 interface HitAdapter<TNode extends {
@@ -8845,14 +9035,14 @@ interface NestedHitTester {
     /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a
      *  casual click selects the whole top-level ancestor. Returns `null` on
      *  empty space. */
-    pickOutermost: (worldX: number, worldY: number) => string | null;
+    pickOutermost: (world: WorldPoint) => string | null;
     /** Alt-aware selection-update pick. Without `alt`, returns the outermost
      *  ancestor (same as `pickOutermost`). With `alt`, returns one level
      *  deeper than the deepest currently-selected ancestor in the leaf's
      *  chain — repeated alt-clicks step ancestor → descendant → leaf. With
      *  `alt` and nothing in the chain selected, jumps straight to the leaf.
      *  Plug into `useSelectTool({ pickBest })`. */
-    pickBest: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
+    pickBest: (world: WorldPoint, alt: boolean, selection: readonly string[]) => string | null;
 }
 /** Build hit-testers that respect containers: a plain click selects the
  *  top-level ancestor, and alt-clicking descends one level at a time toward
@@ -8889,14 +9079,14 @@ declare function createScene<TData, TLayer extends string, TPose = RectPose>(opt
  *  registry passed in `options`. Throws on unknown version, unknown registry
  *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).
  *  The scene starts with empty history. */
-declare function sceneFromJSON<TData, TLayer extends string, TPose>(json: SerializedScene<TData, TLayer, TPose> | SerializedSceneV1<TData, TLayer, TPose>, options?: {
+declare function sceneFromJSON<TData, TLayer extends string, TPose>(json: SavedScene<TData, TLayer, TPose>, options?: {
     registry?: SceneRegistry<TPose, TData, TLayer>;
     historyLimit?: number;
     coalesceWindowMs?: number;
     generateId?: () => NodeId;
     ops?: Readonly<Record<string, RegisteredOp<unknown>>>;
-    composition?: UseSceneOptions<TData, TLayer, TPose>['composition'];
-    layoutFrame?: UseSceneOptions<TData, TLayer, TPose>['layoutFrame'];
+    composition?: SceneOptions<TData, TLayer, TPose>['composition'];
+    layoutFrame?: SceneOptions<TData, TLayer, TPose>['layoutFrame'];
 } & SpecsFromSerializedOptions<TData, TLayer, TPose>): Scene<TData, TLayer, TPose>;
 
 /**
@@ -8968,6 +9158,7 @@ interface StatedNodeFields {
     locked?: boolean;
     units?: UnitScope;
     clip?: NodeClip;
+    consumesChildren?: boolean;
 }
 /** The plain optional fields of a node or spec as a spread for `scene.add`:
  *  each present only when stated, so an unstated one keeps the scene's
@@ -8977,6 +9168,41 @@ declare const statedFields: (n: StatedNodeFields & {
     kind?: string;
 }) => StatedNodeFields;
 
+/**
+ * Reading a save from before a scene's poses composed by default. Versions 1
+ * and 2 stored every pose as world; version 3 stores a child's pose in the
+ * frame of the nearest container that defines one.
+ */
+
+/** What localizing reads of a node: where it sits, its pose, and whether it is a frame. */
+interface PlacedSpec<TPose> {
+    id?: NodeId | string;
+    parent?: NodeId | string | null;
+    pose: TPose;
+    dependsOn?: unknown;
+    derivePose?: unknown;
+}
+/**
+ * `specs`, whose every pose is world, with each pose made local to the frame
+ * it is stored in under `composition`: an old save as it loads, or a tree an
+ * importer measured in world. A child of a container whose pose derives from
+ * its children shares that container's frame, so it is rebased against the
+ * frame above it.
+ */
+declare function localizeWorldPoses<TPose, TSpec extends PlacedSpec<TPose>>(specs: readonly TSpec[], composition: PoseComposition<TPose>): TSpec[];
+/**
+ * Where each of `specs` draws: its pose folded through the frames above it
+ * under `composition`, by id. The inverse of {@link localizeWorldPoses}, for
+ * a reader of a spec list that is not in a scene yet.
+ */
+declare function worldPosesOf<TPose, TSpec extends PlacedSpec<TPose>>(specs: readonly TSpec[], composition: PoseComposition<TPose>): Map<string, TPose>;
+/**
+ * `specs`, whose every pose is world, as they are stored once added to
+ * `scene`: each made local to the frame it lands in, whether that frame is
+ * among `specs` or already in the scene.
+ */
+declare function localizeInScene<TPose, TSpec extends PlacedSpec<TPose>>(scene: Scene<unknown, string, TPose>, specs: readonly TSpec[]): TSpec[];
+
 /**
  * Build a {@link PoseOverrides} map.
  *
@@ -9208,6 +9434,33 @@ declare function unionOfChildren<TPose>(_node: unknown, deps: readonly ({
     pose: TPose;
 } | undefined)[]): TPose | null;
 
+/** The booleans that make one shape of their operands: the Pathfinder's four
+ *  shape modes, and what a boolean group can be set to. */
+type BooleanShapeOp = 'union' | 'intersect' | 'subtract' | 'exclude';
+
+/** A boolean group's path, from its children: see `booleanGroup.ts`. */
+
+/** Registry key for {@link booleanOfChildren}. */
+declare const BOOLEAN_OF_CHILDREN = "kit:booleanOfChildren";
+/** The operation a boolean group's `data.boolean` names; union when it names none. */
+declare function booleanOpOf(data: unknown): BooleanShapeOp;
+/**
+ * A boolean group's path: `data.boolean` over its children's outlines, back
+ * to front, so subtract takes everything in front from the backmost child. A
+ * group among them is one operand, the union of what it shows. A hidden child
+ * is no operand. `null` when no child has an outline, which draws nothing.
+ */
+declare function booleanOfChildren(node: {
+    data?: unknown;
+}, deps: readonly (DerivedDep<unknown> | undefined)[]): Path | null;
+
+/**
+ * The fields that make a node a boolean group, for `scene.add` beside its
+ * layer, pose, parent and `data`. Its children are added under it as usual;
+ * its pose follows theirs, so the one it is added with is a placeholder.
+ */
+declare function booleanGroupFields<TPose>(): Pick<AddNodeSpec<unknown, string, TPose>, 'kind' | 'consumesChildren' | 'dependsOn' | 'derivePath' | 'derivePose'>;
+
 /** The layer-record field the predicates below read. */
 interface AnnotationFlag {
     readonly id: string;
@@ -9295,7 +9548,7 @@ interface MeasureHit {
  * units of it, else a line within the same distance. A hidden or locked
  * measurement (`nodeGates`) is passed over.
  */
-declare function measureAt(scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes' | 'get' | 'layers' | 'overrides'>, ms: Pick<Measurements, 'layer'>, p: MeasurePoint, tolerance: number): MeasureHit | null;
+declare function measureAt(scene: Pick<Scene<unknown, string, unknown>, 'nodesOnLayer' | 'get' | 'layers' | 'overrides'>, ms: Pick<Measurements, 'layer'>, p: MeasurePoint, tolerance: number): MeasureHit | null;
 /** Options for `measureEndSource`. */
 interface MeasureEndSourceOptions {
     /** Overrides the canvas's reach for measurement ends, in screen px. */
@@ -9844,6 +10097,21 @@ interface EffectItem {
     middle: number;
     /** What it paints; empty for a piece that only takes room, such as a space. */
     parts: readonly DerivedPart[];
+    /** Rules it carries across its stretch — a text decoration cut to one cluster. A band that runs to the item's end
+     *  joins one alike in paint and depth that starts the next item, so the effect draws them as one ribbon bent along
+     *  the path rather than as rigid pieces. */
+    bands?: readonly EffectBand[];
+}
+/** A rule across part of an item, in the item's frame. */
+interface EffectBand {
+    /** Its ends along the item, 0..`length`. */
+    x0: number;
+    x1: number;
+    /** Its top and bottom edges, y down from the anchor line. */
+    y0: number;
+    y1: number;
+    fill: Fill | null;
+    stroke: Stroke | null;
 }
 /** A source shape. */
 interface EffectSource {
@@ -9914,7 +10182,8 @@ interface BlendEffect extends BlendPathsOptions, PathEffectOptions {
 
 /**
  * Text (or any shape) laid along a path, item by item. Its sources are `[text, path]`. Only the text's first laid line
- * follows the path; a color glyph keeps its advance and paints nothing; underlines and other decorations are not drawn.
+ * follows the path; a color glyph keeps its advance and paints nothing. An item's bands — underline, strikethrough and
+ * overline — join their alike neighbors' and bend with the path as one ribbon, while the glyphs stay rigid.
  * On an open path an item whose middle falls past either end is not drawn; on a closed one the text wraps past the
  * seam, and an item a whole lap on from the first item's start is not drawn.
  */
@@ -9941,7 +10210,8 @@ declare function textAlongParts(effect: TextAlongEffect, items: readonly EffectI
 /**
  * The path effects, each as the parts it paints from its sources: a blend's
  * steps between two shapes, a shape bent along a spine, copies of a shape
- * along a path, text laid along a path.
+ * along a path, text laid along a path, and one shape roughened, zigzagged,
+ * or puckered and bloated.
  */
 
 /** A shape bent along a spine. Its sources are `[shape, spine]`. */
@@ -9952,8 +10222,21 @@ interface BendAlongEffect extends BendAlongPathOptions, PathEffectOptions {
 interface RepeatAlongEffect extends Omit<RepeatAlongPathOptions, 'flattenTolerance'>, PathEffectOptions {
     kind: 'repeatAlong';
 }
+/** A shape with every point of its outline moved at random. Its source is `[shape]`. */
+interface RoughenEffect extends RoughenPathOptions, PathEffectOptions {
+    kind: 'roughen';
+}
+/** A shape with its outline pushed alternately to either side. Its source is `[shape]`. */
+interface ZigzagEffect extends ZigzagPathOptions, PathEffectOptions {
+    kind: 'zigzag';
+}
+/** A shape with its anchors pulled toward its middle and its handles pushed
+ *  away, or the reverse. Its source is `[shape]`. */
+interface PuckerBloatEffect extends PuckerBloatPathOptions, PathEffectOptions {
+    kind: 'puckerBloat';
+}
 /** A path effect, as a node's `data.pathEffect` holds it. */
-type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect | TextAlongEffect;
+type PathEffect = BlendEffect | BendAlongEffect | RepeatAlongEffect | TextAlongEffect | RoughenEffect | ZigzagEffect | PuckerBloatEffect;
 
 /**
  * A path effect as a scene node: a leaf whose `dependsOn` names its sources,
@@ -10163,6 +10446,29 @@ declare function commitBooleanPieces(adapter: BooleansAdapter, operands: Boolean
  *  that should count strokes as they do. */
 declare const PATHFINDER_STROKES: BooleanStrokes;
 
+/** The Pathfinder keymap's id; its leader action is `keymap.pathfinder`. */
+declare const PATHFINDER_KEYMAP_ID = "pathfinder";
+/** Alt+P, by the physical key too, since with Alt held on a Mac it types `π`. */
+declare const PATHFINDER_LEADER: KeySpec;
+/**
+ * The Pathfinder operations on held keys, behind the leader Alt+P: holding
+ * an operation's key previews it on the selection, releasing runs it, and
+ * Escape while it is held cancels it. Each binding's id is its hold's action
+ * id (`pathfinder.union.hold`), which is what a host rebinds it by. The
+ * operations themselves come from the `paths` preset; this carries only their
+ * holds. Install it with `<SceneCanvas ambient>`.
+ */
+declare const PATHFINDER_KEYMAP: readonly Contribution$1<never>[];
+
+type AnyScene$1 = Scene<unknown, string, unknown>;
+/**
+ * Put `ids` under a new boolean group of `op`, in the frontmost one's place, as
+ * one undo entry; nothing moves on screen. The group wears the frontmost
+ * operand's `fill` and `stroke`. Returns its id, or `null` when fewer than two
+ * of `ids` are nodes on one layer.
+ */
+declare function makeBooleanGroup(scene: AnyScene$1, ids: readonly string[], op?: BooleanShapeOp): NodeId | null;
+
 /** Default world-space distance from the rect's top edge to the rotation
  *  handle's center. Matches the demo's visual default; consumers can
  *  override per-call. Unscaled — kit-internal use sites multiply by
@@ -10195,10 +10501,7 @@ declare function rotationHandle(pose: {
 declare function hitRotationHandle(handle: Pick<RotationHandle, 'cx' | 'cy'>, px: number, py: number, radius: number): boolean;
 
 /** A point in world coordinates. */
-interface DragRectPoint {
-    x: number;
-    y: number;
-}
+type DragRectPoint = WorldPoint;
 /** The axis-aligned box between the drag's two corners, always with
  *  non-negative extents regardless of drag direction. */
 interface DragRectBounds {
@@ -10351,10 +10654,7 @@ declare function dragPointOf(event: {
 }, view?: ViewLike): DragGesturePoint;
 
 /** A point in world coordinates. */
-interface DragRadialPoint {
-    x: number;
-    y: number;
-}
+type DragRadialPoint = WorldPoint;
 /** A radial drag expressed as its center and the polar coordinates of the
  *  cursor relative to it. */
 interface DragRadialState {
@@ -10437,8 +10737,8 @@ interface PathAnchor {
  *  anchor: its control becomes the first anchor's `controlIn`, the way
  *  `pathToAnchors` reads it, so the two walkers count alike. */
 declare function enumerateAnchors(path: PolygonPath): PathAnchor[];
-/** Mutate `coords` in-place: write `(x, y)` at `coordIndex`, return a new
- *  PolygonPath sharing the same commands but with a fresh coords buffer. */
+/** A new PolygonPath sharing `path`'s commands, with the point at `coordIndex`
+ *  moved to `(x, y)` in the path's own space, in a fresh coords buffer. */
 declare function withCoord(path: PolygonPath, coordIndex: number, x: number, y: number): PolygonPath;
 
 /** Result of a hit-test against a path's anchors / control handles. */
@@ -10550,13 +10850,6 @@ interface PoseTargetScene<TPose> extends PoseSource<TPose> {
 /** How `like`'s kind of pose maps to axes: the descriptor's own mapping, else its flat numeric
  *  fields. Null for a pose with neither. */
 declare function poseAxes<TPose>(descriptor: PoseDescriptor<TPose> | undefined, like: TPose): TargetAxes<TPose> | null;
-/** How a container's pose target carries its descendants, for {@link scenePoseTarget}. */
-interface PoseCascade<TPose> {
-    /** Commits `pose` to the container, moving its descendants' poses with it. */
-    write(pose: TPose): void;
-    /** The descendants, each at the pose to show it at while the container shows at `pose`. */
-    beside(pose: TPose): Iterable<readonly [NodeId, TPose]>;
-}
 /**
  * A {@link Target} over one node's pose. Animations on it commit their destination through
  * `set` as they start, and the pose on screen reaches the paint and pick walks as a pose
@@ -10572,11 +10865,9 @@ declare function createPoseTarget<TPose>(opts: PoseTargetOptions<TPose>): Target
  * a caller that wants the move in history records its own op first.
  *
  * Undefined for a node that is not in the scene, or whose pose has no axes. `descriptor`
- * defaults to `RECT_POSE_DESCRIPTOR`. With `cascade`, for a container whose descendants hold
- * poses of their own, a commit goes through `cascade.write` and the descendants are shown
- * traveling beside the container. Both are read the first time a node's target is made.
+ * defaults to `RECT_POSE_DESCRIPTOR`, and is read the first time a node's target is made.
  */
-declare function scenePoseTarget<TPose>(scene: PoseTargetScene<TPose>, id: string, descriptor?: PoseDescriptor<TPose>, cascade?: PoseCascade<TPose>): Target<TPose> | undefined;
+declare function scenePoseTarget<TPose>(scene: PoseTargetScene<TPose>, id: string, descriptor?: PoseDescriptor<TPose>): Target<TPose> | undefined;
 
 /** What {@link createWrittenPoseTarget} takes. */
 interface WrittenPoseTargetOptions<TPose> {
@@ -10608,7 +10899,6 @@ interface SceneClipTargetsOptions<TPose> {
     }>>;
     /** As `scenePoseTarget` takes them. */
     descriptor?: PoseDescriptor<TPose>;
-    cascade?: PoseCascade<TPose>;
 }
 /**
  * A `ClipBinder.target` over a scene. `pose:<node id>` is that node's pose target, the one
@@ -11070,7 +11360,7 @@ interface UseRigNodeOptions<TPose> extends Pick<BindRigOptions<TPose>, 'apply' |
 declare function useRigNode<TPose>(options: UseRigNodeOptions<TPose>): Rig;
 
 /** A glyph this package draws, by its bare name. */
-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';
+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' | 'booleanGroup' | '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' | 'textAlignStart' | 'textAlignEnd' | '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' | 'paintInherit' | 'paintNone' | 'markerNone' | 'markerArrow' | 'markerArrowOpen' | 'markerArrowConcave' | 'markerTriangleHollow' | 'markerDiamond' | 'markerDiamondHollow' | 'markerCircle' | 'markerSquare' | 'markerBar' | 'markerDot' | 'markerCrowOne' | 'markerCrowMany' | 'markerCrowZeroOne' | 'markerCrowOneMany' | 'markerCrowZeroMany';
 declare module '@weasel-js/icons' {
     interface IconName {
         'core:arrow': true;
@@ -11123,6 +11413,7 @@ declare module '@weasel-js/icons' {
         'core:divide': true;
         'core:crop': true;
         'core:trim': true;
+        'core:booleanGroup': true;
         'core:merge': true;
         'core:join': true;
         'core:bridge': true;
@@ -11154,6 +11445,8 @@ declare module '@weasel-js/icons' {
         'core:textAlignCenter': true;
         'core:textAlignRight': true;
         'core:textAlignJustify': true;
+        'core:textAlignStart': true;
+        'core:textAlignEnd': true;
         'core:textAlignTop': true;
         'core:textAlignMiddle': true;
         'core:textAlignBottom': true;
@@ -11180,7 +11473,24 @@ declare module '@weasel-js/icons' {
         'core:paintConic': true;
         'core:paintMesh': true;
         'core:paintPattern': true;
+        'core:paintInherit': true;
         'core:paintNone': true;
+        'core:markerNone': true;
+        'core:markerArrow': true;
+        'core:markerArrowOpen': true;
+        'core:markerArrowConcave': true;
+        'core:markerTriangleHollow': true;
+        'core:markerDiamond': true;
+        'core:markerDiamondHollow': true;
+        'core:markerCircle': true;
+        'core:markerSquare': true;
+        'core:markerBar': true;
+        'core:markerDot': true;
+        'core:markerCrowOne': true;
+        'core:markerCrowMany': true;
+        'core:markerCrowZeroOne': true;
+        'core:markerCrowOneMany': true;
+        'core:markerCrowZeroMany': true;
     }
 }
 
@@ -11201,27 +11511,59 @@ declare const PAINTED_CURSOR_LAYER_ID = "painted-cursor";
  */
 declare function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown>;
 
+/** One preset as data: what it holds by id, for a tool that lists or rearranges presets. */
+interface PresetDescription {
+    id: string;
+    label: string;
+    /** The package that ships it, as `describePresets` was told. */
+    package: string;
+    /** It has a role beyond actions, built-in tools, and includes, so its parts only work together. */
+    atom: boolean;
+    /** Its own action ids, in registration order. */
+    actions: readonly string[];
+    /** Its own tools' ids: built-ins with their sets opened, then tools of its own. */
+    tools: readonly string[];
+    /** The ids of the presets it includes. */
+    includes: readonly string[];
+}
+/** Whether `preset` is an atom: it holds a role beyond actions, built-in tools, and includes. */
+declare function isAtom(preset: FeaturePreset): boolean;
+/**
+ * Every preset reachable from `sources` (keyed by the package that ships them), its includes followed, once each,
+ * each after the presets it includes. A preset reached from two packages is the first's.
+ */
+declare function describePresets(sources: Readonly<Record<string, readonly FeaturePreset[]>>): PresetDescription[];
+
 /**
  * Core's presets by name: what `features={['draw']}` resolves through.
  * Importing this module loads every core preset's actions; a canvas handed
  * only preset objects never reaches it.
  */
 
-/** The base presets each composite preset turns on. */
-declare const COMPOSITE_FEATURES: Readonly<Record<CompositeFeature, readonly BaseFeature[]>>;
-/** The kit-standard action ids each preset registers. */
-declare const FEATURE_ACTION_IDS: Readonly<Record<BaseFeature, readonly string[]>>;
+/** Each core preset by name, in the order `SCENE_CANVAS_FEATURES` lists them. */
+declare const FEATURE_PRESETS: Readonly<Record<Feature, FeaturePreset>>;
+/** The kit-standard action ids each preset registers itself, leaving out those of the presets it includes. */
+declare const FEATURE_ACTION_IDS: Readonly<Record<Feature, readonly string[]>>;
 /**
  * Kit-standard actions no preset registers: they belong to the tools that bind
  * them. A canvas registers each one whenever a tool it carries names it in a
  * binding — `insert` with any shape tool, `enterTextEdit` with the text tool.
  */
 declare const TOOL_DRIVEN_ACTION_IDS: readonly string[];
+/** The kit-standard actions every canvas registers, preset or none: undo and redo. */
+declare const BASELINE_ACTION_IDS: readonly string[];
+
+/** Undo and redo, which every canvas registers whatever its presets. */
+declare const BASELINE_ACTIONS: readonly [_weasel_js_routing.Action & {
+    requires: string[];
+}, _weasel_js_routing.Action & {
+    requires: string[];
+}];
 
 /** Pan and zoom: the hand tool, drag-pan, and pinch. */
 declare const viewPreset: FeaturePreset;
 
-/** The select tool: click, marquee, lasso, and clearing on an empty click. */
+/** The select and lasso tools: click, marquee, lasso, and clearing on an empty click. */
 declare const selectPreset: FeaturePreset;
 
 /** The selection outline, drawn only while this is on. */
@@ -11235,30 +11577,83 @@ declare const rotatePreset: FeaturePreset;
  *  claim the drag. */
 declare const movePreset: FeaturePreset;
 
-/**
- * Undo and redo, delete, duplicate, group and ungroup, nudge, select-all,
- * Escape, the context menu, cancel-gesture, cut, copy, and paste, fill and
- * stroke, and their keys.
+/** Escape, and canceling the gesture in flight. */
+declare const escapePreset: FeaturePreset;
+/** The context menu. */
+declare const contextMenuPreset: FeaturePreset;
+/** Cmd/Ctrl+A. */
+declare const selectAllPreset: FeaturePreset;
+/** Duplicate, and repeating the last transform. */
+declare const duplicatePreset: FeaturePreset;
+/** Deleting the selection. */
+declare const deletePreset: FeaturePreset;
+/** Group and ungroup. */
+declare const groupPreset: FeaturePreset;
+/** The arrow keys. */
+declare const nudgePreset: FeaturePreset;
+/** Fill and stroke, and their opacities. */
+declare const stylePreset: FeaturePreset;
+/**
+ * Cut, copy, and paste.
  *
  * Cmd/Ctrl+V arrives as a DOM `paste` event, and two presets answer it. This
  * one brings `clipboard.pasteEvent`, which pastes nodes a kit canvas copied
  * and nothing else; `ingest` takes those plus images, SVG, files, and every
  * OS drop. With both on, `ingest` answers alone.
  */
+declare const clipboardPreset: FeaturePreset;
+/** Every edit preset above, and their keys. */
 declare const editPreset: FeaturePreset;
 
+/** Flipping the selection. */
+declare const flipPreset: FeaturePreset;
+/** Bringing forward and sending backward. */
+declare const reorderPreset: FeaturePreset;
+/** Aligning edges and centers. */
+declare const alignPreset: FeaturePreset;
+/** Distributing across or down. */
+declare const distributePreset: FeaturePreset;
 /** Align, distribute, reorder, and flip. */
 declare const arrangePreset: FeaturePreset;
 
 /**
- * Pathfinder operations, path-edit entry, and anchor editing.
- *
- * It refines `edit`: anchor nudging and deleting are tried ahead of their
- * node-level twins, which bind the same keys and are enabled whenever
- * anything is selected.
- */
+ * The path-edit keys that share a key with a node-level action: anchor nudging
+ * and deleting, and Escape out of path edit or its tool. Each is tried ahead of
+ * its twin, which is enabled whenever anything is selected.
+ */
+declare const anchorKeysPreset: FeaturePreset;
+/** The pathfinder booleans, and the live boolean group. */
+declare const pathfinderPreset: FeaturePreset;
+/** Text and strokes to paths. */
+declare const outlinesPreset: FeaturePreset;
+/** Entering path edit, and editing anchors, handles, and segments in it. */
+declare const pathEditPreset: FeaturePreset;
+/** Simplify, offset, snip at crossings, and join paths. */
+declare const pathCommandsPreset: FeaturePreset;
+/** Pathfinder operations, path-edit entry, and anchor editing. */
 declare const pathsPreset: FeaturePreset;
 
+/** The select tool and the lasso. */
+declare const selectToolsPreset: FeaturePreset;
+/** The hand tool. */
+declare const viewToolsPreset: FeaturePreset;
+/** The tools that drag out a primitive: rect, ellipse, line, polygon, star. */
+declare const shapeToolsPreset: FeaturePreset;
+/** The pen and the pencil. */
+declare const drawToolsPreset: FeaturePreset;
+/** Text and the sticky note. */
+declare const typeToolsPreset: FeaturePreset;
+/** The page slicer. */
+declare const pageToolsPreset: FeaturePreset;
+
+/** Select, and the selection's outline. */
+declare const pickPreset: FeaturePreset;
+/** Resize and rotate handles. */
+declare const transformPreset: FeaturePreset;
+/** Every core behavior: view, pick, transform, move, edit, arrange, paths, and ingest. Tools that make things are
+ *  left to the canvas, through the `tools:` presets or `defaultTools`. */
+declare const drawPreset: FeaturePreset;
+
 /** Dropped and pasted content: images, SVG, files, and whatever
  *  `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop. */
 declare const ingestPreset: FeaturePreset;
@@ -11324,10 +11719,6 @@ declare function resolvedSnapMarks<P>(satisfied: readonly {
     mark?: SnapCandidateMark<P>;
 }[], delta: P): SnapMark<P>[];
 
-type Point = {
-    x: number;
-    y: number;
-};
 /** A drawing tool's point snapping: the points it places one by one, and the
  *  cursor it trails from the last of them. */
 interface PointSnap {
@@ -11520,4 +11911,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 AimHeldViewProps, type AimOutline, type AimPoint, type AimSource, type AimSpace, type AlignAdapter, type AlignEdge, type AlignReference, type AnchorEdit, type AnchorFieldsApi, type AnchorHit, AnchorMarkerShape, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimatedReflow, type AnnotationFlag, type AnyTool, AreaSelectAdapter, type ArrangeArgs, type ArrangedPose, BUILTIN_TOOLS, BUILTIN_TOOL_IDS, type BaseFeature, type BendAlongEffect, type BindRigOptions, type BlendEffect, type BooleanCommitPiece, BooleanOp, BooleanOpOptions, BooleanOpResult, type BooleanOperands, type BooleanSource, BooleanStrokes, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CANVAS_CONTEXT_ATTRIBUTES, COMPOSITE_FEATURES, type CameraHeldViewProps, type CameraProps, CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasRetainOptions, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewCommonProps, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type CarrySource, type ChildOrder, type ChromeCtx, type ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type CompositeFeature, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, type CoreIconName, type CoreKitTargetSettings, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, CreateOutlinesAdapter, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_OVERLAY_STYLE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SIMPLIFY_TOLERANCE, DEFAULT_SNAP_PX, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, DRAW_TOOLS, DebugConfig, DebugSnapshot, DebugStrokes, DebugTheme, type DefaultTextData, type DeleteActionOptions, type DeleteArgs, DepRegistryProviderIfRoot, type Departures, DerivePathFn, DerivePoseFn, DerivedDep, type DerivedPart, DeviceProfileProvider, type DeviceProfileProviderProps, DevtoolsLabel, type DevtoolsLabelProps, Dims, type DistributeAdapter, type DistributeAxis, type DistributeMode, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DrawnBoundsOptions, type DrawnBoundsScene, type DropZoneOptions, EditAnchorsDep, EditAnchorsParams, type EditableShape, type EditedLayerOf, type EditingDrawOne, type EffectItem, type EffectSource, type EffectSourceReader, EnteredGroupApi, FALLBACK_ACCENT, FEATURE_ACTION_IDS, type Feature, type FeatureBindingOptions, type FeatureEntry, type FeaturePreset, type FeedDelta, type FeedNode, FinishedEditFrame, FitViewToBoundsOptions, type FlipAxis, type FlipPivot, GHOST_STROKE, type GateLayerOptions, type GateSource, type GatedLayer, type GatedNode, type GatherSnapOptions, type GeneratedShape, GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, HANDLE_BASE_PX, HANDLE_LOCK_ROLES, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HandleEdit, HandleLocks, type HandleScope, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, INSERT_REPOSITION_BINDING, IconRegistryProvider, IconRegistryProviderIfRoot, type IconRegistryProviderProps, InertiaConfig, InheritedPaint, type InkExtents, InsertAdapter, type InsertArgs, InsertBehavior, InsertNodeFactory, type InsertOp, type InsertOverlayStyle, InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, type JoinPlan, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, KIT_VERSIONS, type KeyModifiers, type KeyState, type KeyStateAttachOptions, type KitInsertShape, type KitRequirements, type KitVersions, LONG_PRESS_FEEDBACK_ID, LassoHitMode, LassoSelectAdapter, LassoSelectBehavior, LayerDims, 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, NodeClip, type NodeFlagArgs, type NodeGates, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OVERLAY_ROLE_STROKES, type OpFactory, type OpenFilePickerOptions, type OpsApplier, OrderedAdapter, OriginProjection, type OutlineStrokeResult, type Overlay, type OverlayPoint, type OverlayVisibilityId, PAGES_DOC_KEY, PAGE_TOOLS, PAINTED_CURSOR_LAYER_ID, PATHFINDER_STROKES, PATH_ANCHOR_CHROME_ID, PATH_EFFECT, PATH_EFFECT_DERIVATIONS, PATH_GESTURE_TAGS, PATH_SNAP_LABELS, type Page, type PageEditOptions, type PageLayoutOptions, type PagesDoc, type PagesLayerOptions, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, PasteCtx, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, PathEditExtension, type PathEditFrame, type PathEditHost, PathEditMark, type PathEditOpening, type PathEditPreview, PathEditTarget, type PathEditingOverlaySlotConfig, type PathEditingOverlayStyle, type PathEffect, type PathEffectDerivations, type PathEffectOptions, type PathGestureFamily, type PathNode, PathPaint, type PathSnapSourceOptions, type PathStorageKind, PathSymmetryDep, type PenContinuation, type PenPreviewStyle, type PenScratch, type PenSubpath, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedPage, PlaneMap, type PointSnap, type PointerFollower, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PolygonGenerator, type PolygonPoint, PoseAdapter, type PoseAnimationAdapter, type PoseCascade, PoseComposition, PoseDescriptor, type PoseFeed, type PoseFrame, PoseOverrides, PoseRemoval, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PoseTargetOptions, type PoseTargetScene, type PoseTransitionScene, type PoseTransitionSeat, PoseWrite, type PosedNode, type PressureToWidthOptions, type PreviewNode, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RectAim, RectPose, RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, type RegisterNodeShapeOptions, RegisteredOp, type RenderDebugSnapshotArgs, RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RepeatAlongEffect, type RepeatableTransform, type RequirementMismatch, type ResizeActionOptions, ResizeAdapter, ResizeHandleLayout, type ResolvableView, type ResolvedOverlay, type RestPath, type Rig, type RigApply, type RigApplyContext, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RoutedNode, SCENE_CANVAS_FEATURES, SELECTION_MOVE_ID, SELECTION_RESIZE_ID, SELECTION_ROTATE_ID, SELECTION_TRANSFORM_ID, SELECT_TOOLS, SHAPE_COUNT_RANGE, SHAPE_KINDS, SHAPE_TOOLS, SNAP_ANGLE_STEP, SNAP_AXIS_STEP, SNAP_ROLES, STAR_RATIO_RANGE, Scene, type SceneAdapterSelection, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasGeometry, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, SceneCanvasSnap, type SceneCanvasViewport, type SceneClipTargetsOptions, Node as SceneNode, type SceneNodeClientRectOpts, ScenePoseReports, SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, type SelectAdapter, type SelectFromLassoOptions, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionRotateOptions, type SelectionStore, type SelectionTransformOptions, SerializedScene, SerializedSceneV1, 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 ShownDataSource, 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, SpecsFromSerializedOptions, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, type StarGenerator, type StarPoint, type StatedNodeFields, StickyStyle, type StrokeRegionOptions, type StylusData, type SurfaceContribution, type SurfaceSizeProps, SvgIngestOptions, SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, TYPE_TOOLS, TargetTransform, type TextAlongEffect, TextOverflow, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, type TransformArgs, TransformFollower, type TweenPoseOptions, UNION_OF_CHILDREN, type UseAlignOptions, type UseAlignReturn, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, type UseMeasureToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRigNodeOptions, type UseRotateOptions, type UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSliceToolOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseStickyToolOptions, type UseToolsOptions, VERSION, VIEW_MARKER_DEFAULT_STYLE, VIEW_MARKER_DRAG, VIEW_MARKER_HIT_SLOP_PX, VIEW_TOOLS, type VelocityTracker, type VersionCheck, type ViewAim, ViewAnimationOptions, type ViewAt, type ViewKitSettings, type ViewLike, ViewMarker, type ViewMarkerGrab, type ViewMarkerHost, type ViewMarkerProps, type ViewMarkerStyle, type ViewPoseAdapter, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenNode, type WrittenPoseTargetOptions, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, addPage, adjacentPage, aimSpace2d, alignDeltaFor, alignTargetBounds, always, anchorEditWouldChange, and, animateLifecycle, animateOnSetPose, annotationLayerIds, annulusSemiAxes, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, arrangePreset, assertSnapSourceIds, axisAlignedBounds, axisZoomFactor, bindPoseTransition, bindRig, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, carriedDescendants, checkRequirements, clampShapeGenerator, clampView, classifyPathStorage, clearSelectionAction, clipOutline, 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, createEnteredGroupScope, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMeasurements, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathEffectDerivations, createPathLayer, createPenPreviewLayer, createPointerFollower, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createResizeAction, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetDependsOnOp, createSetHiddenOp, createSetLayerOp, createSetLayoutOp, createSetLockedOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSnapReadoutLayer, createTextLayer, createTransformOp, createVelocityTracker, createViewMarkerContribution, createViewMarkerLayer, createViewResolver, createViewportLayer, createWrittenPoseTarget, currentMeasureId, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, deleteAction, deleteAnchorsAction, deleteNode, deleteSelectedMark, depOf, derivedDepOf, derivedPartsOf, derivedPose, dispatchApplyBatch, documentDepOf, documentOf, documentPose, dragPanContribution, dragPointOf, drawnAABBOf, drawnBoundsOf, drawnBoundsScene, editAnchorsAction, editPreset, editTargetOf, editedPathSymmetries, editingAnchors, editingLayer, effectSourceFor, effectivePose, enterTextEditAction, enumerateAnchors, exitPathEditToolAction, findNodeShape, findShapeBounds, findShapeDrawnBounds, findShapeInk, findShapeSilhouette, finishPathEditFrame, fitToBounds, fitViewToPage, fitZoom, flattenPreviews, flipAction, focused, forEachCoalesced, forgetTransform, gateLayer, gatherSnapCandidates, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, glidesByDefault, grabViewMarker, groupNodeRouting, hasChildren, hasEditablePath, hiddenSourceDeleteOps, hiddenSourcesTakenWith, hidesSubtree, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, ingestPreset, inkExtentsOf, insertAction, insertAt, insertLayer, insertPreviewExtent, insertRepositionAction, interpolateView, isAnnotationLayer, isAnnotationNode, isLeaf, isNodeHidden, isNodeLocked, isOverChildren, isRectAim, isShapeGenerator, joinPathsCommand, joinSelectedAnchors, kitTextHandler, lassoSelectAction, lastTransform, layoutPages, livePathEdit, locksInForce, makeHandleCommand, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markUnder, measureAt, measureBetween, measureEndSource, measureEndsOf, measureIds, measureNode, measurePose, measuredSegmentCommands, measurementOf, measurementsContribution, mergeAlphaFromPrev, mergeContributions, modeDecorationLayer, modeIn, modeIs, modeNot, modeTriggers, modifierHeld, momentum, moveAction, moveNodes, moveNodesOps, movePage, movePreset, multiActive, nestedHitTester, never, nextPageId, nodeAsShown, nodeGates, nodeOutline, normalizeView, normalizeZoom, not, noteFontRead, nudgeAnchorsDownAction, nudgeAnchorsLeftAction, nudgeAnchorsRightAction, nudgeAnchorsUpAction, onEmptyCanvas, opFactoryRegistry, openContextMenu, openFilePicker, or, outlinePreset, overChildren, pageAt, pageHolding, pageInView, pageMembers, pageName, pageOfBounds, pagesBounds, pagesLayer, pagesOf, paintAbove, paintAlpha, paintWithAlpha, paintWithColor, parseDebugFlags, pathCopy, pathEditPathOf, pathEditPreview, pathEditToolAction, pathEditToolActive, pathEffectNode, pathEffectOf, pathEffectParts, pathFromParts, pathNodesOf, pathOperationTags, pathOriginProjection, pathPoseDescriptor, pathSnapGlyph, pathSnapSource, pathsPreset, pickTopMostHit, pillCommands, pinchZoomAction, placeAction, placeSkeleton, placedPagesOf, planJoin, planPixelRender, pointRegionFrame, pointSnap, poseAxes, pressureToWidth, publishPreviews, rasterToPng, readEffectSource, rebuildOp, reconcileSpecs, recordTransform, rectAim, regenerateShape, registerNodeShape, registerOpFactory, registeredOpNames, registeredPathEffects, releaseCanvasRenderer, removePage, renamePage, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, requiresAnchorSelection, reshapeOps, reshapeTo, resizeAction, resizePage, resizePreset, resolveBooleanOperands, resolveEditablePathOf, resolveOverlays, resolvePartPaint, resolvePreviews, resolveSpatialReference, resolveVisibility, resolvedSnapMarks, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePreset, rotationDegreesUnit, rotationHandle, rotationSnapSource, routeKind, satisfiesRange, sceneCarrySource, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseAdapter, scenePoseFrame, scenePoseTarget, sceneSelectionStore, sceneSharedUnitScopes, sceneToAdapter, sceneUnitScopes, screenToWorld, screenTolerance, segmentUnder, selectAnchorAction, selectFromLasso, selectPreset, selectedPathNodes, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, setPages, settleShapeGenerator, shapeCoversPoint, shapeGeneratorOf, shapeGeneratorPath, sliceAction, slotOf, snapMods, snapSourcesFor, solid, sourcesHiddenBy, sourcesOf, splitOverChildren, springPose, staggerSpringPose, startThresholdDrag, statedFields, stepAngles, storeEditablePath, strokeOf, strokeRegion, strokeWith, textAlongParts, tickedSegment, toHex8, translateRectPose, tweenPose, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnchorFields, useAnimatedReflow, useAutoCenter, useBooleans, useBooleansAdapter, useBooleansAdapterSource, useCanvasSize, useCreateOutlinesAdapter, useDeviceProfile, useDevtoolsLabel, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEffectSourcesLayer, useElementSize, useEllipseTool, useEyedropperTool, useGradientKinds, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useIconGlyph, useIconRegistry, useIconVariant, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLineTool, useMeasureTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, usePoseTransition, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useSnapSource, useStandardActions, useStarTool, useStickyTool, useTextTool, useTools, useTransformFollower, useVelocityTracker, viewForAim, viewMarkerDragAction, viewPreset, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportWorldRect, viewportZoomAction, warmRender, watchDevicePixelRatio, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withInheritedPaintBounds, withInheritedPaints, withPath, withPathEffectsRegistry, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldToScreen, writtenBy, zoomAt, zoomAtLeast };
+export { ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, ActionsProviderIfRoot, AddNodeSpec, Affordance, AffordanceBinding, AffordanceRegion, type AffordanceRegionHit, type AimHeldViewProps, type AimOutline, type AimPoint, type AimSource, type AimSpace, type AlignAdapter, type AlignEdge, type AlignReference, type AnchorEdit, type AnchorFieldsApi, type AnchorHit, AnchorMarkerShape, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimatedReflow, type AnnotationFlag, type AnyTool, AreaSelectAdapter, type ArrangeArgs, type ArrangedPose, BASELINE_ACTIONS, BASELINE_ACTION_IDS, BOOLEAN_OF_CHILDREN, BUILTIN_TOOLS, BUILTIN_TOOL_GROUPS, BUILTIN_TOOL_IDS, type BendAlongEffect, type BindRigOptions, type BlendEffect, type BooleanCommitPiece, BooleanOp, BooleanOpOptions, BooleanOpResult, type BooleanOperands, type BooleanShapeOp, type BooleanSource, BooleanStrokes, BooleansAdapter, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CANVAS_CONTEXT_ATTRIBUTES, type CameraHeldViewProps, type CameraProps, CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasRetainOptions, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewCommonProps, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type CarrySource, type ChildOrder, type ChromeCtx, type ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, type CoreIconName, type CoreKitTargetSettings, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, CreateOutlinesAdapter, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_OVERLAY_STYLE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SIMPLIFY_TOLERANCE, DEFAULT_SNAP_PX, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, DRAW_TOOLS, DebugConfig, DebugSnapshot, DebugStrokes, DebugTheme, type DefaultTextData, type DeleteActionOptions, type DeleteArgs, DepRegistryProviderIfRoot, type Departures, DerivePathFn, DerivePoseFn, DerivedDep, type DerivedPart, DeviceProfileProvider, type DeviceProfileProviderProps, DevtoolsLabel, type DevtoolsLabelProps, Dims, type DistributeAdapter, type DistributeAxis, type DistributeMode, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DrawnBoundsOptions, type DrawnBoundsScene, type DropZoneOptions, EditAnchorsDep, EditAnchorsParams, type EditableShape, type EditedLayerOf, type EditingDrawOne, type EffectBand, type EffectItem, type EffectSource, type EffectSourceReader, type EnterGroupOptions, EnteredGroupApi, FALLBACK_ACCENT, FEATURE_ACTION_IDS, FEATURE_PRESETS, type Feature, type FeatureBindingOptions, type FeatureEntry, type FeaturePreset, type FeedDelta, type FeedNode, FinishedEditFrame, FitViewToBoundsOptions, type FlipAxis, type FlipPivot, GHOST_STROKE, GROUP_ENTRY_ID, type GateLayerOptions, type GateSource, type GatedLayer, type GatedNode, type GatherSnapOptions, type GeneratedShape, GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, HANDLE_BASE_PX, HANDLE_LOCK_ROLES, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HandleEdit, HandleLocks, type HandleScope, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, INSERT_REPOSITION_BINDING, IconRegistryProvider, IconRegistryProviderIfRoot, type IconRegistryProviderProps, InertiaConfig, InheritedPaint, type InkExtents, InsertAdapter, type InsertArgs, InsertBehavior, InsertNodeFactory, type InsertOp, type InsertOverlayStyle, InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, type JoinPlan, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, KIT_VERSIONS, type KeyModifiers, type KeyState, type KeyStateAttachOptions, type KitHandlersOption, type KitInsertShape, type KitRequirements, type KitVersions, LONG_PRESS_FEEDBACK_ID, LassoHitMode, LassoSelectAdapter, LassoSelectBehavior, LayerDims, LayerEnumerableAdapter, LayerGroup, LayerHit, type LayerSlotValue, type LayersMap, LayoutDropTargetMode, LayoutFrame, type LayoutRef, LayoutStrategy, LeanSceneCanvas, type LeanSceneCanvasProps, type LeaveGroupOptions, 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 NamedPresets, type NestedHitOpts, type NestedHitTester, type NodeClientRect, NodeClip, 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_KEYMAP, PATHFINDER_KEYMAP_ID, PATHFINDER_LEADER, PATHFINDER_STROKES, PATH_ANCHOR_CHROME_ID, PATH_EFFECT, PATH_EFFECT_DERIVATIONS, PATH_GESTURE_TAGS, PATH_SNAP_LABELS, type Page, type PageEditOptions, type PageLayoutOptions, type PagesDoc, type PagesLayerOptions, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, PasteCtx, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, PathEditExtension, type PathEditFrame, type PathEditHost, PathEditMark, type PathEditOpening, type PathEditPreview, PathEditTarget, type PathEditingOverlaySlotConfig, type PathEditingOverlayStyle, type PathEffect, type PathEffectDerivations, type PathEffectOptions, type PathGestureFamily, type PathNode, PathPaint, type PathSnapSourceOptions, type PathStorageKind, PathSymmetryDep, type PenContinuation, type PenPreviewStyle, type PenScratch, type PenSubpath, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedPage, type PlacedSpec, PlaneMap, type PointSnap, type PointerFollower, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PolygonGenerator, type PolygonPoint, PoseAdapter, type PoseAnimationAdapter, 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 PresetDescription, type PressTargetTree, type PressureToWidthOptions, type PreviewNode, type PuckerBloatEffect, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RectAim, RectPose, RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, type RegisterNodeShapeOptions, RegisteredOp, type RenderDebugSnapshotArgs, RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RepeatAlongEffect, type RepeatableTransform, type RequirementMismatch, type ResizeActionOptions, ResizeAdapter, ResizeHandleLayout, type ResolvableView, type ResolvedOverlay, type RestPath, type Rig, type RigApply, type RigApplyContext, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type RoughenEffect, 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, SavedScene, Scene, type SceneAdapterSelection, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasGeometry, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, SceneCanvasSnap, type SceneCanvasTextEditor, type SceneCanvasViewport, type SceneClipTargetsOptions, Node as SceneNode, type SceneNodeClientRectOpts, type SceneOptions, ScenePoseReports, SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, ScrollOffset, type ScrollRange, 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 ShownDataSource, 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, SpecsFromSerializedOptions, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, type StarGenerator, type StarPoint, type StatedNodeFields, StickyStyle, type StrokeRegionOptions, type StylusData, type SurfaceContribution, type SurfaceSizeProps, SvgIngestOptions, SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, TOOL_GROUP_ORDER, TYPE_TOOLS, TargetTransform, type TextAlongEffect, type TextEditDoubleClick, TextOverflow, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, type TransformArgs, TransformFollower, type TweenPoseOptions, UNION_OF_CHILDREN, type UseAlignOptions, type UseAlignReturn, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, type UseMeasureToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRigNodeOptions, type UseRotateOptions, type UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, type UseSelectionOptions, type UseSliceToolOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseStickyToolOptions, type UseToolsOptions, VERSION, VIEW_MARKER_DEFAULT_STYLE, VIEW_MARKER_DRAG, VIEW_MARKER_HIT_SLOP_PX, VIEW_TOOLS, type VelocityTracker, type VersionCheck, type ViewAim, ViewAnimationOptions, type ViewAt, type ViewKitSettings, type ViewLike, ViewMarker, type ViewMarkerGrab, type ViewMarkerHost, type ViewMarkerProps, type ViewMarkerStyle, type ViewPoseAdapter, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenNode, type WrittenPoseTargetOptions, type ZigzagEffect, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, addPage, adjacentPage, aimSpace2d, alignDeltaFor, alignPreset, alignTargetBounds, always, anchorEditWouldChange, anchorKeysPreset, and, animateLifecycle, animateOnSetPose, annotationLayerIds, annulusSemiAxes, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, arrangePreset, assertSnapSourceIds, axisAlignedBounds, axisZoomFactor, bindPoseTransition, bindRig, booleanGroupFields, booleanGroupRouting, booleanOfChildren, booleanOpOf, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, carriedDescendants, checkRequirements, clampShapeGenerator, clampView, classifyPathStorage, clearSelectionAction, clipOutline, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, clipboardPasteEventAction, clipboardPreset, cloneAction, coarsePointer, commitAnchorEdit, commitBooleanPieces, commitDeleteToScene, commitOps, composeAffordanceLayer, composeRectPose, composeRigidPose, composeSelectionPose, computeFitViewport, computeSliceOps, computeWheelAction, cond, containerScrollAction, contextMenuAction, contextMenuPreset, coreKitSettingsSchema, createArrangeOp, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteAction, createDeleteOp, createDepartures, createEnteredGroupScope, createGroupEntryContribution, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMeasurements, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathEffectDerivations, createPathLayer, createPenPreviewLayer, createPointerFollower, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createResizeAction, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetDependsOnOp, createSetHiddenOp, createSetLayerOp, createSetLayoutOp, createSetLockedOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSnapReadoutLayer, createTextLayer, createTransformOp, createVelocityTracker, createViewMarkerContribution, createViewMarkerLayer, createViewResolver, createViewportLayer, createWrittenPoseTarget, currentMeasureId, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, deleteAction, deleteAnchorsAction, deleteNode, deletePreset, deleteSelectedMark, depOf, derivedDepOf, derivedPartsOf, derivedPose, describePresets, dispatchApplyBatch, distributePreset, documentDepOf, documentOf, documentPose, dragPanContribution, dragPointOf, drawPreset, drawToolsPreset, drawnAABBOf, drawnBoundsOf, drawnBoundsScene, duplicatePreset, editAnchorsAction, editPreset, editTargetOf, editedPathSymmetries, editingAnchors, editingLayer, effectSourceFor, effectivePose, enterTextEditAction, enumerateAnchors, escapePreset, exitPathEditToolAction, findNodeShape, findShapeBounds, findShapeDrawnBounds, findShapeInk, findShapeSilhouette, finishPathEditFrame, fitToBounds, fitViewToPage, fitZoom, flattenPreviews, flipAction, flipPreset, focused, forEachCoalesced, forgetTransform, gateLayer, gatherSnapCandidates, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, glidesByDefault, grabViewMarker, groupNodeRouting, groupPreset, hasChildren, hasEditablePath, heldInFrame, hiddenSourceDeleteOps, hiddenSourcesTakenWith, hidesSubtree, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, ingestPreset, inkExtentsOf, insertAction, insertAt, insertLayer, insertPreviewExtent, insertRepositionAction, interpolateView, isAnnotationLayer, isAnnotationNode, isAtom, isLeaf, isNodeHidden, isNodeLocked, isOverChildren, isRectAim, isShapeGenerator, joinPathsCommand, joinSelectedAnchors, kitTextHandler, lassoSelectAction, lastTransform, layoutPages, livePathEdit, localizeInScene, localizeWorldPoses, locksInForce, makeBooleanGroup, 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, nodeAsShown, nodeGates, nodeOutline, normalizeView, normalizeZoom, not, noteFontRead, nudgeAnchorsDownAction, nudgeAnchorsLeftAction, nudgeAnchorsRightAction, nudgeAnchorsUpAction, nudgePreset, onEmptyCanvas, opFactoryRegistry, openContextMenu, openFilePicker, or, outlinePreset, outlinesPreset, overChildren, pageAt, pageHolding, pageInView, pageMembers, pageName, pageOfBounds, pageToolsPreset, pagesBounds, pagesLayer, pagesOf, paintAbove, paintAlpha, paintWithAlpha, paintWithColor, parseDebugFlags, pathCommandsPreset, pathCopy, pathEditPathOf, pathEditPreset, pathEditPreview, pathEditToolAction, pathEditToolActive, pathEffectNode, pathEffectOf, pathEffectParts, pathFromParts, pathNodesOf, pathOperationTags, pathOriginProjection, pathPoseDescriptor, pathSnapGlyph, pathSnapSource, pathfinderPreset, pathsPreset, pickPreset, pickTopMostHit, pillCommands, pinchZoomAction, placeAction, placeSkeleton, placedPagesOf, planJoin, planPixelRender, pointRegionFrame, pointSnap, poseAxes, pressureToWidth, publishPreviews, rasterToPng, readEffectSource, rebuildOp, reconcileSpecs, recordTransform, rectAim, regenerateShape, registerNodeShape, registerOpFactory, registeredOpNames, registeredPathEffects, releaseCanvasRenderer, removePage, renamePage, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, reorderPreset, requiresAnchorSelection, reshapeOps, reshapeTo, resizeAction, resizePage, resizePreset, resolveBooleanOperands, resolveEditablePathOf, resolveOverlays, resolvePartPaint, resolvePreviews, resolveSpatialReference, resolveVisibility, resolvedSnapMarks, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePreset, rotationDegreesUnit, rotationHandle, rotationSnapSource, routeKind, satisfiesRange, sceneBoxFrames, sceneCarrySource, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseAdapter, scenePoseFrame, scenePoseTarget, sceneSelectionStore, sceneSharedUnitScopes, sceneToAdapter, sceneUnitScopes, sceneViewPoseAdapter, screenToWorld, screenTolerance, scrollRange, scrollRectPose, scrollRigidPose, scrollableAt, segmentUnder, selectAllPreset, selectAnchorAction, selectFromLasso, selectPreset, selectToolsPreset, selectedPathNodes, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, setPages, settleShapeGenerator, shapeCoversPoint, shapeGeneratorOf, shapeGeneratorPath, shapeToolsPreset, sliceAction, slotOf, snapMods, snapSourcesFor, solid, sourcesHiddenBy, sourcesOf, splitOverChildren, springPose, staggerSpringPose, startThresholdDrag, statedFields, stepAngles, storeEditablePath, strokeOf, strokeRegion, strokeWith, stylePreset, textAlongParts, tickedSegment, toHex8, transformPreset, translateRectPose, tweenPose, typeToolsPreset, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnchorFields, useAnimatedReflow, useAutoCenter, useBooleans, useBooleansAdapter, useBooleansAdapterSource, useCanvasSize, useCreateOutlinesAdapter, useDeviceProfile, useDevtoolsLabel, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEffectSourcesLayer, useElementSize, useEllipseTool, useEyedropperTool, useGradientKinds, useGroupEntryContribution, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useIconGlyph, useIconRegistry, useIconVariant, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLineTool, useMeasureTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, usePoseTransition, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useSnapSource, useStandardActions, useStarTool, useStickyTool, useTextTool, useTools, useTransformFollower, useVelocityTracker, viewForAim, viewMarkerDragAction, viewPreset, viewToTransform, viewToolsPreset, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportWorldRect, viewportZoomAction, warmRender, watchDevicePixelRatio, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withInheritedPaintBounds, withInheritedPaints, withPath, withPathEffectsRegistry, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldPosesOf, worldToScreen, writtenBy, zoomAt, zoomAtLeast };