@weasel-js/core 1.10.0 → 1.10.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { View, NodeId, Bounds, ModifierState, PointerSessionCancelReason, DeviceProfile, DebugSink, HitShape, HandleKind, ViewportGestureKind, IngestItem, SelectionMode, SelectionExtendKey, SelectionApi, ActionDeps, DragSample, Point2, LongPressState, Tool as Tool$1, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, ToolDef as ToolDef$1, DepName, DepSchema, Action, AffordanceHit, GestureBinding, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, OngoingOverlay, ActionsProp, OverlayRole, ResizeAnchor } from '@weasel-js/routing';
-export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionPresentation, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepName, DepRegistry, DepSchema, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, KeyBinding, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, ModeShortcutHandlers, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, UiOngoingControl, Point2 as Vec2, View, ViewportGestureKind, WalkStep, actionBindings, actionItems, activatesFocusedControl, assembleEntries, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDepRegistry, createDispatcher, createLongPressStore, defineTool, deleteScratch, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, isDebugEnabled, isEditableTarget, isInControlWithin, liveScope, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, pastDragThreshold, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
+import { View, NodeId, Bounds, ModifierState, PointerSessionCancelReason, DeviceProfile, DebugSink, HitShape, HandleKind, ViewportGestureKind, IngestItem, SelectionMode, SelectionExtendKey, SelectionApi, ActionDeps, DragSample, Point2, LongPressState, Tool as Tool$1, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, ToolDef as ToolDef$1, DepName, DepSchema, Action, GestureBinding, AffordanceHit, ToolKeybinding, HotkeyTrigger, RuleCtx, Rule, OngoingOverlay, ActionTunings, ActionsProp, OverlayRole, ResizeAnchor } from '@weasel-js/routing';
+export { ALWAYS, Action, ActionDeps, ActionDisabledReason, ActionDispatch, ActionEnabledResult, ActionEntry, ActionItem, ActionParamSchema, ActionParams, ActionPresentation, ActionTuning, ActionTunings, ActionVariant, ActionsProp, ActionsRegistry, AffordanceHit, AssemblyInputs, BindingOpts, BindingScope, BindingSource, BoundGesture, Bounds, BuildRuleCtxArgs, COARSE_TARGET_SCALE, CONTROL_SELECTOR, ContributionDeps, ContributionRouting, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, DebugSink, DepName, DepRegistry, DepSchema, DetectedDeviceFacts, DeviceProfile, DispatchRecord, DispatchRecordInput, Dispatcher, DispatcherContext, DragSample, DroppedCandidate, Eligibility, EligibilityState, GestureBinding, HandleKind, HitShape, HotkeyTrigger, ImmediateInvoker, IngestItem, InputEvent, InvocationCtx, Invoker, KeyBinding, LONG_PRESS_MS, LongPressOptions, LongPressState, LongPressStore, MatchResult, ModeShortcutHandlers, ModifierState, NEVER, NodeId, OngoingHandle, OngoingInvoker, OngoingOverlay, OverlayPosition, OverlayRole, PendingLongPress, PlacedBy, Point2, PointerSession, PointerSessionCallbacks, PointerSessionCancelReason, PointerSessionOptions, RankedCandidate, RecordCandidate, ResizeAnchor, ResolveAllOptions, ResolveOnlyResult, ResolvedCandidate, Rule, RuleCtx, ScopedBinding, ScratchKey, ScratchStore, SelectionApi, SelectionExtendKey, SelectionMode, Selector, SpecificityPart, ToolKeybinding, ToolModifiers, ToolPresentation, ToolSlot, TunedBinding, UiOngoingControl, Point2 as Vec2, View, ViewportGestureKind, WalkStep, actionBindings, actionItems, activatesFocusedControl, assembleEntries, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDepRegistry, createDispatcher, createLongPressStore, defineTool, deleteScratch, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, focusedControlOwnsKey, getScratch, heldKeySpec, historyKey, isDebugEnabled, isEditableTarget, isInControlWithin, liveScope, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, pastDragThreshold, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity, tuneAction } from '@weasel-js/routing';
 import { DrawCommand, Effect, CompositeOp, BlendFactors, ShaderProgramHandle } from '@weasel-js/renderer';
 export { BlendFactor, BlendFactors, CompositeOp, CullRect, DrawCommand, Effect, FillPoseBox, GlMat3, GroupDrawCommand, ImageDrawCommand, ImageMinification, ImageNodeData, ImageRasterSize, ImageStatus, PaintBindContext, PaintDrawKind, PaintProgram, PaintResources, PathDrawCommand, ProgramSource, RenderTarget, SPRITE_STRIDE, ShaderDrawCommand, ShaderProgram, ShaderProgramHandle, ShaderUniform, SpriteSheet, SpritesDrawCommand, TextDrawCommand, TilePatternOpts, blur, commandFill, commandPaint, commandStroke, createTilePattern, cullDrawCommands, fillInPoseFrame, fillToBoundsFrame, frameRect, getImageBitmap, imageStatus, isPaintKindKnown, isVectorImageSrc, mat3, registerEffect, releaseImage, resolveFillPattern, resolvePatternSpec, retryImage, setImageCacheBudget, subscribeImageReady, textCommand, textCommandFromPose, textCommandFromRuns, viewToMat3, vignette, warmPaintKinds } from '@weasel-js/renderer';
 import { CommandFill, CommandStroke, Paint, Fill, Stroke, Palette, SolidPaint } from '@weasel-js/paint';
@@ -9,16 +9,16 @@ export { BakeOptions, CURSOR_ANGLE_STEPS, CURSOR_MAX_CSS_PX, CursorGlyph, Cursor
 import * as _weasel_js_gestures from '@weasel-js/gestures';
 import { ClaimableGesture, GestureSpec } from '@weasel-js/gestures';
 export { ClaimableGesture, ClickSpec, DragSpec, DropSpec, GestureSpec, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, PinchSpec, TargetPredicate, TargetSpec, WheelSpec, bodyPredicate, hitPredicate } from '@weasel-js/gestures';
-import { C as ContainerBounds, L as LayoutStrategy, P as ParallaxOpts, a as PlaneMap, R as RegionPickView, b as LayoutDropTargetMode, c as ReflowTransition, I as InsertAdapter, d as PasteOmission, M as MoveAdapter, A as AreaSelectAdapter, e as LayerEnumerableAdapter, f as LassoHitMode, g as ResizeAdapter, h as RotateAdapter, i as LassoSelectAdapter, j as ClipboardSnapshot, k as PasteCtx, O as OrderedAdapter } from './types-CIKDwlsP.js';
-export { D as DropRegion, l as DropTarget, m as LayoutArrival, n as LayoutChild, o as LayoutContainer, p as LayoutDragged, q as LayoutSnap, r as ReflowGlideOptions, s as ScalarOrXY, S as SnapTarget, t as deriveParallaxView, u as fromPlane, v as planeMap, w as planeMatrix, x as planeToPlane, y as rectFromPlane, z as rectToPlane, B as toPlane } from './types-CIKDwlsP.js';
+import * as _weasel_js_geom from '@weasel-js/geom';
+import { Path, Affine, PoseLinear, PolygonPath, Scale2, Rect, GlMat3, PathFillRule, PlacementAlign, View as View$1, PathInWorldPose } from '@weasel-js/geom';
+export { AverageAxis, BezierEasing, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EasingFn, EasingName, EasingSpec, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, PathFillRule, PathInWorldPose, PathStation, PenAnchor, PointAlongPathOptions, PointInPathOptions, PolygonPath, PoseLinear, PoseRotation, Rect, RectPath, SPRING_PRESETS, Scale2, SimplifyPathOptions, SpringPreset, SpringPresetName, ZOOM_FLOOR, averageAnchorsAt, boundsOfPath, circlePath, composePath, countPathAnchors, 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, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasOpenSubpath, joinAnchorsAt, linePath, linear, meanScale, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, pointAlongPath, pointInPath, polygonFromPoints, polylineFromPoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, resolveEasing, reversePath, rotatePathAround, roundRectPath, scaleDelta, scalePathToBounds, screenAngleOf, simplifyPath, splitByClosure, splitSubpaths, squarePath, standoff, starPath, transformPath, translatePath, unionBoundsPath, withinPxBox, withinPxRadius, worldEditToStorage } from '@weasel-js/geom';
+import { P as ParallaxOpts, C as ContainerBounds, L as LayoutStrategy, a as PlaneMap, R as RegionPickView, b as LayoutDropTargetMode, c as ReflowTransition, I as InsertAdapter, d as PasteOmission, M as MoveAdapter, A as AreaSelectAdapter, e as LayerEnumerableAdapter, f as LassoHitMode, g as ResizeAdapter, h as RotateAdapter, i as LassoSelectAdapter, j as ClipboardSnapshot, k as PasteCtx, O as OrderedAdapter } from './types-DBbbCy0i.js';
+export { D as DropRegion, l as DropTarget, m as LayoutArrival, n as LayoutChild, o as LayoutContainer, p as LayoutDragged, q as LayoutSnap, r as ReflowGlideOptions, s as ScalarOrXY, S as SnapTarget, t as deriveParallaxView, u as fromPlane, v as planeMap, w as planeMatrix, x as planeToPlane, y as rectFromPlane, z as rectToPlane, B as toPlane } from './types-DBbbCy0i.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 * as _weasel_js_history from '@weasel-js/history';
 import { SerializedHistory, Op, History, CreateHistoryOptions, HistorySelection } from '@weasel-js/history';
 export { BeginJournalOptions, CreateHistoryOptions, EvictedEntry, History, HistoryBranch, HistoryEntry, HistoryLogger, HistorySelection, Journal, Op, RecordEntryOptions, SerializedHistory, SerializedHistoryEntry, SerializedOp, SwapArgs, SwapOpOptions, swapOp } from '@weasel-js/history';
-import * as _weasel_js_geom from '@weasel-js/geom';
-import { Path, PoseLinear, Scale2, Mat3, Rect, GlMat3, PolygonPath, PathFillRule, PlacementAlign, View as View$1 } from '@weasel-js/geom';
-export { BezierEasing, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EasingFn, EasingName, EasingSpec, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, PathFillRule, PathInWorldPose, PathStation, PenAnchor, PointAlongPathOptions, PointInPathOptions, PolygonPath, PoseLinear, PoseRotation, Rect, RectPath, SPRING_PRESETS, Scale2, SpringPreset, SpringPresetName, ZOOM_FLOOR, boundsOfPath, circlePath, composePath, countPathAnchors, 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, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, hasOpenSubpath, linePath, linear, meanScale, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, pointAlongPath, pointInPath, polygonFromPoints, polylineFromPoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, rectMarkerPath, rectPath, regularPolygonPath, resolveEasing, reversePath, rotatePathAround, roundRectPath, scaleDelta, scalePathToBounds, screenAngleOf, splitByClosure, splitSubpaths, squarePath, standoff, starPath, transformPath, translatePath, unionBoundsPath, withinPxBox, withinPxRadius, worldEditToStorage } from '@weasel-js/geom';
 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 * as react from 'react';
@@ -33,25 +33,25 @@ import { ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1, Yoke } fr
 export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ActiveToolContextProviderProps, ActiveToolContextValue, DepRegistryProvider, DispatcherChannels, InputScope, OngoingAction, PointerContextProvider, PointerContextValue, PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, SelectionContextValue, UseGestureDispatcherOptions, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useYoke } from '@weasel-js/routing/react';
 import { TextNodeSource, TextOutlinesError, TextPose, TextStyle, StyledRun, TextVerticalAlign, TextPaint } from '@weasel-js/text';
 export { DEFAULT_DECORATION_METRICS, DEFAULT_TEXT_STYLE, DecorationKind, FaceMetricsFn, FitTextPoseOptions, FlagKey, FontVariantCaps, LabelOptions, LaidOutCell, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredSpan, MeasuredText, PaintRunsOpts, PaintedRuns, PlacedGlyph, PointInTextPoseOpts, PositionedRun, RangeStyle, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, RunSourceMap, RunStylePatch, SCRIPT_METRICS, SMALL_CAPS_SCALE, ScriptPreset, SetFlagResult, SmallCapsText, StyleKey, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextNodeSource, TextOutlineSource, TextOutlinesError, TextOutlinesFailure, TextPaint, TextPaintPath, TextPose, TextPoseLayout, TextPoseLayoutInput, TextRenderer, TextStyle, TextToPathOptions, TextTransform, TextVerticalAlign, TransformedRunText, applyStyleToRange, cachedLayoutRuns, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, fitTextPose, fontString, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutRuns, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, paragraphDirection, patchRangeStyle, pointInTextPose, rangeWeight, registerBidi, renderLabel, resolveAlign, resolveRunFace, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset } from '@weasel-js/text';
-import { B as BoundsConstraint, P as PointSnapBehavior, G as GestureContext, R as RotateBehavior, I as InsertBehavior, L as LassoSelectBehavior, S as SnapStrategy, M as MoveBehavior } from './clone-2a5hVbBd.js';
-export { A as ActionBehavior, a as AreaSelectOverlay, b as BehaviorEnd, c as BehaviorMoveResult, d as BehaviorResult, C as CloneBehavior, e as CloneBehaviorResult, f as GestureFrames, g as GroupTransform, h as InsertMoveResult, i as InsertOverlay, j as InsertPoint, k as InsertProposed, l as LassoSelectMoveResult, m as LassoSelectOverlay, n as LassoSelectPose, o as LassoSelectProposed, p as MoveEnd, q as PointSnapContext, r as PointSnapFrame, s as PointSnapResult, t as PointerState, u as ResizeMoveResult, v as ResizeOverlay, w as ResizeProposed, x as RotateMoveResult, y as RotateOverlay, z as RotateProposed } from './clone-2a5hVbBd.js';
+import { B as BoundsConstraint, P as PointSnapBehavior, G as GestureContext, R as RotateBehavior, I as InsertBehavior, L as LassoSelectBehavior, S as SnapStrategy, M as MoveBehavior } from './clone-C0eADtS0.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 PointSnapContext, q as PointSnapFrame, r as PointSnapResult, s as PointerState, t as ResizeMoveResult, u as ResizeOverlay, v as ResizeProposed, w as RotateMoveResult, x as RotateOverlay, y as RotateProposed } from './clone-C0eADtS0.js';
 import { P as PoseDescriptor, b as RotatedPose } from './poseDescriptor-Bqk-11Rl.js';
 export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode, t as translatePoseViaDescriptor, v as visualBoundsViaDescriptor } from './poseDescriptor-Bqk-11Rl.js';
 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 { U as UseResizeOptions } from './cornerHandles-BEshc4z3.js';
-export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-BEshc4z3.js';
+import { U as UseResizeOptions } from './cornerHandles-BSKbyuvQ.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-BSKbyuvQ.js';
 import { ModeRegistry, ModeDecorations } from '@weasel-js/modes';
-import { U as UseMoveOptions, O as OriginProjection } from './originProjection-PPT88jZv.js';
-export { A as AUTO_ORIGIN_PROJECTION, R as RECT_ORIGIN_PROJECTION } from './originProjection-PPT88jZv.js';
+import { U as UseMoveOptions, O as OriginProjection } from './originProjection-CoNVpITV.js';
+export { A as AUTO_ORIGIN_PROJECTION, R as RECT_ORIGIN_PROJECTION } from './originProjection-CoNVpITV.js';
 import { PrefSection, PrefNumberUnit } from '@weasel-js/prefs';
 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, StrokeToPathOptions, getMarker, listMarkers, markerInset, markerKeyOf, markerRegistry, markerSites, registerMarker, resolveMarkerSize, resolveStrokeWidth, strokeInsets, strokeToPath } from '@weasel-js/stroke';
+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';
 import { P as PaintKindEntry } from './test-seams-D0pyV3pR.js';
 export { a as PaintKind, b as PaintKindEditorProps, c as PaintKindFamily, d as PaintKindLoader, e as asPaint, g as getPaintKind, l as listGradientKinds, f as listPaintKinds, p as paintKindOf, h as paintKindRegistry, i as patternFamily, r as registerPaintKind, j as registerPaintKindLoader, s as seedTile, k as switchGradientKind } from './test-seams-D0pyV3pR.js';
 export { Polyline, trimPolyline } from '@weasel-js/geom/tessellate';
-export { SplitBySegmentOptions, pathDivide, pathExclude, pathIntersect, pathSubtract, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath } from '@weasel-js/geom/booleans';
+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';
 export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-DHg5KqaJ.js';
 export { a as aabbCenter, p as pointInRotatedRect, r as rectCorners, b as rotatePoint, c as rotatedRectCorners } from './math-CYUjoyyU.js';
@@ -112,6 +112,52 @@ declare function viewZoom(view: View): number;
  */
 declare function normalizeView(view: View): View;
 
+interface LayerRecordBase<TLayer extends string> {
+    id: TLayer;
+    visible: boolean;
+    locked: boolean;
+    /** Draw this layer as a parallax plane: through a view derived from the
+     *  camera's (see `deriveParallaxView`), and picked through the same one.
+     *  Absent means the layer moves with the camera. */
+    parallax?: ParallaxOpts;
+}
+/** A layer declared when the scene was created. Fixed set, no display name —
+ *  these are the kit's own render bands, not something a user manages. */
+interface SystemLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
+    kind: 'system';
+}
+/** A layer the user created and can rename, reorder or delete. */
+interface UserLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
+    kind: 'user';
+    name: string;
+}
+/** Per-layer metadata held by the scene: whether it is visible and locked,
+ *  and where it sits in the render stack. Distinct from a node's `layer` tag,
+ *  which merely names one of these. */
+type LayerRecord<TLayer extends string> = SystemLayerRecord<TLayer> | UserLayerRecord<TLayer>;
+/** One of the layers a scene is created with. */
+interface SystemLayerSpec<TLayer extends string> {
+    id: TLayer;
+    visible?: boolean;
+    locked?: boolean;
+    /** See `LayerRecord.parallax`. */
+    parallax?: ParallaxOpts;
+}
+/** Argument to `Scene.addLayer`. Always produces a `UserLayerRecord`
+ *  (`kind: 'user'`). */
+interface AddLayerSpec<TLayer extends string> {
+    id: TLayer;
+    name: string;
+    /** Default `true`. */
+    visible?: boolean;
+    /** Default `false`. */
+    locked?: boolean;
+    /** See `LayerRecord.parallax`. */
+    parallax?: ParallaxOpts;
+    /** Render-stack position. Default: top of stack (highest render index). */
+    index?: number;
+}
+
 /** A pose a container's layout wrote — reported by `Scene.onReflow` — in the
  *  node's stored frame. */
 interface LayoutMove<TPose> {
@@ -140,11 +186,10 @@ interface PoseAdapter<TPose> {
     definesFrame?(id: string): boolean;
 }
 /**
- * The transforms a `compose` represents **exactly**. A parent transform wider
- * than its strategy's closure is rounded to the nearest pose — for `'rigid'`
- * that means an anisotropically scaled parent turns a rotated child into a
- * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the
- * shear is dropped.
+ * What a container's pose does to its children under a `compose`: nothing,
+ * an offset, or a whole frame. `'rigid'` is the frame: a container's rotation
+ * and its `transform` both reach its children, and a child's `transform`
+ * holds the skew or stretch its box and rotation cannot.
  */
 type PoseClosure = 'identity' | 'translation' | 'rigid';
 /** Consumer's pose-composition strategy for hierarchical scenes. `compose`
@@ -296,6 +341,9 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
     /** Registry key for the container's clip-path factory.
      *  Containers only; omitted when the container has no clip. */
     clipFromPoseKey?: string;
+    /** Registry key for the container's `copiesFromPose`. Containers only;
+     *  omitted when it draws no copies. */
+    copiesFromPoseKey?: string;
     /** Ids this node's geometry derives from, or `'children'`. Omitted when it
      *  derives from nothing. */
     dependsOn?: readonly string[] | 'children';
@@ -311,24 +359,6 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
     units?: UnitScope;
 }
 
-/**
- * Axis-aligned rectangle pose with optional rotation. Rotation is in
- * radians, pivoted on the unrotated AABB center; absent === 0.
- */
-interface RectPose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Rotation in radians around the unrotated AABB center. Absent === 0. */
-    rotation?: number;
-    /** A skew or per-axis scale the box and rotation cannot hold; see
-     *  {@link PoseLinear}. Absent is the identity. */
-    transform?: PoseLinear;
-}
-
-/** Brand a string as a NodeId. */
-declare const asNodeId: (s: string) => NodeId;
 /**
  * One dependency, as a derivation reads it: the node itself and the pose it is
  * painted at.
@@ -342,10 +372,11 @@ interface DerivedDep<TPose, TData = unknown, TLayer extends string = string> {
     /** Its override when it has one, else its own derived pose, else the pose
      *  the document stores — `effectivePose`, the same answer the renderer uses. */
     pose: TPose;
-    /** The path it derives, or `null` when it derives none. Read it to place
-     *  something *along* a dependency rather than beside it — a label on a
-     *  routed edge, a tick on a curve. Resolved on first read and memoized on
-     *  the dependency. */
+    /** The path a pose override shows it by, else the one it derives, else
+     *  `null`; the document reading skips the override, and a `toPose` lookup
+     *  carries it into the box its `toPose` answers. Read
+     *  it to place something *along* a dependency: a label on a routed edge.
+     *  Resolved on first read and memoized on the dependency. */
     readonly path: Path | null;
 }
 /** `F` with its parameters checked bivariantly, as a method's are, so that a
@@ -363,6 +394,31 @@ type DerivePoseFn<TPose, TData = unknown, TLayer extends string = string> = Biva
 /** A container's clip, from its pose: the type of `ContainerNode.clipFromPose`
  *  and of each entry in `SceneRegistry.clipFromPose`. */
 type ClipFromPoseFn<TPose> = Bivariant<(pose: TPose) => Path | null>;
+/** The extra times a container draws its children: the type of
+ *  `ContainerNode.copiesFromPose` and of each entry in
+ *  `SceneRegistry.copiesFromPose`. Each affine is in world coordinates and
+ *  carries the children, as drawn, to one copy. */
+type CopiesFromPoseFn<TPose, TData = unknown, TLayer extends string = string> = Bivariant<(pose: TPose, node: ContainerNode<TData, TLayer, TPose>) => readonly Affine[] | null>;
+
+/**
+ * Axis-aligned rectangle pose with optional rotation. Rotation is in
+ * radians, pivoted on the unrotated AABB center; absent === 0.
+ */
+interface RectPose {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Rotation in radians around the unrotated AABB center. Absent === 0. */
+    rotation?: number;
+    /** A skew or per-axis scale the box and rotation cannot hold; see
+     *  {@link PoseLinear}. Absent is the identity. */
+    transform?: PoseLinear;
+}
+
+/** Brand a string as a NodeId. */
+declare const asNodeId: (s: string) => NodeId;
+
 interface NodeBase<TData, TLayer extends string, TPose> {
     id: NodeId;
     layer: TLayer;
@@ -423,6 +479,13 @@ interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends
      *  means "no clip for this container right now"; an empty / zero-area path
      *  means "clip everything out" (children render nowhere). */
     clipFromPose?: ClipFromPoseFn<TPose>;
+    /** Draws the whole subtree again under each affine it returns, on top of
+     *  the original, which still draws once as authored. The copies are paint,
+     *  not nodes: nothing stores them, so they follow every edit to the
+     *  children, and a pick that lands on one answers with the child it copies.
+     *  A copy is a copy of the clipped content — the clip travels with it.
+     *  Re-evaluated each render; `null` or `[]` draws no copies. */
+    copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
     /** How this container arranges its children. Whenever the container's
      *  child set or order changes, or its bounds change size, the scene hands
      *  the change to the strategy — `depart` for children that left it,
@@ -438,29 +501,6 @@ interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends
 /** A node in the scene tree: either a leaf or a container. Re-exported
  *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */
 type Node<TData, TLayer extends string, TPose = RectPose> = LeafNode<TData, TLayer, TPose> | ContainerNode<TData, TLayer, TPose>;
-interface LayerRecordBase<TLayer extends string> {
-    id: TLayer;
-    visible: boolean;
-    locked: boolean;
-    /** Draw this layer as a parallax plane: through a view derived from the
-     *  camera's (see `deriveParallaxView`), and picked through the same one.
-     *  Absent means the layer moves with the camera. */
-    parallax?: ParallaxOpts;
-}
-/** A layer declared when the scene was created. Fixed set, no display name —
- *  these are the kit's own render bands, not something a user manages. */
-interface SystemLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
-    kind: 'system';
-}
-/** A layer the user created and can rename, reorder or delete. */
-interface UserLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
-    kind: 'user';
-    name: string;
-}
-/** Per-layer metadata held by the scene: whether it is visible and locked,
- *  and where it sits in the render stack. Distinct from a node's `layer` tag,
- *  which merely names one of these. */
-type LayerRecord<TLayer extends string> = SystemLayerRecord<TLayer> | UserLayerRecord<TLayer>;
 /** What `Scene.add` needs to mint a node. Everything except the id is
  *  required; the id is generated unless one is supplied. */
 interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
@@ -477,6 +517,8 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     /** Only meaningful when `kind === 'container'`. Attach a clip-path function
      *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
     clipFromPose?: ClipFromPoseFn<TPose>;
+    /** Mirrors `ContainerNode.copiesFromPose`; ignored for leaves. */
+    copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;
     /** Mirrors `SceneNode.dependsOn`. */
     dependsOn?: readonly NodeId[] | 'children';
     /** Mirrors `SceneNode.derivePath`. Taken as a live function; its registry key is
@@ -502,34 +544,14 @@ interface RegisteredOp<P> {
      *  Omitted, or returning `undefined`, the op is always its own entry. */
     coalesceKey?: (payload: P) => string | undefined;
 }
-/** One of the layers a scene is created with. */
-interface SystemLayerSpec<TLayer extends string> {
-    id: TLayer;
-    visible?: boolean;
-    locked?: boolean;
-    /** See `LayerRecord.parallax`. */
-    parallax?: ParallaxOpts;
-}
-/** Argument to `Scene.addLayer`. Always produces a `UserLayerRecord`
- *  (`kind: 'user'`). */
-interface AddLayerSpec<TLayer extends string> {
-    id: TLayer;
-    name: string;
-    /** Default `true`. */
-    visible?: boolean;
-    /** Default `false`. */
-    locked?: boolean;
-    /** See `LayerRecord.parallax`. */
-    parallax?: ParallaxOpts;
-    /** Render-stack position. Default: top of stack (highest render index). */
-    index?: number;
-}
 /** Per-scene registry mapping string keys to live function references.
  *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
  *  Each function-field type has its own keyed map. */
 interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {
     /** Maps registry keys to `clipFromPose` factory functions for container nodes. */
     clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;
+    /** Maps registry keys to `copiesFromPose` functions for container nodes. */
+    copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;
     /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */
     derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;
     /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */
@@ -581,10 +603,10 @@ interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
     composition?: PoseComposition<TPose>;
     /** How laid-out containers are measured. See {@link LayoutFrame}. */
     layoutFrame?: LayoutFrame<TPose>;
-    /** When supplied, `scene.applyBatch` consults this on every call. If it
-     *  returns a non-null `Journal`, ops are routed to the journal's
-     *  `applyBatch` instead of recording a new parent-history entry. The scene
-     *  state changes as normal; only the history tracking differs.
+    /** When supplied, `scene.applyBatch` consults this on every call. If it returns a non-null
+     *  `Journal`, ops are routed to the journal's `applyBatch` instead of recording a new
+     *  parent-history entry, and undo and redo step that journal. The scene state changes as
+     *  normal; only the history tracking differs.
      *
      *  When the accessor isn't known at scene-construction time, wire it after
      *  construction via `scene.setActiveJournalAccessor(fn)`. */
@@ -1016,7 +1038,9 @@ interface AffordanceRegion<TScratch = unknown> {
      *    chrome that floats a fixed distance off an edge at any zoom.
      *  - `rect`  — axis-aligned rect (target rotation applies).
      *  - `annulus` — outer ellipse minus inner rect cutout, for zones that sit *around* the
-     *    AABB (e.g. a rotate-on-hover band). */
+     *    AABB (e.g. a rotate-on-hover band).
+     *  - `outline` — within `hitRadiusPx` screen pixels of `path`'s outline, either side of it,
+     *    for chrome that is a path's own edge (path edit's segments). Hit-only. */
     shape: {
         kind: 'point';
         x: number;
@@ -1074,6 +1098,10 @@ interface AffordanceRegion<TScratch = unknown> {
          *  In screen pixels because the clamp has to know the view and the affordance
          *  doesn't: `ChromeState` carries no scale. */
         minBandPx?: number;
+    } | {
+        kind: 'outline';
+        path: PolygonPath;
+        hitRadiusPx: number;
     };
     /** Optional paint. World position is derived from `shape` + target
      *  transform; visual size stays in screen pixels (so handles don't
@@ -1103,8 +1131,12 @@ interface AffordanceRegion<TScratch = unknown> {
      *  discriminator; `buildAffordanceAt` falls back to
      *  `<affordanceId>:<regionId>`. */
     hitKind?: string;
-    /** Cursor to show while hovering this region. */
-    cursor?: CursorSpec;
+    /** Cursor to show while hovering this region: one spec, or one worked out
+     *  from where the pointer is (`at`, in world coords). */
+    cursor?: CursorSpec | ((at: {
+        x: number;
+        y: number;
+    }, view: View) => CursorSpec);
     /** `'exclusive'` bars every binding whose target doesn't consult the
      *  affordance. Read only when the affordance is composed into a
      *  consumer-registered layer; kit chrome routes through
@@ -1425,17 +1457,14 @@ interface ResolvableView {
  *
  * The view an input event belongs to. `id` is `null` for the root view —
  * the whole canvas, when no viewport contains the point.
- *
- * `origin` is the client-space origin of that view's surface, ready to hand
- * to `clientToWorld` — which is the whole reason this type carries it rather
- * than leaving callers to add the canvas rect and the view rect themselves.
  */
 interface ViewTarget {
     id: string | null;
     view: View;
-    origin: {
-        left: number;
-        top: number;
+    /** The point asked about, in that view's world. */
+    world: {
+        x: number;
+        y: number;
     };
 }
 /**
@@ -1474,10 +1503,10 @@ interface CreateViewResolverOpts {
     views: () => readonly ResolvableView[];
     /** The camera for points no view claims. */
     root: () => View;
-    /** Client-space origin of the canvas element. */
-    canvasOrigin: () => {
-        left: number;
-        top: number;
+    /** A client point in the canvas's own CSS pixels, from its top-left. */
+    toLocal: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
     };
     /**
      * Whether something painted over every view claims a canvas-local point —
@@ -1922,12 +1951,94 @@ declare function fitToBounds(viewportW: number, viewportH: number, contentW: num
     panY: number;
 };
 
+/** One page of a document: a sheet of a fixed size, in world units. */
+interface Page {
+    readonly id: string;
+    readonly name?: string;
+    readonly width: number;
+    readonly height: number;
+}
+/** A page and where it sits in world space. */
+interface PlacedPage extends Page {
+    readonly x: number;
+    readonly y: number;
+    /** Its place in the document's page order. */
+    readonly index: number;
+}
+/** Options for {@link layoutPages}. */
+interface PageLayoutOptions {
+    /** Which way the pages run. Default `'row'`. */
+    direction?: 'row' | 'column';
+    /** World units between neighbors. Default 40. */
+    gap?: number;
+    /** Where a page sits across the run, against the largest page. Default `'start'`. */
+    align?: 'start' | 'center' | 'end';
+    /** Where the first page's run starts. Default the world origin. */
+    origin?: {
+        readonly x: number;
+        readonly y: number;
+    };
+}
+/**
+ * Place a document's pages in one world space, in order, so a single scene,
+ * view, and history serve all of them. With the defaults the first page's
+ * top-left corner is the world origin, where a one-page document's page is.
+ * Throws on two pages with one id.
+ */
+declare function layoutPages(pages: readonly Page[], options?: PageLayoutOptions): PlacedPage[];
+/** The page under a world point, or `null` between and outside them. A point on an edge is on the page. */
+declare function pageAt(pages: readonly PlacedPage[], point: {
+    readonly x: number;
+    readonly y: number;
+}): PlacedPage | null;
+/**
+ * The page a world-space box belongs to: the one it overlaps most, the earlier
+ * of two it overlaps equally, and `null` when it touches none. This is the
+ * rule that says which page an object is on.
+ */
+declare function pageOfBounds(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null;
+/**
+ * The page `step` places along the page order from the one with id `current`:
+ * the next slide is `1`, the one before is `-1`. `null` past either end, unless
+ * `wrap`. With no current page in the list, a step forward starts at the first
+ * page and a step back at the last.
+ */
+declare function adjacentPage(pages: readonly PlacedPage[], current: string | null, step: number, options?: {
+    wrap?: boolean;
+}): PlacedPage | null;
+/** The box around every page, or `null` for a document with none. */
+declare function pagesBounds(pages: readonly PlacedPage[]): Bounds | null;
+
+/** Options for {@link pagesLayer}. */
+interface PagesLayerOptions {
+    /** Each page's color: one for all, or one per page. */
+    fill: string | ((page: PlacedPage) => string);
+    /** Default `'pages'`. */
+    id?: string;
+    /** Default `'Pages'`. */
+    label?: string;
+}
+/**
+ * The sheets themselves: a world-space layer that paints each placed page as a
+ * filled rect, to sit under the scene. Build it again when the pages or the
+ * fill change; its commands are cached on both.
+ */
+declare function pagesLayer(pages: readonly PlacedPage[], options: PagesLayerOptions): RenderLayer<unknown>;
+
+/** The view that shows one placed page whole: `fitViewToBounds` on its rect. */
+declare function fitViewToPage(page: PlacedPage, viewportDims: ViewportDims, currentView: View, options?: FitViewToBoundsOptions): View;
+
 /** Optional clamp bounds for `zoomAt`. Defaults: {@link DEFAULT_MIN_ZOOM} /
  *  {@link DEFAULT_MAX_ZOOM} (per axis). */
 interface ZoomClampOpts {
     min?: ZoomBound;
     max?: ZoomBound;
 }
+/** Which axes a zoom scales. */
+type ZoomAxis = 'both' | 'x' | 'y';
+/** `factor` held to one axis: the other axis's factor is 1, so `zoomAt` leaves
+ *  its scale and its translation where they were. */
+declare function axisZoomFactor(factor: number, axis: ZoomAxis): ZoomFactor;
 /**
  * Pure zoom primitive. Returns a new `View` whose `scale` is multiplied
  * by `factor` (per-axis, clamped) and whose translation is adjusted so
@@ -3422,7 +3533,7 @@ interface CreateOutlinesAdapter {
      * node drawn straight. Outline Stroke skews and stretches a world-width
      * stroke with it. Without it every stroke is outlined in world.
      */
-    getStrokeFrame?(id: NodeId): Mat3 | null | undefined;
+    getStrokeFrame?(id: NodeId): Affine | null | undefined;
     /**
      * Mint one path node of node `sourceId`'s outlines. `path` is in world
      * space. The node must wear `spec`'s fill and stroke — a text whose runs
@@ -3448,15 +3559,14 @@ interface CreateOutlinesAdapter {
     }): {
         id: string;
     };
-    /** Full node for `id`, so undo restores the text node whole. Without it the
-     *  delete captures an `{ id }` stub. */
-    getNode?(id: string): {
+    /** Full node for `id`, so undo restores the text node whole. */
+    getNode(id: string): {
         id: string;
     } | undefined | null;
-    /** Parent and sibling order — the reorder contract. With both, each path is
-     *  inserted at its text node's index; without, where `insertNode` defaults. */
-    getParent?(id: string): string | null;
-    getChildren?(parentId: string | null): readonly string[];
+    /** The tree: each path is inserted at its source node's index among its
+     *  parent's children. */
+    getParent(id: string): string | null;
+    getChildren(parentId: string | null): string[];
     applyOps?(ops: Op[], label?: string): void;
     setSelection?(ids: NodeId[]): void;
     insertNode?(node: {
@@ -3526,16 +3636,6 @@ interface BooleanOpOptions {
 
 /** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */
 type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';
-/**
- * z-position descriptor for a path node. `parentId` is the direct parent
- * (or `null` for a top-level node); `index` is the position within that
- * parent's child order — never a global render index.
- */
-/** @internal */
-interface BooleanZOrder {
-    parentId: string | null;
-    index: number;
-}
 /** Adapter the hook and the pure core both consume. */
 interface BooleansAdapter {
     getSelection(): readonly NodeId[] | readonly string[];
@@ -3559,7 +3659,7 @@ interface BooleansAdapter {
      * node drawn straight. A counted world-width stroke is skewed and stretched
      * with it. Without it every stroke is outlined in world.
      */
-    getStrokeFrame?(id: NodeId): Mat3 | null | undefined;
+    getStrokeFrame?(id: NodeId): Affine | null | undefined;
     compareZ(a: NodeId, b: NodeId): number;
     /**
      * Mint a new node from a boolean-op result `Path`. `producedBy` names the
@@ -3578,34 +3678,21 @@ interface BooleansAdapter {
         id: string;
     };
     /**
-     * Optional: return the full object for an id, used by the delete ops so
-     * their `invert` (an insert) can restore the complete object on undo.
-     * If omitted, a `{ id }` stub is captured — undo will reinstate the id
-     * but consumers reading other fields (path, fill, etc.) will see them as
-     * undefined.
+     * The full object for an id. The delete ops capture it, so their `invert`
+     * (an insert) restores the complete object on undo.
      */
-    getNode?(id: NodeId): {
+    getNode(id: NodeId): {
         id: string;
     } | undefined | null;
     /**
-     * Optional: the reorder contract. With `getChildren` (and `getParent`, or
-     * every node reads as top-level) the kit reads each source's slot among its
-     * siblings, and with `setChildOrder` as well it moves each result into the
-     * slot of the topmost source in its own source's parent. Without them the result lands wherever
-     * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.
-     */
-    getParent?(id: string): string | null;
-    getChildren?(parentId: string | null): readonly string[];
-    setChildOrder?(parentId: string | null, ids: string[]): void;
-    /**
-     * Optional override for the slot the kit otherwise reads through
-     * `getParent` / `getChildren`: `id`'s parent and its index in that
-     * parent's child order.
-     *
-     * @deprecated Supply `getParent` and `getChildren` instead, and the kit
-     * derives this.
+     * The tree. The kit reads each source's slot among its siblings through
+     * `getParent` and `getChildren`, and moves each result into the slot of
+     * the topmost source in its own source's parent through `setChildOrder`.
+     * `defaultCommitAdapter` supplies all three, and `getNode`.
      */
-    getZOrder?(id: NodeId): BooleanZOrder | undefined;
+    getParent(id: string): string | null;
+    getChildren(parentId: string | null): string[];
+    setChildOrder(parentId: string | null, ids: string[]): void;
     applyOps?(ops: Op[], label?: string): void;
     setSelection?(ids: NodeId[]): void;
     insertNode?(node: {
@@ -3763,7 +3850,64 @@ interface GeometryProjection {
         id?: string;
         data: unknown;
         pose: unknown;
-    }, m: Mat3): unknown | null;
+    }, m: Affine): unknown | null;
+}
+
+/** Adapter dep for `insertAction`. The `extras` carry the active tool's kind
+ *  + per-kind geometry. */
+interface InsertDep {
+    /**
+     * Materialise a new node from the given drag-rect bounds and typed
+     * per-kind extras. Returns the new node's id, or `null` if the consumer
+     * rejected the insert (e.g. sub-threshold bounds, unknown kind).
+     */
+    commit(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, extras: InsertExtras): NodeId | null;
+    /**
+     * What `commit` would apply, unapplied: the new node's id and the ops that
+     * insert it, for a caller that has more to put in the same undo step. The
+     * pen joins two paths this way. Without it such a caller declines.
+     */
+    build?(bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, extras: InsertExtras): {
+        id: NodeId;
+        ops: Op[];
+    } | null;
+    /** The scene layer `commit` puts the node on. An insert on a layer carrying
+     *  `parallax` is dragged out in that plane's world, so `bounds` arrive
+     *  there too. Omitted: the camera's world. */
+    layer?(): string;
+}
+/**
+ * What `editAnchorsAction` keeps a path symmetric under. Asked once at the
+ * press, with the id of the path being edited; answer every transform of the
+ * symmetry group except the identity, in world coordinates. Of those, the
+ * ones the path is already its own image under are held through the drag:
+ * each image of a dragged anchor or handle follows it, and one a transform
+ * fixes stays where that transform allows.
+ */
+interface PathSymmetryDep {
+    transforms(id: string): readonly Affine[];
+}
+/** Where the `insert` dep puts what it makes. Read at each insert. A node
+ *  goes onto the container's layer, with its pose made local to it when the
+ *  scene composes frames; an id naming no container is the same as `null`. */
+interface InsertIntoDep {
+    get(): string | null;
+}
+/** Holder for the insert gesture in flight in one input scope. `gesture` is
+ *  `insertAction`'s own state, opaque to everything else, and `null` between
+ *  gestures. A source must return the same object on every read. */
+interface InsertLive {
+    gesture: unknown;
 }
 
 /** Minimal view API the action layer consumes. */
@@ -3871,17 +4015,17 @@ interface EditAnchorsDep {
         pose: unknown;
         data: unknown;
     } | null;
-    /** Commit `worldPath` as the new value for `id`. Implementation routes
-     *  to setPose (when pose IS the polygon) or batched setPose+update
-     *  (when the polygon lives on data.path). Records one history entry
-     *  labelled `label`. */
-    applyEdit(id: string, worldPath: unknown, label: string): void;
+    /** Commit `worldPath` as the new value for `id`, as one history entry
+     *  labeled `label`: a setPose when the pose IS the polygon, a batched
+     *  setPose+update when it lives on data.path. Given `origins` (from
+     *  `editAnchorSetTracked`), a `data.skin` is renumbered in that entry. */
+    applyEdit(id: string, worldPath: unknown, label: string, origins?: readonly (_weasel_js_geom.PointOrigin | null)[]): void;
     /** The ops `applyEdit` would commit for the same arguments, unapplied, so
      *  a caller can make the edit part of a larger batch — the pen joining
      *  two paths edits one node and deletes the other in one undo step.
      *  Optional; a caller that needs it declines the composite edit without
      *  it. Returns `[]` when `id` has no editable polygon. */
-    editOps?(id: string, worldPath: unknown, label: string): Op[];
+    editOps?(id: string, worldPath: unknown, label: string, origins?: readonly (_weasel_js_geom.PointOrigin | null)[]): Op[];
     /**
      * Anchors currently selected within the edited path, as **flat anchor
      * indices** — the same numbering `enumerateAnchors` produces and the
@@ -4090,45 +4234,7 @@ interface SnapDep {
         y: number;
     };
 }
-/** Adapter dep for `insertAction`. The `extras` carry the active tool's kind
- *  + per-kind geometry. */
-interface InsertDep {
-    /**
-     * Materialise a new node from the given drag-rect bounds and typed
-     * per-kind extras. Returns the new node's id, or `null` if the consumer
-     * rejected the insert (e.g. sub-threshold bounds, unknown kind).
-     */
-    commit(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, extras: InsertExtras): NodeId | null;
-    /**
-     * What `commit` would apply, unapplied: the new node's id and the ops that
-     * insert it, for a caller that has more to put in the same undo step. The
-     * pen joins two paths this way. Without it such a caller declines.
-     */
-    build?(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, extras: InsertExtras): {
-        id: NodeId;
-        ops: Op[];
-    } | null;
-    /** The scene layer `commit` puts the node on. An insert on a layer carrying
-     *  `parallax` is dragged out in that plane's world, so `bounds` arrive
-     *  there too. Omitted: the camera's world. */
-    layer?(): string;
-}
-/** Holder for the insert gesture in flight in one input scope. `gesture` is
- *  `insertAction`'s own state, opaque to everything else, and `null` between
- *  gestures. A source must return the same object on every read. */
-interface InsertLive {
-    gesture: unknown;
-}
+
 /**
  * Adapter dep for `resizeAction`: bounds-frame behaviors (e.g.
  * `lockAspectWithModifier`), world-space anchor-point snap behaviors (e.g.
@@ -4150,9 +4256,9 @@ interface ResizePolicy<TPose> extends GestureLifecycleOptions {
 }
 /**
  * Layout-strategy lookup by container id, consumed by `moveAction` to run
- * the drag-time reflow pass. Sourced by `<SceneCanvas>` from its `layouts`
- * prop. Optional: `getLayout` returns null for any container when no layout
- * is configured, so the reflow pass is a no-op then.
+ * the drag-time reflow pass. Sourced by `<SceneCanvas>` from the layout each
+ * container declares on its scene node. `getLayout` returns null for a
+ * container that declares none, so the reflow pass is a no-op then.
  */
 interface LayoutDep {
     getLayout(containerId: string): LayoutStrategy<unknown> | null;
@@ -4255,6 +4361,10 @@ declare module '@weasel-js/routing' {
          *  `insert.adjustRotation` reaches the one in its own input scope.
          *  Sourced by `<SceneCanvas>`; without it the rotation does nothing. */
         insertLive?: InsertLive;
+        /** The container the `insert` dep puts new nodes into — every shape a
+         *  tool draws and every dropped image or text. Absent, or answering
+         *  `null`: the top of the tree. */
+        insertInto?: InsertIntoDep;
         /** Snap dep — world-space point snapping (grid / guides). Sourced by
          *  `<SceneCanvas>` from `toolOptions.snapPoint`. Absent means no snapping. */
         snap?: SnapDep;
@@ -4269,6 +4379,9 @@ declare module '@weasel-js/routing' {
         /** Edit-anchors dep — narrow read/write of one polygon's path. If
          *  absent, `editAnchorsAction`'s `start` returns an empty handle (no-op). */
         editAnchors: EditAnchorsDep;
+        /** The transforms a path being edited should stay its own image under.
+         *  Absent: an anchor drag moves only what is dragged. */
+        pathSymmetry?: PathSymmetryDep;
         /**
          * Text-edit dep — activates the in-place text editing overlay. Sourced
          * from consumer via `useTextEdit` / `useSceneTextEdit`.
@@ -4312,7 +4425,7 @@ declare module '@weasel-js/routing' {
             cancelAll(reason: 'commit' | 'cancel'): void;
         };
         /**
-         * Layout-strategy lookup. Sourced by `<SceneCanvas>` from `layouts`.
+         * Layout-strategy lookup. Sourced by `<SceneCanvas>` from the scene.
          * Optional: absent (or all-null) → `moveAction` skips reflow.
          */
         layout?: LayoutDep;
@@ -4787,43 +4900,6 @@ declare function DepRegistryProviderIfRoot({ children }: {
     children: ReactNode;
 }): react.JSX.Element;
 
-/**
- * Project an action's keyboard bindings into the shape a shortcut chip
- * renders from (`formatShortcut` / `formatShortcutParts` in `@weasel-js/ui`).
- */
-
-/** One keyboard shortcut, flattened for display. Structurally the
- *  `ShortcutInput` weasel-ui formats — kept local so core doesn't depend on
- *  the UI package. */
-interface ActionShortcut {
-    key: string;
-    mod: boolean;
-    alt: boolean;
-    shift: boolean;
-}
-/**
- * The chip form of a single gesture spec, or `undefined` when the spec has
- * none.
- *
- * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
- *   shifted bracket reports as `'{'`). The first is the shortcut's name.
- * - A modifier declared `'optional'` matches held or unheld, so it isn't
- *   part of what the user has to press.
- *
- * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
- * *required* `ctrl` or `meta`: the display shape carries only `mod`.
- */
-declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
-/**
- * Every keyboard shortcut an action answers to, in declaration order.
- * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
- * identical are emitted once; an action bound only to those returns empty.
- *
- * With `params` — an `ActionItem`'s — only the bindings that pass those same
- * values count, so each variant of `flip` gets its own key.
- */
-declare function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
-
 /**
  * Pose composition for hierarchical scene graphs.
  *
@@ -4847,9 +4923,9 @@ declare function decomposeRectPose<TPose extends RectPose>(parent: TPose, world:
  * pose is offset into the parent's unrotated box, then the whole thing is
  * turned about the parent's center. Rotations add; the child keeps its size.
  *
- * Reduces to `composeRectPose` when the parent is upright. Exact for
- * translation and rotation; a parent carrying scale is outside what this can
- * express — see `PoseClosure`.
+ * Reduces to `composeRectPose` when the parent is upright. A parent's
+ * `transform` composes too, and what the child's box and rotation cannot hold
+ * of the result lands in the child's own `transform`.
  */
 declare function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose;
 /** Inverse of `composeRigidPose` — un-turns about the parent's center, then
@@ -4871,6 +4947,245 @@ declare const RIGID_POSE_COMPOSITION: PoseComposition<RectPose>;
  */
 declare function worldPoseLookup<TPose>(adapter: PoseAdapter<TPose>, compose: (parent: TPose, child: TPose) => TPose): (id: string) => TPose | null;
 
+/**
+ * @experimental
+ * A world-space place a selection transform lines up against — what align
+ * aligns to, what flip mirrors about — other than the selection itself:
+ *
+ * - `'pointer'` — where the pointer is: the click's world point when a click
+ *   invoked the action, otherwise the latest position in the `pointer` dep.
+ * - `{ x, y, width?, height? }` — a world point, or a world rect when it has
+ *   extent.
+ * - `{ node }` — that node's visual bounds (a key object; it does not move).
+ */
+type SpatialReference = 'pointer' | {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+} | {
+    node: NodeId;
+};
+/** @experimental Where `resolveSpatialReference` reads a reference's inputs. */
+interface SpatialReferenceSources {
+    /** The pointer's world position, or `null` when it is over no canvas. */
+    pointer(): {
+        x: number;
+        y: number;
+    } | null;
+    /** A node's world visual bounds, or `null` when it is not in the scene. */
+    nodeBounds(id: NodeId): Bounds | null;
+}
+/**
+ * @experimental
+ * The world bounds `ref` names — a point comes back as a zero-size rect — or
+ * `null` when it names nothing right now (no pointer, a missing node, a
+ * malformed value).
+ */
+declare function resolveSpatialReference(ref: SpatialReference | unknown, src: SpatialReferenceSources): Bounds | null;
+
+/** Edge or center the selection should align to within the reference's
+ *  bounds (rotated members contribute their ink extent). */
+type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';
+/** @experimental What the selection aligns to: `'union'` — the selection's
+ *  own visual union AABB, the default — or a {@link SpatialReference}. */
+type AlignReference = 'union' | SpatialReference;
+/** @experimental The bounds each member of `bounds` aligns to under `to`, or
+ *  `null` when there is nothing to align: a union of fewer than two members,
+ *  an empty selection, or a reference that names nothing right now. */
+declare function alignTargetBounds(bounds: readonly Bounds[], to: AlignReference | undefined, src: SpatialReferenceSources): Bounds | null;
+/** Adapter for `useAlign`. */
+interface AlignAdapter<TPose> {
+    getSelection(): NodeId[];
+    /** The pose as stored — local to the node's parent. */
+    getPose(id: NodeId): TPose;
+    /** The node's container, `null` for a root: the chain a pose is composed
+     *  through when container poses define a frame. */
+    getParent(id: NodeId): NodeId | null;
+    applyOps?(ops: Op[], label?: string): void;
+}
+/** Options for `useAlign`. */
+interface UseAlignOptions<TPose> {
+    /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
+     *  for `{x,y,width,height}` poses. Pass `pathPoseDescriptor` for `Path`
+     *  poses so polygon coords translate correctly. */
+    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. */
+    composition?: PoseComposition<TPose>;
+}
+/** Return shape of `useAlign`. */
+interface UseAlignReturn {
+    /** Imperative trigger. `to` defaults to `'union'`, which needs two items;
+     *  any other reference aligns a single item too. `'pointer'` reads the
+     *  surrounding `<PointerContextProvider>`. */
+    align(edge: AlignEdge, to?: AlignReference): void;
+}
+/** Compute the (dx, dy) translation that moves AABB `b` so that the requested
+ *  `edge`/center matches the corresponding feature of the union AABB `u`. */
+declare function alignDeltaFor(b: Bounds, u: Bounds, edge: AlignEdge): {
+    dx: number;
+    dy: number;
+};
+/** Align the current selection to a shared edge or center of the selection's
+ *  union AABB, or of another reference. Single batch — one undo step.
+ *
+ *  The edge is a world edge: bounds are measured and translated in world, and
+ *  each result is stored back in its own parent's frame. */
+declare function useAlign<TPose>(adapter: AlignAdapter<TPose>, options?: UseAlignOptions<TPose>): UseAlignReturn;
+
+/** Axis along which selection is distributed. `'x'` spreads horizontally. */
+type DistributeAxis = 'x' | 'y';
+/** `'centers'` spaces centers equally; `'gaps'` makes the gap between
+ *  consecutive items equal. Both measure a rotated item by its ink extent.
+ *  Endpoints stay put in both modes. */
+type DistributeMode = 'centers' | 'gaps';
+/** Adapter for `useDistribute`. */
+interface DistributeAdapter<TPose> {
+    getSelection(): NodeId[];
+    /** The pose as stored — local to the node's parent. */
+    getPose(id: NodeId): TPose;
+    /** The node's container, `null` for a root: the chain a pose is composed
+     *  through when container poses define a frame. */
+    getParent(id: NodeId): NodeId | null;
+    applyOps?(ops: Op[], label?: string): void;
+}
+/** Options for `useDistribute`. */
+interface UseDistributeOptions<TPose> {
+    /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
+     *  for `{x,y,width,height}` poses. */
+    geometry?: PoseDescriptor<TPose>;
+    /** Default mode when `distribute(axis)` is called without one. Default 'centers'. */
+    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. */
+    composition?: PoseComposition<TPose>;
+}
+/** Return shape of `useDistribute`. */
+interface UseDistributeReturn {
+    /** Imperative trigger. No-op when fewer than 3 items selected. */
+    distribute(axis: DistributeAxis, mode?: DistributeMode): void;
+}
+/** Distribute the current multi-selection along `axis`. Requires ≥3 items;
+ *  no-op otherwise. Endpoints (min and max along the axis) stay put; the
+ *  remaining items are repositioned. Single batch — one undo step.
+ *
+ *  The span being divided is a world span: bounds are measured and translated
+ *  in world, and each result is stored back in its own parent's frame. */
+declare function useDistribute<TPose>(adapter: DistributeAdapter<TPose>, options?: UseDistributeOptions<TPose>): UseDistributeReturn;
+
+/**
+ * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).
+ *
+ * These were extracted from the legacy `useFlip` hook when it was removed —
+ * they remain because the descriptor-style `flipAction` still needs to reflect
+ * arbitrary `TPose` values through a `PoseDescriptor`.
+ */
+
+/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */
+type FlipAxis = 'x' | 'y';
+/** How a multi-selection flip chooses its pivot.
+ *
+ *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the
+ *    selection is unchanged, individual items are reflected in place.
+ *  - `'union'` — every pose mirrors about the selection's union AABB; items
+ *    swap sides as well as reflect, matching Illustrator/Figma defaults.
+ *  - a {@link SpatialReference} — every pose mirrors about the center of the
+ *    bounds it names: the pointer, a world point or rect, or a key node. */
+type FlipPivot = 'each' | 'union' | SpatialReference;
+
+/**
+ * The params the kit's own actions read, merged into routing's
+ * `ActionParamSchema` so `<SceneCanvas tune>` types them. An action that
+ * reads params gets its entry here, beside the others.
+ */
+
+/** 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;
+};
+type AlignParams = AtPoint & {
+    to: AlignReference;
+};
+type FlipParams = AtPoint & {
+    axis: FlipAxis;
+    pivot: FlipPivot;
+};
+type DistributeParams = {
+    mode: DistributeMode;
+};
+type ReorderParams = {
+    distance: 'adjacent' | 'extreme';
+};
+type NudgeParams = {
+    magnitude: 'small' | 'big';
+};
+declare module '@weasel-js/routing' {
+    interface ActionParamSchema {
+        'align.left': AlignParams;
+        'align.centerX': AlignParams;
+        'align.right': AlignParams;
+        'align.top': AlignParams;
+        'align.centerY': AlignParams;
+        'align.bottom': AlignParams;
+        flip: FlipParams;
+        'distribute.horizontal': DistributeParams;
+        'distribute.vertical': DistributeParams;
+        'reorder.forward': ReorderParams;
+        'reorder.backward': ReorderParams;
+        'nudge.up': NudgeParams;
+        'nudge.down': NudgeParams;
+        'nudge.left': NudgeParams;
+        'nudge.right': NudgeParams;
+        'tool.activate': {
+            toolId: string;
+        };
+    }
+}
+
+/**
+ * Project an action's keyboard bindings into the shape a shortcut chip
+ * renders from (`formatShortcut` / `formatShortcutParts` in `@weasel-js/ui`).
+ */
+
+/** One keyboard shortcut, flattened for display. Structurally the
+ *  `ShortcutInput` weasel-ui formats — kept local so core doesn't depend on
+ *  the UI package. */
+interface ActionShortcut {
+    key: string;
+    mod: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/**
+ * The chip form of a single gesture spec, or `undefined` when the spec has
+ * none.
+ *
+ * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
+ *   shifted bracket reports as `'{'`). The first is the shortcut's name.
+ * - A modifier declared `'optional'` matches held or unheld, so it isn't
+ *   part of what the user has to press.
+ *
+ * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
+ * *required* `ctrl` or `meta`: the display shape carries only `mod`.
+ */
+declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
+/**
+ * Every keyboard shortcut an action answers to, in declaration order.
+ * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
+ * identical are emitted once; an action bound only to those returns empty.
+ *
+ * With `params` — an `ActionItem`'s — only the bindings that pass those same
+ * values count, so each variant of `flip` gets its own key.
+ */
+declare function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
+
 /** A screen-pixel tolerance in world units, per axis, through the camera of
  *  the view the gesture landed in. With no view, one pixel is one unit. */
 declare function screenTolerance(px: number, ctx: Pick<GestureContext<unknown>, 'view'>): {
@@ -4985,6 +5300,21 @@ declare const insertAction: Action & {
     requires: string[];
 };
 
+/**
+ * @experimental
+ * Companion to `insertAction`: while its key is held, dragging moves the
+ * shape being drawn instead of resizing it; letting go resumes resizing from
+ * where the shape now sits. No-op when no insert is in flight.
+ */
+declare const insertRepositionAction: Action;
+/**
+ * The binding a shape-drawing tool adds so holding Space mid-draw repositions
+ * the shape. Gated to the tool's own engaged phase, so Space between drags is
+ * left to the offhand hand tool. Shift and Alt may be down with it, so a
+ * constrained or from-center draw can be moved without letting go of them.
+ */
+declare const INSERT_REPOSITION_BINDING: GestureBinding;
+
 /**
  * @experimental
  * Clears the selection on a click on empty canvas. It has no ambient
@@ -5103,6 +5433,9 @@ interface ViewportZoomOptions {
     min?: number;
     /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */
     max?: number;
+    /** Hold wheel, trackpad-pinch, and key zoom to one axis; the other keeps its
+     *  scale and its translation. Default `'both'`. Cmd+0 still resets both. */
+    axis?: ZoomAxis;
     /**
      * Glide the discrete steps (Cmd+=, Cmd+-, Cmd+0) instead of jumping.
      * `true` uses the kit defaults; an object tunes them. Wheel and pinch never
@@ -5161,7 +5494,11 @@ declare function makeViewportWheelPanAction(opts?: WheelPanOptions): Action & {
  *   - **Drag** then moves whatever the press left selected — one anchor,
  *     or every selected anchor together.
  *   - **Dragging a control handle** moves just that handle, mirroring the
- *     opposite one while the anchor is smooth. Alt breaks the mirror.
+ *     opposite one while the anchor is smooth. Alt breaks the mirror; Shift
+ *     holds the handle to the angle it had at the press, changing only its
+ *     length.
+ *   - **Under a `pathSymmetry` dep**, on a path that is its own image under
+ *     some of its transforms, every image of what is dragged follows it.
  *
  * Selection lives on the `editAnchors` dep (flat anchor indices) rather
  * than in this handle's scratch, because the keyboard actions
@@ -5231,6 +5568,9 @@ interface PinchZoomOptions {
     min?: number;
     /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */
     max?: number;
+    /** Hold the zoom to one axis. Default `'both'`. The two fingers still pan
+     *  on both. */
+    axis?: ZoomAxis;
 }
 /**
  * @experimental
@@ -5470,8 +5810,8 @@ declare function useKeybindings(tools: ToolsApi, options?: UseKeybindingsOptions
 interface UseSelectToolOptions<TPose> {
     /** Return ids of all objects whose painted body covers (worldX, worldY).
      *  Order doesn't matter — the tool collapses parent/child overlap via
-     *  `pickTopMostHit`. When omitted, defaults to an AABB-vs-point scan over
-     *  `adapter.getNodes()` using the pose descriptor. Override for tighter
+     *  `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[];
     /** Optional alt-aware selection-update hit returning the single id the
@@ -5647,9 +5987,10 @@ declare const onEmptyCanvas: _weasel_js_gestures.TargetPredicate & {
  *  tool adds this to its ambient list. */
 declare function areaSelectContribution(): Contribution;
 
-/** The signals `pickTopMostHit` ranks a hit list by. All optional. */
+/** What `pickTopMostHit` ranks a hit list by: the tree, and a z signal where
+ *  the adapter has one. */
 interface PickTopMostHitAdapter {
-    getParent?: (id: string) => string | null;
+    getParent: (id: string) => string | null;
     /** Paint depth of `id`; higher draws later, so higher wins a hit. Ids the
      *  adapter doesn't know sort below every id it does. */
     getZIndex?: (id: string) => number | null | undefined;
@@ -5665,7 +6006,7 @@ interface PickTopMostHitAdapter {
  *  With no z signal the LAST id wins: scenes walked forward come back
  *  bottom-first by convention. A caller that z-sorts topmost-first and exposes
  *  neither z hook should resolve before calling. */
-declare function pickTopMostHit(ids: readonly string[], adapter: PickTopMostHitAdapter | undefined | null): string | null;
+declare function pickTopMostHit(ids: readonly string[], adapter: PickTopMostHitAdapter): string | null;
 
 /** Options for `useHandTool`. Both are forwarded to `viewport.dragPan` as
  *  binding params; momentum additionally needs a `view` dep publishing
@@ -5843,8 +6184,8 @@ declare namespace useTextTool {
                 description: string;
                 step: number;
                 unit: {
-                    toDisplay: (v: number) => number;
-                    fromDisplay: (v: number) => number;
+                    scale: number;
+                    precision: number;
                     suffix: string;
                 };
                 default: number;
@@ -5856,8 +6197,8 @@ declare namespace useTextTool {
                 min: number;
                 step: number;
                 unit: {
-                    toDisplay: (v: number) => number;
-                    fromDisplay: (v: number) => number;
+                    scale: number;
+                    precision: number;
                     suffix: string;
                 };
                 default: number;
@@ -6055,8 +6396,10 @@ interface UseRigNodeOptions<TPose> extends Pick<BindRigOptions<TPose>, 'apply' |
  * rig node or a node under it changes its pose or data, or when nodes under it come or go; an
  * edit elsewhere in the scene leaves it alone. A rig bound again keeps its `target`, with the
  * animations running on it, its committed pose, and its placement, unless the skeleton's
- * joints were added, removed, renamed, or reordered: then it starts at the bind pose with a
- * new `target`.
+ * joints were added, removed, renamed, or reordered. Then it has a new `target`, which takes
+ * over the placement and the pose of every joint the skeleton still names. Animations go on
+ * running on the target they were started on and show through the new one, so a joint that
+ * was renamed stops moving.
  */
 declare function useRigNode<TPose>(options: UseRigNodeOptions<TPose>): Rig;
 
@@ -6925,7 +7268,10 @@ interface SceneSlotConfig<TNode extends {
     /** 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[];
-    /** Project an object to its committed pose. Defaults to `adapter.getPose(obj.id)`. */
+    /** 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
@@ -7660,102 +8006,6 @@ type InsertPaint = (kind: string, seq: number) => {
  *  alone on a line or a pencil trail. */
 declare const paletteInsertPaint: InsertPaint;
 
-/** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /
- *  `setSelection`. Matches `useSelection().adapterMethods` plus an imperative
- *  read; pass `useSelection()` itself or `selection.adapterMethods`. */
-interface SceneAdapterSelection {
-    get?(): string[];
-    set?(ids: string[]): void;
-    getSelection?(): string[];
-    setSelection?(ids: string[]): void;
-}
-/** Sibling z-order surface used by reorder ops. Inlined here (rather than
- *  pulled from `core/ops/reorder` to avoid import cycles); the `null` parent
- *  channel addresses the root sibling list. */
-/** @internal */
-interface ReorderAdapter {
-    getChildren(parentId: string | null): string[];
-    setChildOrder(parentId: string | null, ids: string[]): void;
-}
-/** Everything the interaction layer can ask of a scene, as one type: the
- *  move, resize, rotate, selection, layer and reorder contracts combined.
- *  `<SceneCanvas>` synthesizes one of these, which is why most consumers never
- *  touch an adapter directly. */
-type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node<TData, TLayer, TPose>, TPose> & ResizeAdapter<Node<TData, TLayer, TPose>, TPose> & RotateAdapter<Node<TData, TLayer, TPose>, TPose> & AreaSelectAdapter & LassoSelectAdapter & LayerEnumerableAdapter<TLayer> & ReorderAdapter & Partial<InsertAdapter<Node<TData, TLayer, TPose>>> & {
-    getParent(id: string): string | null;
-    getLayers: NonNullable<LayerEnumerableAdapter<TLayer>['getLayers']>;
-    /** The node's pose with every ancestor's frame folded in. Equal to
-     *  `getPose` unless the scene composes poses. */
-    getWorldPose(id: string): TPose;
-    /** Whether `id`'s pose is a frame its children are expressed in — see
-     *  `definesFrame`. */
-    definesFrame(id: string): boolean;
-    /** Present only when a composing strategy is configured; the render
-     *  walk feature-detects it. */
-    composePose?(parent: TPose, child: TPose): TPose;
-    getSelection(): string[];
-    setSelection(ids: string[]): void;
-    insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;
-    removeNode(id: string): void;
-    /** Replace a node's `data` — what a `setData` op writes through. */
-    setData(id: string, data: TData): void;
-    /** Swap a container's layout — what a `setLayout` op writes through. */
-    setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;
-    /** Move a node to another layer — what a `setLayer` op writes through. */
-    setLayer(id: string, layer: TLayer): void;
-    getRemovalClosure(ids: readonly string[]): string[];
-    applyOps(ops: Op[], label?: string): void;
-    snapshotSelection(ids: string[]): ClipboardSnapshot;
-    commitPaste(clipboard: ClipboardSnapshot, offset: {
-        dx: number;
-        dy: number;
-    }, ctx?: PasteCtx): Node<TData, TLayer, TPose>[];
-    getPasteOffset(clipboard: ClipboardSnapshot): {
-        dx: number;
-        dy: number;
-    };
-};
-/** Optional extras for the synthesized adapter. Pass `commitInsert` to wire
- *  the insert gesture into a Scene-owned canvas; the returned object becomes
- *  a leaf on the layer named by `layer` (default `'default'`). */
-interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
-    /** Factory for new objects. Returning `null` aborts the insert. */
-    commitInsert?: (bounds: Bounds) => {
-        pose: TPose;
-        data: TData;
-        id?: string;
-    } | null;
-    /** Layer to place inserted nodes on. Defaults to the trivial-form layer. */
-    insertLayer?: TLayer;
-    /** Selection source: the result of `useSelection()` (or its
-     *  `adapterMethods`). When omitted, `getSelection` returns `[]` and
-     *  `setSelection` is a noop, so the marquee gesture updates nothing. */
-    selection?: SceneAdapterSelection;
-    /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */
-    poseDescriptor?: PoseDescriptor<TPose>;
-    /** Layout strategies keyed by container node id, for containers whose
-     *  scene node declares none (`ContainerNode.layout` wins). `move` runs its
-     *  layout-aware pass on them; for inserts, deletes and resizes to reach
-     *  them too, install them with `useLayoutArrivals`. Pass either a static
-     *  map, or a `getLayout(id)` function for dynamic resolution. */
-    layouts?: Record<string, LayoutStrategy<TPose>> | ((containerId: string) => LayoutStrategy<TPose> | null);
-}
-/** 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`. */
-declare function sceneToAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
-/**
- * React-hook wrapper around `sceneToAdapter`. Memoizes on every option, so
- * the adapter keeps its identity across renders unless one of them changes.
- */
-declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
-
 /** A preset that names one behavior and abbreviates nothing. */
 type BaseFeature = 'view' | 'select' | 'outline' | 'move' | 'resize' | 'rotate' | 'edit' | 'arrange' | 'paths' | 'ingest';
 /** A preset that abbreviates others: `pick` is `select` + `outline`,
@@ -7810,6 +8060,45 @@ interface BuiltinToolOptions {
  *  meet: warn in development (the default), throw, or not check. */
 type VersionCheck = 'warn' | 'strict' | 'off';
 
+/** `<SceneCanvas viewport>`: configures the `view` preset, and implies
+ *  it: passing this turns `view` on.
+ *
+ *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or
+ *    an object to tune. Omitted means off.
+ *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0), and `pinchZoom`
+ *    (two-finger pinch) are on under `view`; pass `false` to disable one.
+ *    Disabling via the `actions` prop
+ *    (`actions: { 'viewport.wheelPan': null }`) also works and runs after
+ *    this. */
+interface SceneCanvasViewport {
+    inertia?: boolean | InertiaConfig;
+    /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8
+     *  clamp; `false` disables. An object sets the scale clamp and holds the
+     *  zoom to one axis (`axis`). */
+    pinchZoom?: boolean | PinchZoomOptions;
+    /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults
+     *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes
+     *  duration, easing, interpolator and the reset-branch duration. Wheel
+     *  and pinch are unaffected — their input already samples every frame. */
+    animatedZoom?: boolean | ViewportZoomAnimateOptions;
+    /** Wheel pan. `true`/omitted = on; `false` disables; an object locks the
+     *  axis (`{ axis: 'x' }`) so a single-axis viewport needs no commit clamp. */
+    pan?: boolean | WheelPanOptions;
+    /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the
+     *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}
+     *  object to bind zoom to plain wheel (`wheel: 'plain'`, pair with
+     *  `pan: false`), set `min`/`max` scale clamps, or hold the zoom to one
+     *  axis (`axis: 'x'`). */
+    zoom?: boolean | ViewportZoomOptions;
+    /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).
+     *  When supplied, replaces the default reset-to-identity behavior —
+     *  consumers typically refit the document page into the workspace via
+     *  `fitViewToBounds`. Return the target `View` to let the kit animate
+     *  there when `animatedZoom` is on; return nothing to dispatch it
+     *  yourself, which is what a controlled canvas does. */
+    recenter?: () => View | void;
+}
+
 /** Default size in CSS pixels for selection corner-handles AND their
  *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal
  *  use sites multiply by `DeviceProfile.targetScale`. */
@@ -7872,11 +8161,6 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
      *  spread over that slot's defaults; pass `slot: null` to suppress a
      *  default explicitly. */
     layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;
-    /** Layout strategies keyed by container node id (or a resolver), for
-     *  containers whose scene node declares none (`ContainerNode.layout`
-     *  wins). Applied to a drag and to every other change to their children,
-     *  through the scene's layout pass. */
-    layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];
     /** Which layout container a drag lands in when several contain the drop
      *  point — the innermost (default), the topmost in paint order, or only
      *  containers whose strategy declares a `dropRegion`. Decides both the
@@ -8124,46 +8408,20 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
     /** Touch and pen long-press: its hold time, its haptic, and the
      *  feedback shown while it is held. */
     longPress?: SceneCanvasLongPress;
-    /** Configures the `view` preset, and implies it: passing this turns
-     *  `view` on.
-     *
-     *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or
-     *    an object to tune. Omitted means off.
-     *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0), and `pinchZoom`
-     *    (two-finger pinch) are on under `view`; pass `false` to disable one.
-     *    Disabling via the `actions` prop
-     *    (`actions: { 'viewport.wheelPan': null }`) also works and runs after
-     *    this. */
-    viewport?: {
-        inertia?: boolean | InertiaConfig;
-        /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8
-         *  clamp; `false` disables. An object sets the scale clamp. */
-        pinchZoom?: boolean | PinchZoomOptions;
-        /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults
-         *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes
-         *  duration, easing, interpolator and the reset-branch duration. Wheel
-         *  and pinch are unaffected — their input already samples every frame. */
-        animatedZoom?: boolean | ViewportZoomAnimateOptions;
-        /** Wheel pan. `true`/omitted = on; `false` disables; an object locks the
-         *  axis (`{ axis: 'x' }`) so a single-axis viewport needs no commit clamp. */
-        pan?: boolean | WheelPanOptions;
-        /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the
-         *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}
-         *  object to bind zoom to plain wheel (`wheel: 'plain'`, pair with
-         *  `pan: false`) and/or set `min`/`max` scale clamps. */
-        zoom?: boolean | ViewportZoomOptions;
-        /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).
-         *  When supplied, replaces the default reset-to-identity behavior —
-         *  consumers typically refit the document page into the workspace via
-         *  `fitViewToBounds`. Return the target `View` to let the kit animate
-         *  there when `animatedZoom` is on; return nothing to dispatch it
-         *  yourself, which is what a controlled canvas does. */
-        recenter?: () => View | void;
-    };
+    /** Configures the `view` preset, and implies it. See {@link SceneCanvasViewport}. */
+    viewport?: SceneCanvasViewport;
+    /**
+     * Tune actions on this canvas without restating them, keyed by action id:
+     * `params` every invocation starts from, and `bindings` added beside the
+     * action's own. A tuning applies to whichever descriptor holds the id, a
+     * preset's or a tool's. Pass a stable object; a params thunk is read on
+     * every call. See the core README ("Tuning an action").
+     */
+    tune?: ActionTunings;
     /**
      * @experimental
-     * Override / disable / extend the default action set. Pass `null` to disable all
-     * defaults.
+     * 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;
     /**
@@ -8319,7 +8577,7 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<TP
 
 /** Paint one node the way the kit does by default: dispatch to the first
  *  registered node-shape painter that matches, then draw its `data.label` on
- *  top when it has one. Consumers replace or wrap this via `drawOne`. */
+ *  top when it has one: on top of a container's children too. Consumers replace or wrap this via `drawOne`. */
 declare function defaultDrawOne<TData, TLayer extends string, TPose>(node: Node<TData, TLayer, TPose>, pose: TPose, view?: View, ctx?: NodePaintCtx): DrawCommand[];
 /**
  * The box {@link defaultDrawOne}'s output for `node` fits in — the matched
@@ -8358,6 +8616,28 @@ declare const SceneCanvas: <TData, TLayer extends string, TPose>(props: SceneCan
     ref?: react__default.Ref<SceneCanvasApi>;
 }) => ReturnType<typeof SceneCanvasInner>;
 
+/**
+ * How a painter asks for part of a node's paint to land on top of the node's
+ * children: a container's label, a frame's title, a badge. A scene walk draws
+ * a node before its children, so anything else a container paints is covered
+ * by them.
+ */
+
+/**
+ * `cmds` as one command a scene walk paints after the node's children. Return
+ * it among a `drawOne`'s other commands. Outside a scene walk it is an
+ * ordinary group, painted where it sits in the list.
+ */
+declare function overChildren(cmds: DrawCommand[]): DrawCommand;
+/** Whether `cmd` came from {@link overChildren}. */
+declare function isOverChildren(cmd: DrawCommand): boolean;
+/** `cmds` as what paints under the node's children and what paints over them.
+ *  A list asking for nothing over comes back as `under` itself. */
+declare function splitOverChildren(cmds: DrawCommand[]): {
+    under: DrawCommand[];
+    over: DrawCommand[];
+};
+
 /** Which of the host's edges the panel is held against, per axis. */
 interface HostAnchorAlign {
     x: PlacementAlign;
@@ -8488,6 +8768,103 @@ interface PickHudProps {
  *  would actually select shown in bold. */
 declare function PickHud({ canvasRef, anchorRef, viewRef, toWorld, pickEvery, pickBest, offset }: PickHudProps): react.JSX.Element | null;
 
+/**
+ * Synthesize a `<Canvas>`-compatible adapter from a `Scene` primitive.
+ * `getPose` / `setPose` return / write **local** coordinates (relative to
+ * parent); world composition is the renderer's job via `composeWorldPose`.
+ */
+
+/** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /
+ *  `setSelection`. Matches `useSelection().adapterMethods` plus an imperative
+ *  read; pass `useSelection()` itself or `selection.adapterMethods`. */
+interface SceneAdapterSelection {
+    get?(): string[];
+    set?(ids: string[]): void;
+    getSelection?(): string[];
+    setSelection?(ids: string[]): void;
+}
+/** Sibling z-order surface used by reorder ops. Inlined here (rather than
+ *  pulled from `core/ops/reorder` to avoid import cycles); the `null` parent
+ *  channel addresses the root sibling list. */
+/** @internal */
+interface ReorderAdapter {
+    getChildren(parentId: string | null): string[];
+    setChildOrder(parentId: string | null, ids: string[]): void;
+}
+/** Everything the interaction layer can ask of a scene, as one type: the
+ *  move, resize, rotate, selection, layer and reorder contracts combined.
+ *  `<SceneCanvas>` synthesizes one of these, which is why most consumers never
+ *  touch an adapter directly. */
+type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node<TData, TLayer, TPose>, TPose> & ResizeAdapter<Node<TData, TLayer, TPose>, TPose> & RotateAdapter<Node<TData, TLayer, TPose>, TPose> & AreaSelectAdapter & LassoSelectAdapter & LayerEnumerableAdapter<TLayer> & ReorderAdapter & Partial<InsertAdapter<Node<TData, TLayer, TPose>>> & {
+    getParent(id: string): string | null;
+    getLayers: NonNullable<LayerEnumerableAdapter<TLayer>['getLayers']>;
+    /** The node's pose with every ancestor's frame folded in. Equal to
+     *  `getPose` unless the scene composes poses. */
+    getWorldPose(id: string): TPose;
+    /** Whether `id`'s pose is a frame its children are expressed in — see
+     *  `definesFrame`. */
+    definesFrame(id: string): boolean;
+    /** Present only when a composing strategy is configured; the render
+     *  walk feature-detects it. */
+    composePose?(parent: TPose, child: TPose): TPose;
+    getSelection(): string[];
+    setSelection(ids: string[]): void;
+    insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;
+    removeNode(id: string): void;
+    /** Replace a node's `data` — what a `setData` op writes through. */
+    setData(id: string, data: TData): void;
+    /** Swap a container's layout — what a `setLayout` op writes through. */
+    setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;
+    /** Move a node to another layer — what a `setLayer` op writes through. */
+    setLayer(id: string, layer: TLayer): void;
+    getRemovalClosure(ids: readonly string[]): string[];
+    applyOps(ops: Op[], label?: string): void;
+    snapshotSelection(ids: string[]): ClipboardSnapshot;
+    commitPaste(clipboard: ClipboardSnapshot, offset: {
+        dx: number;
+        dy: number;
+    }, ctx?: PasteCtx): Node<TData, TLayer, TPose>[];
+    getPasteOffset(clipboard: ClipboardSnapshot): {
+        dx: number;
+        dy: number;
+    };
+};
+/** Optional extras for the synthesized adapter. Pass `commitInsert` to wire
+ *  the insert gesture into a Scene-owned canvas; the returned object becomes
+ *  a leaf on the layer named by `layer` (default `'default'`). */
+interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {
+    /** Factory for new objects. Returning `null` aborts the insert. */
+    commitInsert?: (bounds: Bounds) => {
+        pose: TPose;
+        data: TData;
+        id?: string;
+    } | null;
+    /** Layer to place inserted nodes on. Defaults to the trivial-form layer. */
+    insertLayer?: TLayer;
+    /** Selection source: the result of `useSelection()` (or its
+     *  `adapterMethods`). When omitted, `getSelection` returns `[]` and
+     *  `setSelection` is a noop, so the marquee gesture updates nothing. */
+    selection?: SceneAdapterSelection;
+    /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */
+    poseDescriptor?: PoseDescriptor<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`. */
+declare function sceneToAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
+
+/**
+ * React-hook wrapper around `sceneToAdapter`. Memoizes on every option, so
+ * the adapter keeps its identity across renders unless one of them changes.
+ */
+declare function useSceneAdapter<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, options?: SceneToAdapterOptions<TData, TLayer, TPose>): SceneCanvasAdapter<TData, TLayer, TPose>;
+
 /**
  * Routing classifiers for the kit's built-in shape kinds
  * (`KIT_SHAPE_KINDS`): each entry matches `data.kind === '<name>'`. Routing
@@ -8527,6 +8904,21 @@ interface NodePropertiesEntry {
     name: string;
     /** Property schema for this kind. */
     schema: PrefSection;
+    /**
+     * What a property write stores, given the node as the write left it and as
+     * it was: lets a kind keep fields derived from the one written in step
+     * with it, in the same undo step. Unset, the write is stored as made.
+     */
+    settle?(next: {
+        pose: unknown;
+        data: unknown;
+    }, prev: {
+        pose: unknown;
+        data: unknown;
+    }): {
+        pose: unknown;
+        data: unknown;
+    };
 }
 /**
  * The **properties trait's** registry. Each trait of a node (shape, routing,
@@ -8731,6 +9123,8 @@ type ResolvedOverlay = {
     /** The drag's anchor — a growth axis to mark. Absent for a pencil, which
      *  has none. */
     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
      *  cannot: an image insert's `src`, say. */
     extras: unknown;
@@ -8803,8 +9197,7 @@ declare function modeDecorationLayer(decorations: ModeDecorations, opts?: {
 
 /**
  * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.
- * Children are drawn in z-order (index 0 = bottom). If the adapter doesn't
- * implement `getChildren`, the layer is a silent no-op.
+ * Children are drawn in z-order (index 0 = bottom).
  */
 
 /** Options for `createChildrenLayer`. */
@@ -8888,32 +9281,6 @@ declare const DEFAULT_DEBUG_THEME: DebugTheme;
  */
 declare const DEFAULT_DEBUG_STROKES: DebugStrokes;
 
-/** Where a container's layout comes from: a map by container id, or a
- *  resolver. The same shape `<SceneCanvas layouts>` takes. */
-type LayoutSource<TPose> = Record<string, LayoutStrategy<TPose>> | ((containerId: string) => LayoutStrategy<TPose> | null);
-/** Options for {@link layoutArrivalHandler} and {@link useLayoutArrivals}. */
-interface LayoutArrivalOptions<TPose> {
-    layouts: LayoutSource<TPose>;
-    /** How poses are read and resized. Default `AUTO_POSE_DESCRIPTOR`. */
-    poseDescriptor?: PoseDescriptor<TPose>;
-}
-/**
- * A scene arrival handler over `layouts`: the scene's own layout pass
- * (`depart` for children that left a container, `arrive` for children that
- * joined it, `childPoses` for any other change to its children or size),
- * measured through the canvas's pose
- * descriptor. A container that declares its own layout
- * (`ContainerNode.layout`) is arranged by that one; `layouts` fills in for
- * the rest.
- */
-declare function layoutArrivalHandler<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, opts: LayoutArrivalOptions<TPose>): SceneArrivalHandler<TPose>;
-/**
- * Install {@link layoutArrivalHandler} on `scene` for as long as the calling
- * component is mounted. `<SceneCanvas layouts>` does this itself; call it
- * when a canvas is wired by hand through `sceneToAdapter({ layouts })`.
- */
-declare function useLayoutArrivals<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, opts: Partial<LayoutArrivalOptions<TPose>>): void;
-
 /**
  * @experimental
  * Bundle a list of Affordances into a single RenderLayer.
@@ -8942,10 +9309,10 @@ interface TargetTransform {
     /** No rotation and no `transform`: local is world. */
     identity: boolean;
     /** Target box frame → world. */
-    toWorld: Mat3;
+    toWorld: Affine;
     /** World → target box frame. `null` when the target's `transform` is
      *  singular: it draws nothing, and no world point maps back. */
-    toLocal: Mat3 | null;
+    toLocal: Affine | null;
 }
 
 /**
@@ -8959,8 +9326,10 @@ interface AffordanceRegionHit {
     affordanceId: string;
     /** `AffordanceRegion.id`. */
     regionId: string;
-    /** The region itself, so callers can read `hitKind` / `cursor`. */
+    /** The region itself, so callers can read `hitKind`. */
     region: AffordanceRegion;
+    /** The region's cursor at the hit point. */
+    cursor?: CursorSpec;
     /** Result of the region's `bind()`, called exactly once. */
     binding: AffordanceBinding;
 }
@@ -9064,8 +9433,8 @@ interface RotationAffordanceOptions {
         insetPx?: number;
     } | null | false;
     /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned
-     *  with the target, falling back to `'grab'` if the browser rejects the
-     *  image. */
+     *  square to the line from the pivot to the pointer, falling back to
+     *  `'grab'` if the browser rejects the image. */
     cursor?: CursorSpec;
     /** A grab region for a rotate badge painted off the top edge — the one
      *  the selection overlay's `rotationHandle` draws. `distancePx` is how far
@@ -9101,7 +9470,7 @@ interface RotationScratch extends CommonAffordanceScratch {
  */
 declare function createRotationAffordance(opts?: RotationAffordanceOptions): Affordance;
 
-/** Path anchor + control-handle affordances. */
+/** Path anchor, control-handle, and segment affordances. */
 
 /**
  * Live anchor-editing state. The thunk that returns it is called on every
@@ -9130,15 +9499,18 @@ interface AnchorScratch extends CommonAffordanceScratch {
     /** Which of the anchor's three grabbable points this is. */
     part: 'anchor' | 'controlIn' | 'controlOut';
 }
-/** Chrome-caps id gating both returned affordances. */
+/** Chrome-caps id gating every returned affordance. */
 declare const PATH_ANCHOR_CHROME_ID = "path-edit.anchors";
 /**
- * Anchor + control affordances for the selected paths, bottom → top.
+ * Segment, anchor, and control affordances for the selected paths, bottom →
+ * top.
  *
- * Returns **two** affordances rather than one so that a control handle beats
- * an anchor regardless of which is nearer, the way controls draw on top.
- * Within each of the two, nearest wins. They deliberately share one id:
- * chrome-caps gates anchor editing as a single piece of chrome.
+ * Three affordances rather than one, so that a control handle beats an anchor
+ * regardless of which is nearer, the way controls draw on top, and both beat
+ * the segment they sit on. Within each, nearest wins. A press on the edited
+ * path's outline is a `segment` hit, which the segment bend binds to and a
+ * selection move turns down. They deliberately share one id: chrome-caps
+ * gates anchor editing as a single piece of chrome.
  *
  * Order matters — spread this into an affordance list in the returned order.
  */
@@ -9210,7 +9582,9 @@ declare function unionAABB<TPose extends RectPose>(parts: Iterable<TPose | null
 /**
  * `useSceneTextEdit` — scene-aware wrapper around `useTextEdit`: scene
  * lookups for text / style / runs / screen-pose, and
- * `scene.update(id, { data })` for commits.
+ * `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.
@@ -9270,10 +9644,6 @@ interface UseSceneTextEditOptions<TData> {
      * on, when there are several). With no canvas there, the node's world box
      * is passed through as screen pixels.
      *
-     * The overlay takes a single scale factor, so a non-uniform view scale is
-     * represented by its `scale.x`; text under `scale.x !== scale.y` will not
-     * match the canvas.
-     *
      * A thunk is re-read on every projection; a plain `View` is the value from
      * the render that supplied it.
      */
@@ -9288,6 +9658,12 @@ interface UseSceneTextEditOptions<TData> {
     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
@@ -9321,7 +9697,7 @@ interface StrokeRegionOptions {
  * the node's own (`poseFrameOf`, to world), which skews and stretches the
  * stroke with the node.
  */
-declare function strokeRegion(path: Path, stroke: Stroke, frame: Mat3 | null | undefined, { scale, flattenTolerance }?: StrokeRegionOptions): PolygonPath;
+declare function strokeRegion(path: Path, stroke: Stroke, frame: Affine | null | undefined, { scale, flattenTolerance }?: StrokeRegionOptions): PolygonPath;
 
 /**
  * Outline Stroke: replace each selected stroked path, or stroked text, with
@@ -9526,8 +9902,8 @@ declare function createArrangeOp(args: ArrangeArgs, compute?: () => ArrangedPose
  * so an ordinal captured before the mutation is replayed against a list that
  * has not been refilled yet and clamps to the end, while "put this back before
  * `e`" stays true however much else has already moved. The ordinal is the
- * fallback for the cases the anchor cannot cover — an adapter with no
- * `getChildren` seam, or an anchor that is itself gone by replay time.
+ * fallback for the case the anchor cannot cover: an anchor that is itself
+ * gone by replay time.
  */
 interface SiblingSlot {
     /** Ordinal among the siblings. `-1` means "nowhere in particular". */
@@ -9582,7 +9958,7 @@ interface DeleteArgs<TNode extends {
     label?: string;
     /** Sibling ordinal the node occupies at the moment of delete. Sugar for
      *  `slot: { index }`, and only a seed: `apply` re-observes the node's full
-     *  slot through the adapter, where it can, and that supersedes this. */
+     *  slot through the adapter, and that supersedes this. */
     index?: number;
     /** Full slot, anchor included. Written by `apply`; supersedes `index`. */
     slot?: SiblingSlot;
@@ -10298,6 +10674,83 @@ interface PathEditingOverlayStyle {
  *  edited. */
 declare function createPathEditingOverlayLayer(opts: CreatePathEditingOverlayLayerOptions): RenderLayer<unknown>;
 
+/**
+ * The parameters a polygon or star was drawn with, kept on the node beside the
+ * geometry they made (`data.generator` beside `data.path`), so the shape stays
+ * editable as a polygon or a star after it is drawn.
+ *
+ * `data.path` stays the geometry every reader uses; the generator only says how
+ * to make it again. Editing the path itself turns the shape into plain
+ * geometry: the generator is dropped, since it could no longer reproduce what
+ * is drawn. A generator whose path no longer matches it (a writer that changed
+ * the path without dropping it) is treated the same way.
+ */
+
+/** A regular polygon's parameters. `rotation` is the angle of its first
+ *  vertex, in radians, inside the pose's own rotation. */
+interface PolygonGenerator {
+    kind: 'polygon';
+    sides: number;
+    rotation: number;
+}
+/** A star's parameters. `innerRadiusRatio` is the inner radius over the outer
+ *  one; `rotation` is the angle of its first point, in radians, inside the
+ *  pose's own rotation. */
+interface StarGenerator {
+    kind: 'star';
+    points: number;
+    innerRadiusRatio: number;
+    rotation: number;
+}
+/** The parameters a node's `data.path` was generated from. */
+type ShapeGenerator = PolygonGenerator | StarGenerator;
+/** The range of a polygon's side count and a star's point count. */
+declare const SHAPE_COUNT_RANGE: {
+    readonly min: 3;
+    readonly max: 32;
+};
+/** The range of a star's `innerRadiusRatio`. */
+declare const STAR_RATIO_RANGE: {
+    readonly min: 0.01;
+    readonly max: 1;
+};
+/** Whether `v` is a well-formed {@link ShapeGenerator}. */
+declare function isShapeGenerator(v: unknown): v is ShapeGenerator;
+/** The generator a node's `data` holds, or `null`. */
+declare function shapeGeneratorOf(data: unknown): ShapeGenerator | null;
+/** `g` with its counts rounded and every field held in range. */
+declare function clampShapeGenerator(g: ShapeGenerator): ShapeGenerator;
+/** The shape `g` makes, on a circle of `radius` around `center`. */
+declare function shapeGeneratorPath(g: ShapeGenerator, center?: {
+    x: number;
+    y: number;
+}, radius?: number): PolygonPath;
+/** `data` without its generator: the shape as plain geometry. */
+declare function withoutShapeGenerator<T>(data: T): T;
+/** A node's two halves, as a regeneration reads and writes them. */
+interface GeneratedShape<P extends PathInWorldPose = PathInWorldPose> {
+    pose: P;
+    data: unknown;
+}
+/**
+ * `node` made again from `next`, in place: the new shape takes the box the old
+ * one's circle had, under the same rotation and transform, so a star given
+ * more points keeps its center and its size. Returns `null` when the node holds
+ * no generator, or its path no longer matches the one it holds.
+ */
+declare function regenerateShape<P extends PathInWorldPose>(node: GeneratedShape<P>, next: ShapeGenerator): GeneratedShape<P> | null;
+/**
+ * What a write that left a node as `next`, from `prev`, stores: when the write
+ * changed the generator, the shape made again from it. A generator written
+ * onto a node that held none, or of another kind, or onto one whose path no
+ * longer matches, is dropped, leaving the shape as plain geometry. Any other
+ * write is stored as written. Fits `NodePropertiesEntry.settle`.
+ */
+declare function settleShapeGenerator<N extends {
+    pose: unknown;
+    data: unknown;
+}>(next: N, prev: N): N;
+
 /**
  * Snap a (dx, dy) direction vector to the nearest 0/45/90/135° axis,
  * preserving the input magnitude. Used by the pen tool's Shift-constrain
@@ -10672,154 +11125,50 @@ declare function hitAnchor(path: PolygonPath, worldX: number, worldY: number, th
 
 /**
  * @experimental
- * A world-space place a selection transform lines up against — what align
- * aligns to, what flip mirrors about — other than the selection itself:
- *
- * - `'pointer'` — where the pointer is: the click's world point when a click
- *   invoked the action, otherwise the latest position in the `pointer` dep.
- * - `{ x, y, width?, height? }` — a world point, or a world rect when it has
- *   extent.
- * - `{ node }` — that node's visual bounds (a key object; it does not move).
- */
-type SpatialReference = 'pointer' | {
-    x: number;
-    y: number;
-    width?: number;
-    height?: number;
+ * A transform the selection underwent, kept relative so it can be applied to
+ * whatever is selected next.
+ *
+ * - `translate`: a world offset.
+ * - `rotate`: radians about the selection's center, or about each node's own
+ *   center (`pivot: 'each'`).
+ * - `scale`: the box the selection was resized to, in units of the box it
+ *   started as (`{ x: 0, y: 0, width: 1, height: 1 }` is no change), and the
+ *   anchor the resize held fixed.
+ * - `duplicate`: copy the selection, offset by `(dx, dy)`, and select the copies.
+ */
+type RepeatableTransform = {
+    readonly kind: 'translate';
+    readonly dx: number;
+    readonly dy: number;
 } | {
-    node: NodeId;
+    readonly kind: 'rotate';
+    readonly angle: number;
+    readonly pivot: 'union' | 'each';
+} | {
+    readonly kind: 'scale';
+    readonly to: Bounds;
+    readonly anchor: ResizeAnchor;
+} | {
+    readonly kind: 'duplicate';
+    readonly dx: number;
+    readonly dy: number;
 };
-/** @experimental Where `resolveSpatialReference` reads a reference's inputs. */
-interface SpatialReferenceSources {
-    /** The pointer's world position, or `null` when it is over no canvas. */
-    pointer(): {
-        x: number;
-        y: number;
-    } | null;
-    /** A node's world visual bounds, or `null` when it is not in the scene. */
-    nodeBounds(id: NodeId): Bounds | null;
-}
 /**
  * @experimental
- * The world bounds `ref` names — a point comes back as a zero-size rect — or
- * `null` when it names nothing right now (no pointer, a missing node, a
- * malformed value).
+ * The last transform recorded against `scene`, which `transformAgain` repeats.
  */
-declare function resolveSpatialReference(ref: SpatialReference | unknown, src: SpatialReferenceSources): Bounds | null;
-
-/** Edge or center the selection should align to within the reference's
- *  bounds (rotated members contribute their ink extent). */
-type AlignEdge = 'left' | 'right' | 'top' | 'bottom' | 'center-x' | 'center-y';
-/** @experimental What the selection aligns to: `'union'` — the selection's
- *  own visual union AABB, the default — or a {@link SpatialReference}. */
-type AlignReference = 'union' | SpatialReference;
-/** @experimental The bounds each member of `bounds` aligns to under `to`, or
- *  `null` when there is nothing to align: a union of fewer than two members,
- *  an empty selection, or a reference that names nothing right now. */
-declare function alignTargetBounds(bounds: readonly Bounds[], to: AlignReference | undefined, src: SpatialReferenceSources): Bounds | null;
-/** Adapter for `useAlign`. */
-interface AlignAdapter<TPose> {
-    getSelection(): NodeId[];
-    /** The pose as stored — local to the node's parent. */
-    getPose(id: NodeId): TPose;
-    /** The parent chain, for a scene whose container poses define a frame.
-     *  Omit it (or leave `composition` unset) for an absolute-pose scene. */
-    getParent?(id: NodeId): NodeId | null;
-    applyOps?(ops: Op[], label?: string): void;
-}
-/** Options for `useAlign`. */
-interface UseAlignOptions<TPose> {
-    /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
-     *  for `{x,y,width,height}` poses. Pass `pathPoseDescriptor` for `Path`
-     *  poses so polygon coords translate correctly. */
-    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. */
-    composition?: PoseComposition<TPose>;
-}
-/** Return shape of `useAlign`. */
-interface UseAlignReturn {
-    /** Imperative trigger. `to` defaults to `'union'`, which needs two items;
-     *  any other reference aligns a single item too. `'pointer'` reads the
-     *  surrounding `<PointerContextProvider>`. */
-    align(edge: AlignEdge, to?: AlignReference): void;
-}
-/** Compute the (dx, dy) translation that moves AABB `b` so that the requested
- *  `edge`/center matches the corresponding feature of the union AABB `u`. */
-declare function alignDeltaFor(b: Bounds, u: Bounds, edge: AlignEdge): {
-    dx: number;
-    dy: number;
-};
-/** Align the current selection to a shared edge or center of the selection's
- *  union AABB, or of another reference. Single batch — one undo step.
- *
- *  The edge is a world edge: bounds are measured and translated in world, and
- *  each result is stored back in its own parent's frame. */
-declare function useAlign<TPose>(adapter: AlignAdapter<TPose>, options?: UseAlignOptions<TPose>): UseAlignReturn;
-
+declare function lastTransform(scene: object): RepeatableTransform | undefined;
 /**
- * Pose-flip helpers used by `flipAction` (via `defaults/flip.ts`).
- *
- * These were extracted from the legacy `useFlip` hook when it was removed —
- * they remain because the descriptor-style `flipAction` still needs to reflect
- * arbitrary `TPose` values through a `PoseDescriptor`.
+ * @experimental
+ * Remember `transform` as the last one `scene` underwent, `subject` being the
+ * ids selected once it landed. A translate of exactly the copies a
+ * `duplicate` just made folds into it, so the copies' offset from their
+ * sources is what repeats: duplicate, drag the copy, and each repeat steps
+ * one more copy along.
  */
-
-/** Axis for flip. `'x'` mirrors horizontally (left↔right); `'y'` mirrors vertically (top↔bottom). */
-type FlipAxis = 'x' | 'y';
-/** How a multi-selection flip chooses its pivot.
- *
- *  - `'each'` — every pose mirrors about its own AABB; spatial layout of the
- *    selection is unchanged, individual items are reflected in place.
- *  - `'union'` — every pose mirrors about the selection's union AABB; items
- *    swap sides as well as reflect, matching Illustrator/Figma defaults.
- *  - a {@link SpatialReference} — every pose mirrors about the center of the
- *    bounds it names: the pointer, a world point or rect, or a key node. */
-type FlipPivot = 'each' | 'union' | SpatialReference;
-
-/** Axis along which selection is distributed. `'x'` spreads horizontally. */
-type DistributeAxis = 'x' | 'y';
-/** `'centers'` spaces centers equally; `'gaps'` makes the gap between
- *  consecutive items equal. Both measure a rotated item by its ink extent.
- *  Endpoints stay put in both modes. */
-type DistributeMode = 'centers' | 'gaps';
-/** Adapter for `useDistribute`. */
-interface DistributeAdapter<TPose> {
-    getSelection(): NodeId[];
-    /** The pose as stored — local to the node's parent. */
-    getPose(id: NodeId): TPose;
-    /** The parent chain, for a scene whose container poses define a frame.
-     *  Omit it (or leave `composition` unset) for an absolute-pose scene. */
-    getParent?(id: NodeId): NodeId | null;
-    applyOps?(ops: Op[], label?: string): void;
-}
-/** Options for `useDistribute`. */
-interface UseDistributeOptions<TPose> {
-    /** Projection between `TPose` and bounds. Defaults to `RECT_POSE_DESCRIPTOR`
-     *  for `{x,y,width,height}` poses. */
-    geometry?: PoseDescriptor<TPose>;
-    /** Default mode when `distribute(axis)` is called without one. Default 'centers'. */
-    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. */
-    composition?: PoseComposition<TPose>;
-}
-/** Return shape of `useDistribute`. */
-interface UseDistributeReturn {
-    /** Imperative trigger. No-op when fewer than 3 items selected. */
-    distribute(axis: DistributeAxis, mode?: DistributeMode): void;
-}
-/** Distribute the current multi-selection along `axis`. Requires ≥3 items;
- *  no-op otherwise. Endpoints (min and max along the axis) stay put; the
- *  remaining items are repositioned. Single batch — one undo step.
- *
- *  The span being divided is a world span: bounds are measured and translated
- *  in world, and each result is stored back in its own parent's frame. */
-declare function useDistribute<TPose>(adapter: DistributeAdapter<TPose>, options?: UseDistributeOptions<TPose>): UseDistributeReturn;
+declare function recordTransform(scene: object, transform: RepeatableTransform, subject: readonly string[]): void;
+/** @experimental Drop what `scene` remembers, so `transformAgain` has nothing to repeat. */
+declare function forgetTransform(scene: object): void;
 
 /** What {@link createPoseTarget} takes. */
 interface PoseTargetOptions<TPose> {
@@ -11253,6 +11602,11 @@ declare function PenIcon({ className, size }: IconProps): react.JSX.Element;
  *  and a thumb stub. Used for `useHandTool` (viewport pan). */
 declare function HandIcon({ className, size }: IconProps): react.JSX.Element;
 
+/** Knife — an outlined handle on the diagonal with a filled blade whose
+ *  spine continues the handle's upper edge to the tip at lower-left. Used
+ *  for `useSliceTool`. */
+declare function SliceIcon({ className, size }: IconProps): react.JSX.Element;
+
 /** Placeholder for tools without `presentation.icon`. A circle with "?"
  *  inside — readable, debuggable, not hidden. */
 declare function UnknownIcon({ className, size }: IconProps): react.JSX.Element;
@@ -11322,6 +11676,21 @@ declare function CreateOutlinesIcon(): react.JSX.Element;
  */
 declare function OutlineStrokeIcon(): react.JSX.Element;
 
+/**
+ * Retract handles: a sharp corner on its anchor, with the handle stubs
+ * either side pointing in toward it.
+ *
+ * @experimental
+ */
+declare function RetractHandlesIcon(): react.JSX.Element;
+/**
+ * Make handles symmetric: a smooth curve through its anchor, with one handle
+ * line across it ending in two equal knobs.
+ *
+ * @experimental
+ */
+declare function SymmetricHandlesIcon(): react.JSX.Element;
+
 /**
  * Cut: scissors.
  *
@@ -11346,6 +11715,12 @@ declare function PasteIcon(): react.JSX.Element;
  * @experimental
  */
 declare function DuplicateIcon(): react.JSX.Element;
+/**
+ * Transform again: a step-and-repeat run of three squares, the last filled.
+ *
+ * @experimental
+ */
+declare function TransformAgainIcon(): react.JSX.Element;
 /**
  * Group: corner brackets framing two filled rects.
  *
@@ -11503,4 +11878,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, type ActionGlyphProps, type ActionShortcut, ActionsProviderIfRoot, type AddLayerSpec, type AddNodeSpec, type Affordance, type AffordanceBinding, type AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, type AlignEdge, AlignLeftIcon, type AlignReference, AlignRightIcon, AlignTopIcon, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimateToBoundsOptions, type AnimatedReflow, type AnyTool, AreaSelectAdapter, type AreaSelectDep, type ArrangeArgs, type ArrangedPose, ArrowIcon, BUILTIN_TOOL_IDS, type BaseFeature, type BindRigOptions, type Bivariant, type BooleanOp, type BooleanOpOptions, type BooleanOpPreview, type BooleanOpResult, type BooleanPreviewPiece, type BooleanStrokes, type BooleansAdapter, BoundsConstraint, BringForwardIcon, BringToFrontIcon, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COMPOSITE_FEATURES, type CameraProps, type CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type ChildOrder, type ChromeCtx, type ChromeId, type ChromeState, type ClampBounds, type ClipFromPoseFn, type ClipboardDep, type ClipboardIngestCtx, ClipboardSnapshot, type CoalescedCtx, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type CompositeFeature, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContainerBounds, type ContainerNode, type ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, CopyIcon, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, type CreateOutlinesAdapter, CreateOutlinesIcon, type CreateOutlinesResult, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, type CustomPaintContext, CutIcon, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATE_BEHAVIORS, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_ROTATION_SNAP_STEP, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DecayLoopConfig, type DefaultTextData, type DeleteArgs, DeleteIcon, DepRegistryProviderIfRoot, type DerivePathFn, type DerivePoseFn, type DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type DistributeAdapter, type DistributeAxis, DistributeHorizontalIcon, type DistributeMode, DistributeVerticalIcon, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DropZoneOptions, DuplicateIcon, type EditAnchorsDep, type EditedLayerOf, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_ACCENT, FEATURE_ACTION_IDS, type Feature, type FeedDelta, type FeedNode, type FitViewToBoundsOptions, type FlipAxis, type FlipPivot, FlipXIcon, FlipYIcon, type FrameStats, GHOST_STROKE, type GateLayerOptions, type GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, GroupIcon, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HitTestView, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, IDENTITY_POSE_COMPOSITION, type IconProps, ImageIcon, type InertiaConfig, type IngestCtx, type IngestionDep, InsertAdapter, type InsertArgs, InsertBehavior, type InsertDep, type InsertExtras, type InsertLive, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, IntersectIcon, 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, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LassoSelectDep, type LayerCommandCache, type LayerDrawFailure, type LayerDrawSpan, LayerEnumerableAdapter, type LayerFrameStats, type LayerGroup, type LayerHit, type LayerRecord, type LayerSlotValue, type LayersMap, type LayoutArrivalOptions, type LayoutDep, LayoutDropTargetMode, type LayoutFrame, type LayoutMove, type LayoutRef, type LayoutSource, LayoutStrategy, type LeafNode, type LifecycleAdapter, type LifecycleAnimation, LineIcon, type LinePoint, type LongPressFeedbackOptions, MergeIcon, type MomentumOptions, MoveAdapter, MoveBehavior, type MoveToIndexArgs, type NestedHitOpts, type NestedHitTester, type NodeAtPointDep, type NodeClientRect, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, type OpFactory, type OpenFilePickerOptions, type OpsApplier, OrderedAdapter, OriginProjection, type OutlinePathSpec, OutlineStrokeIcon, type OutlineStrokeResult, type Overlay, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, type PanBounds, ParallaxOpts, PasteCtx, PasteIcon, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, type PathEditHost, type PathEditingOverlayStyle, type PathPaint, type PenContinuation, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedRig, PlaneMap, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, type PolygonPoint, type PoseAdapter, type PoseAnimationAdapter, type PoseCascade, type PoseClosure, type PoseComposition, PoseDescriptor, type PoseFeed, type PoseHold, type PoseOverride, type PoseOverrides, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PoseTargetOptions, type PoseTargetScene, type PosedNode, type PressureToWidthOptions, type PreviewNode, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, type RecordedViewport, RectIcon, type RectPose, RedoIcon, type RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, RegionPickView, type RegisterNodeShapeOptions, type RegisteredOp, type RenderDebugSnapshotArgs, type RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RequirementMismatch, ResizeAdapter, type ResizePolicy, type ResolvableView, type ResolvedOverlay, type RestPath, type Rig, type RigApply, type RigApplyContext, type RigEditState, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, SCENE_CANVAS_FEATURES, SCENE_HISTORY_FORM, SELECTION_MOVE_ID, SELECTION_RESIZE_ID, SELECTION_ROTATE_ID, SELECTION_TRANSFORM_ID, SHAPE_KINDS, type Scene, type SceneAdapterSelection, type SceneArrivalHandler, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, type SceneClipTargetsOptions, type Node as SceneNode, type SceneNodeClientRectOpts, type SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionRotateOptions, type SelectionStore, type SelectionTransformOptions, SendBackwardIcon, SendToBackIcon, type SerializedLayer, type SerializedNode, type SerializedScene, type SerializedSceneHistory, type SetChildOrderArgs, type SetDataArgs, type SetLayerArgs, type SetLayoutArgs, type SetPathArgs, type SetPathFields, type SetSelectionArgs, type SetTextArgs, type ShapeCoversPointOptions, type ShapeKind, type ShapeKindDescriptor, type ShapeKindsWhere, type SiblingSlot, type SliceDep, type SliceLeaf, type SlicePiece, type SliceScratch, type SliceableNode, type SnapDep, SnapStrategy, type SpatialReference, type SpatialReferenceSources, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StrokeRegionOptions, type StylusData, SubtractIcon, type SurfaceContribution, type SvgIngestOptions, type SvgUnpacker, type SystemLayerRecord, type SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, type TargetTransform, type TextEditDep, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, type TransformArgs, TrimIcon, type TweenPoseOptions, UNION_OF_CHILDREN, UndoIcon, UngroupIcon, UnionIcon, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type UseBoneToolOptions, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, 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 UseToolsOptions, type UseWeightToolOptions, type UserLayerRecord, VERSION, VIEW_ANIMATION_KEY, type VelocityTracker, type VersionCheck, type ViewAnimationApi, type ViewAnimationOptions, type ViewApi, type ViewChannel, type ViewLike, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, type ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WeighedPath, type WeightEnv, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenPoseTargetOptions, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, actionShortcuts, alignDeltaFor, alignTargetBounds, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyCreateOutlines, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, asNodeId, axisAlignedBounds, bindRig, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, checkRequirements, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, clipboardPasteEventAction, cloneAction, coarsePointer, composeAffordanceLayer, composeRectPose, composeRigidPose, composeSelectionPose, composeWorldPose, composesFrames, computeFitViewport, computeSliceOps, computeWheelAction, cond, constrainTo45, createArrangeOp, createBoneOverlay, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createRigEditState, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetLayerOp, createSetLayoutOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, createWeightOverlay, createWrittenPoseTarget, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, depsUnchanged, derivedDepOf, derivedPose, dispatchApplyBatch, documentPose, dragPanContribution, dragPointOf, drawLayers, drawOneLayer, editAnchorsAction, editingLayer, effectivePose, enterTextEditAction, enumerateAnchors, findNodeShape, findShapeBounds, findShapeInk, findShapeSilhouette, fitToBounds, fitViewToBounds, fitZoom, flattenPreviews, focused, forEachCoalesced, gateLayer, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, insertAction, insertLayer, insertPreviewExtent, interpolateView, isLayerPainted, isLayerVisible, keySpecShortcut, kitTextHandler, lassoSelectAction, layoutArrivalHandler, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, mergeAlphaFromPrev, mergeContributions, modeDecorationLayer, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nestedHitTester, never, normalizeView, normalizeZoom, not, onEmptyCanvas, opFactoryRegistry, openFilePicker, or, paintAlpha, paintWithAlpha, paintWithColor, paintedLayers, paletteInsertPaint, parseDebugFlags, pathOriginProjection, pathPaintOf, pathPoseDescriptor, pickTopMostHit, pinchZoomAction, placeSkeleton, placedRig, planPixelRender, pointRegionFrame, poseAxes, pressureToWidth, previewBooleanOp, rasterToPng, rebaseLocalPose, rebuildOp, reconcileSpecs, registerContentHandler, registerNodeShape, registerOpFactory, registeredOpNames, releaseCanvasRenderer, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveOverlays, resolvePreviews, resolveSpatialReference, resolveVisibility, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotationDegreesUnit, rotationHandle, satisfiesRange, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseTarget, sceneSelectionStore, sceneToAdapter, sceneUnitScopes, screenToWorld, screenTolerance, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, shapeCoversPoint, sliceAction, snap, snapRotationWithModifier, solid, springPose, stableStringify, staggerSpringPose, startThresholdDrag, strokeOf, strokeRegion, strokeWith, subscribeToSources, toHex8, translateRectPose, tweenPose, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnimatedReflow, useAutoCenter, useBoneTool, useBooleans, useBooleansAdapter, useCanvasSize, useCreateOutlinesAdapter, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGradientKinds, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLayoutArrivals, useLineTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useStandardActions, useStarTool, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewAnimationOn, useWeightTool, viewAxes, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, warmRender, watchDevicePixelRatio, weighedPaths, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, workspaceTintLayer, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, type ActionGlyphProps, type ActionShortcut, ActionsProviderIfRoot, type AddLayerSpec, type AddNodeSpec, type Affordance, type AffordanceBinding, type AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, type AlignEdge, AlignLeftIcon, type AlignReference, AlignRightIcon, AlignTopIcon, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, type AnimateToBoundsOptions, type AnimatedReflow, type AnyTool, AreaSelectAdapter, type AreaSelectDep, type ArrangeArgs, type ArrangedPose, ArrowIcon, BUILTIN_TOOL_IDS, type BaseFeature, type BindRigOptions, type Bivariant, type BooleanOp, type BooleanOpOptions, type BooleanOpPreview, type BooleanOpResult, type BooleanPreviewPiece, type BooleanStrokes, type BooleansAdapter, BoundsConstraint, BringForwardIcon, BringToFrontIcon, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COMPOSITE_FEATURES, type CameraProps, type CanvasDebugSink, type CanvasExtensionApi, type CanvasHelpers, type CanvasLayers, type CanvasProps, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewCamera, type CanvasViewHandle, type CanvasViewHelpers, type CanvasViewProps, type CanvasViewState, type ChildOrder, type ChromeCtx, type ChromeId, type ChromeState, type ClampBounds, type ClipFromPoseFn, type ClipboardDep, type ClipboardIngestCtx, ClipboardSnapshot, type CoalescedCtx, type CommonAffordanceScratch, type ComposeSelectionPoseOpts, type CompositeFeature, type ComputeSliceOpsArgs, type ComputeSliceResult, type Condition, ContainerBounds, type ContainerNode, type ContentHandlerEntry, type Contribution, type ContributionChrome, type ContributionDepReader, type ContributionFrameCtx, type CopiesFromPoseFn, CopyIcon, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateDebugOverlayLayerOpts, type CreateOutlinesAdapter, CreateOutlinesIcon, type CreateOutlinesResult, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CustomLayerEntry, type CustomPaintContext, CutIcon, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE, DEFAULT_INK, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATE_BEHAVIORS, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_ROTATION_SNAP_STEP, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DRAG_PAN_ID, type DebugConfig, type DebugFeature, type DebugSnapshot, type DebugStroke, type DebugStrokes, type DebugTheme, type DecayLoopConfig, type DefaultTextData, type DeleteArgs, DeleteIcon, DepRegistryProviderIfRoot, type DerivePathFn, type DerivePoseFn, type DerivedDep, DeviceProfileProvider, type DeviceProfileProviderProps, type Dims, type DistributeAdapter, type DistributeAxis, DistributeHorizontalIcon, type DistributeMode, DistributeVerticalIcon, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCanvas, type DrawCanvasDraw, type DrawCanvasProps, type DropZoneOptions, DuplicateIcon, type EditAnchorsDep, type EditedLayerOf, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_ACCENT, FEATURE_ACTION_IDS, type Feature, type FeedDelta, type FeedNode, type FitViewToBoundsOptions, type FlipAxis, type FlipPivot, FlipXIcon, FlipYIcon, type FrameStats, GHOST_STROKE, type GateLayerOptions, type GeneratedShape, type GeometryProjection, GestureContext, type GesturePreviewSource, type GestureSource, GroupIcon, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HitTestView, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, type HoverTracking, IDENTITY_POSE_COMPOSITION, INSERT_REPOSITION_BINDING, type IconProps, ImageIcon, type InertiaConfig, type IngestCtx, type IngestionDep, InsertAdapter, type InsertArgs, InsertBehavior, type InsertDep, type InsertExtras, type InsertIntoDep, type InsertLive, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type InsertPaint, type InsertPreviewExtent, type InsertPreviewGeometry, type InsertPreviewLike, type InsertPreviewOverlay, type InsertToolOptions, IntersectIcon, 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, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LassoSelectDep, type LayerCommandCache, type LayerDrawFailure, type LayerDrawSpan, LayerEnumerableAdapter, type LayerFrameStats, type LayerGroup, type LayerHit, type LayerRecord, type LayerSlotValue, type LayersMap, type LayoutDep, LayoutDropTargetMode, type LayoutFrame, type LayoutMove, type LayoutRef, LayoutStrategy, type LeafNode, type LifecycleAdapter, type LifecycleAnimation, LineIcon, type LinePoint, type LongPressFeedbackOptions, MergeIcon, type MomentumOptions, MoveAdapter, MoveBehavior, type MoveToIndexArgs, type NestedHitOpts, type NestedHitTester, type NodeAtPointDep, type NodeClientRect, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, type OpFactory, type OpenFilePickerOptions, type OpsApplier, OrderedAdapter, OriginProjection, type OutlinePathSpec, OutlineStrokeIcon, type OutlineStrokeResult, type Overlay, type OverlayPoint, type OverlayVisibilityId, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type Page, type PageLayoutOptions, type PagesLayerOptions, type PaintBoundsFn, PaintKindEntry, type PaintedSkins, type PanBounds, ParallaxOpts, PasteCtx, PasteIcon, PasteOmission, type PathAnchor, type PathAnchorAffordanceOptions, type PathEditHost, type PathEditingOverlayStyle, type PathPaint, type PathSymmetryDep, type PenContinuation, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickSlop, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PlacedNode, type PlacedPage, type PlacedRig, PlaneMap, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PolygonGenerator, PolygonIcon, type PolygonPoint, type PoseAdapter, type PoseAnimationAdapter, type PoseCascade, type PoseClosure, type PoseComposition, PoseDescriptor, type PoseFeed, type PoseHold, type PoseOverride, type PoseOverrides, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PoseTargetOptions, type PoseTargetScene, type PosedNode, type PressureToWidthOptions, type PreviewNode, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, type RasterImage, type RasterRenderArgs, type RasterSession, type RasterSessionOptions, type RecordedBounds, type RecordedHandle, type RecordedHitbox, type RecordedLayer, type RecordedOrigin, type RecordedSnap, type RecordedViewport, RectIcon, type RectPose, RedoIcon, type RedrawSource, type ReflowScene, ReflowTransition, type ReflowTransitionOptions, RegionPickView, type RegisterNodeShapeOptions, type RegisteredOp, type RenderDebugSnapshotArgs, type RenderLayer, type RenderNeeds, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderArgs, type ReorderDirection, type ReorderRestoreEntry, type ReparentArgs, type RepeatableTransform, type RequirementMismatch, ResizeAdapter, type ResizePolicy, type ResolvableView, type ResolvedOverlay, type RestPath, RetractHandlesIcon, type Rig, type RigApply, type RigApplyContext, type RigEditState, type RigNodeData, type RigNodeParts, type RigNodeSource, type RigScene, RotateAdapter, RotateBehavior, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, SCENE_CANVAS_FEATURES, SCENE_HISTORY_FORM, SELECTION_MOVE_ID, SELECTION_RESIZE_ID, SELECTION_ROTATE_ID, SELECTION_TRANSFORM_ID, SHAPE_COUNT_RANGE, SHAPE_KINDS, STAR_RATIO_RANGE, type Scene, type SceneAdapterSelection, type SceneArrivalHandler, SceneArrivalRefused, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasLayers, type SceneCanvasLongPress, type SceneCanvasProps, type SceneCanvasViewport, type SceneClipTargetsOptions, type Node as SceneNode, type SceneNodeClientRectOpts, type SceneRegistry, type SceneSlotConfig, type SceneSlotLayers, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewCull, type SceneViewDrawOne, type SceneViewLayers, type ScopedScene, type ScreenSlop, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionMoveOptions, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type SelectionRotateOptions, type SelectionStore, type SelectionTransformOptions, SendBackwardIcon, SendToBackIcon, type SerializedLayer, type SerializedNode, type SerializedScene, type SerializedSceneHistory, type SetChildOrderArgs, type SetDataArgs, type SetLayerArgs, type SetLayoutArgs, type SetPathArgs, type SetPathFields, type SetSelectionArgs, type SetTextArgs, type ShapeCoversPointOptions, type ShapeGenerator, type ShapeKind, type ShapeKindDescriptor, type ShapeKindsWhere, type SiblingSlot, type SliceDep, SliceIcon, type SliceLeaf, type SlicePiece, type SliceScratch, type SliceableNode, type SnapDep, SnapStrategy, type SpatialReference, type SpatialReferenceSources, type SpringPoseOptions, type StaggerSpringPoseOptions, type StandardSlotConfig, type StandardSlotName, type StarGenerator, StarIcon, type StarPoint, type StrokeRegionOptions, type StylusData, SubtractIcon, type SurfaceContribution, type SvgIngestOptions, type SvgUnpacker, SymmetricHandlesIcon, type SystemLayerRecord, type SystemLayerSpec, TOOL_DRIVEN_ACTION_IDS, type TargetTransform, type TextEditDep, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type Tool, type ToolDef, type ToolsApi, TransformAgainIcon, type TransformArgs, TrimIcon, type TweenPoseOptions, UNION_OF_CHILDREN, UndoIcon, UngroupIcon, UnionIcon, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type UseBoneToolOptions, type UseBooleansOptions, type UseBooleansReturn, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeyStateOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, 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 UseToolsOptions, type UseWeightToolOptions, type UserLayerRecord, VERSION, VIEW_ANIMATION_KEY, type VelocityTracker, type VersionCheck, type ViewAnimationApi, type ViewAnimationOptions, type ViewApi, type ViewChannel, type ViewLike, type ViewRect, type ViewResolver, type ViewTarget, type ViewTransform, type ViewportDims, type ViewportLayer, type ViewportZoomAnimateOptions, type ViewportZoomOptions, type VisibilityRules, WHEEL_ZOOM_STEP, type WarmRenderOptions, WeaselProvider, type WeaselProviderProps, type WeighedPath, type WeightEnv, type WheelInput, type WheelPanOptions, type WheelPanOpts, type WorkspaceTintLayerOptions, type WrittenPoseTargetOptions, type ZoomAxis, type ZoomBound, type ZoomClampOpts, type ZoomFactor, accentColorOf, actionIs, actionShortcuts, adjacentPage, alignDeltaFor, alignTargetBounds, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyCreateOutlines, applyOpsTo, applyOutlineStroke, areaSelectAction, areaSelectContribution, asNodeId, axisAlignedBounds, axisZoomFactor, bindRig, buildChromeCtx, buildDebugOverlayCommands, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, checkRequirements, clampShapeGenerator, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, clipboardPasteEventAction, cloneAction, coarsePointer, composeAffordanceLayer, composeRectPose, composeRigidPose, composeSelectionPose, composeWorldPose, composesFrames, computeFitViewport, computeSliceOps, computeWheelAction, cond, constrainTo45, createArrangeOp, createBoneOverlay, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createHistory, createInsertOp, createKeyState, createLongPressFeedbackContribution, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createPoseTarget, createRasterSession, createReflowTransition, createReorderOp, createReparentOp, createRigEditState, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetChildOrderOp, createSetDataOp, createSetLayerOp, createSetLayoutOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, createWeightOverlay, createWrittenPoseTarget, cycleFill, dataRestPath, debugSnapshotArgs, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultNodeProperties, defaultNodeRouting, defaultPaintBounds, defaultVisibilityRules, definesFrame, depsUnchanged, derivedDepOf, derivedPose, dispatchApplyBatch, documentPose, dragPanContribution, dragPointOf, drawLayers, drawOneLayer, editAnchorsAction, editingLayer, effectivePose, enterTextEditAction, enumerateAnchors, findNodeShape, findShapeBounds, findShapeInk, findShapeSilhouette, fitToBounds, fitViewToBounds, fitViewToPage, fitZoom, flattenPreviews, focused, forEachCoalesced, forgetTransform, gateLayer, gesturePlaneReader, gestureViewReader, gesturing, getAlpha01, getNodeShapes, getStylusData, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, inPlane, inferredNodeProperties, inferredNodeRouting, insertAction, insertLayer, insertPreviewExtent, insertRepositionAction, interpolateView, isLayerPainted, isLayerVisible, isOverChildren, isShapeGenerator, keySpecShortcut, kitTextHandler, lassoSelectAction, lastTransform, layoutPages, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, mergeAlphaFromPrev, mergeContributions, modeDecorationLayer, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nestedHitTester, never, normalizeView, normalizeZoom, not, onEmptyCanvas, opFactoryRegistry, openFilePicker, or, overChildren, pageAt, pageOfBounds, pagesBounds, pagesLayer, paintAlpha, paintWithAlpha, paintWithColor, paintedLayers, paletteInsertPaint, parseDebugFlags, pathOriginProjection, pathPaintOf, pathPoseDescriptor, pickTopMostHit, pinchZoomAction, placeSkeleton, placedRig, planPixelRender, pointRegionFrame, poseAxes, pressureToWidth, previewBooleanOp, rasterToPng, rebaseLocalPose, rebuildOp, reconcileSpecs, recordTransform, regenerateShape, registerContentHandler, registerNodeShape, registerOpFactory, registeredOpNames, releaseCanvasRenderer, renderDebugSnapshot, renderNeeds, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveOverlays, resolvePreviews, resolveSpatialReference, resolveVisibility, rigFromNode, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotationDegreesUnit, rotationHandle, satisfiesRange, sceneClipTargets, sceneFromJSON, sceneNodeClientRect, scenePoseTarget, sceneSelectionStore, sceneToAdapter, sceneUnitScopes, screenToWorld, screenTolerance, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, selectionLayer, selectionMoveBindings, selectionMoveContribution, selectionResizeBindings, selectionResizeContribution, selectionRotateBindings, selectionRotateContribution, selectionTransformBindings, selectionTransformContribution, settleShapeGenerator, shapeCoversPoint, shapeGeneratorOf, shapeGeneratorPath, sliceAction, snap, snapRotationWithModifier, solid, splitOverChildren, springPose, stableStringify, staggerSpringPose, startThresholdDrag, strokeOf, strokeRegion, strokeWith, subscribeToSources, toHex8, translateRectPose, tweenPose, unionAABB, unionBounds, unionOfChildren, unionOfChildrenVia, unplaceSkeleton, useAlign, useAnimatedReflow, useAutoCenter, useBoneTool, useBooleans, useBooleansAdapter, useCanvasSize, useCreateOutlinesAdapter, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGradientKinds, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeyModifiers, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePaintKind, usePaintKinds, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseDescriptorDepSource, usePoseRun, useRectTool, useResizePolicy, useRig, useRigNode, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSliceDep, useSliceDepSource, useSliceTool, useStandardActions, useStarTool, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewAnimationOn, useWeightTool, viewAxes, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, warmRender, watchDevicePixelRatio, weighedPaths, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withoutShapeGenerator, workspaceTintLayer, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };