@weasel-js/core 1.4.2 → 1.4.4

package/dist/index.d.ts

@@ -1,33 +1,33 @@
 import * as React$1 from 'react';
-import React__default, { RefObject, ReactNode, Ref, MouseEvent as MouseEvent$1, ComponentType, MutableRefObject } from 'react';
+import React__default, { RefObject, ReactNode, Ref, MouseEvent, ComponentType, MutableRefObject } from 'react';
 import { a as ViewTransform, V as View, Z as ZoomBound, b as ZoomFactor } from './view-DSQgxBJB.js';
 export { s as screenToWorld, v as viewToTransform, w as worldToScreen } from './view-DSQgxBJB.js';
-import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-nnXU4VjN.js';
-export { I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, c as Unit, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-nnXU4VjN.js';
-import { R as RenderLayer, D as Dims, a as DeviceProfile, b as DetectedDeviceFacts, C as Condition, c as Rule, d as RuleCtx, V as VisibilityRules, e as ChromeCtx, f as ChromeId, A as Action, I as InertiaConfig, g as ViewAnimationOptions, h as DepSchema, S as SliceDep, i as ActionsRegistry, T as Tool, j as AffordanceHit, k as Dispatcher, l as ToolDef, m as ViewportToolDef, n as AnyTool, O as OverlayPosition, o as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, p as OngoingOverlay, q as ChromeState, P as PanBounds, r as SelectionApi, U as UseSelectionOptions, s as InsertExtras, B as BuiltinShapeToolId, G as GeometryProjection, t as ContentHandlerEntry, u as SvgIngestOptions, v as ActionsProp, w as Animator, x as Affordance, y as AffordanceRegion, z as AffordanceBinding, E as CommonAffordanceScratch, F as ColorOverrideRegistry, J as BooleansAdapter, K as UseAnimatorOptions, M as SpringPresetName, N as EasingSpec, Q as AnimationHandle, W as VertexColorChannel, X as SampledTrack, Y as Eligibility, Z as BindingScope, _ as Contribution, $ as ScopedBinding } from './registry-BwY_DxJM.js';
-export { a0 as ALWAYS, a1 as ActionDeps, a2 as ActionDisabledReason, a3 as ActionEnabledResult, a4 as ActionEntry, a5 as ActionsProvider, a6 as ActiveToolContextProvider, a7 as ActiveToolContextProviderIfRoot, a8 as ActiveToolContextProviderProps, a9 as ActiveToolContextValue, aa as AnimateToBoundsOptions, ab as AreaSelectDep, ac as BezierEasing, ad as BindingOpts, ae as BooleanOp, af as BooleanOpResult, ag as BoundGesture, ah as BuildRuleCtxArgs, ai as ClaimableGesture, aj as ClipboardDep, ak as ClipboardIngestCtx, al as ColorOverride, am as ColorOverrideFn, an as CustomPaintContext, ao as DecayLoopConfig, ap as DecayOptions, aq as DepName, ar as DepRegistry, as as DepRegistryProvider, at as DispatcherContext, au as DragSample, av as EASINGS, aw as EasingFn, ax as EasingName, ay as EditAnchorsDep, az as EventTrack, aA as GestureBinding, aB as IDENTITY_POSE_COMPOSITION, aC as ImmediateInvoker, aD as IngestCtx, aE as IngestionDep, aF as InsertDep, aG as Interpolate, aH as InterpolatorFactory, aI as InvocationCtx, aJ as Invoker, aK as KIT_SHAPE_KINDS, aL as Keyframe, aM as LassoSelectDep, aN as LayerCommandCache, aO as LayoutDep, aP as LoopFactory, aQ as LoopOptions, aR as MatchResult, aS as NEVER, aT as NestedTimeline, aU as NodeAtPointDep, aV as OngoingHandle, aW as OngoingInvoker, aX as PhysicsHandle, aY as PhysicsOptions, aZ as Point2, a_ as PointerContextProvider, a$ as PointerContextValue, b0 as PointerWorldPos, b1 as PoseAdapter, b2 as PoseComposition, b3 as ResizePolicy, b4 as ResolveAllOptions, b5 as ResolveOnlyResult, b6 as ResolvedCandidate, b7 as SPRING_PRESETS, b8 as SelectionExtendKey, b9 as SelectionMode, ba as Selector, bb as SnapDep, bc as SpringOptions, bd as SpringPreset, be as StaggerBuilder, bf as StaggerDelay, bg as StaggerFactory, bh as StaggerOptions, bi as StaggerPerItem, bj as StaggerSpringPoseOptions, bk as StaggerTweenOptions, bl as SvgUnpacker, bm as TextEditDep, bn as TimelineHandle, bo as TimelineOptions, bp as TimelineTrack, bq as ToolCtx, br as ToolModifiers, bs as ToolPresentation, bt as ToolSlot, bu as Track, bv as TweenLoopOptions, bw as TweenOptions, bx as UiOngoingControl, by as VIEW_ANIMATION_KEY, bz as ViewAnimationApi, bA as ViewApi, bB as ViewChannel, bC as actionBindings, bD as applyBooleanOp, bE as buildRuleCtx, bF as clipboardCopyAction, bG as clipboardCutAction, bH as composeRectPose, bI as composeWorldPose, bJ as createDispatcher, bK as cubicBezierEasing, bL as decomposeRectPose, bM as describeRule, bN as drawLayers, bO as drawOneLayer, bP as easeIn, bQ as easeInBack, bR as easeInBounce, bS as easeInCirc, bT as easeInCubic, bU as easeInElastic, bV as easeInExpo, bW as easeInOut, bX as easeInOutBack, bY as easeInOutBounce, bZ as easeInOutCirc, b_ as easeInOutCubic, b$ as easeInOutElastic, c0 as easeInOutExpo, c1 as easeInOutQuad, c2 as easeInOutQuart, c3 as easeInOutQuint, c4 as easeInOutSine, c5 as easeInQuad, c6 as easeInQuart, c7 as easeInQuint, c8 as easeInSine, c9 as easeOut, ca as easeOutBack, cb as easeOutBounce, cc as easeOutCirc, cd as easeOutCubic, ce as easeOutElastic, cf as easeOutExpo, cg as easeOutQuad, ch as easeOutQuart, ci as easeOutQuint, cj as easeOutSine, ck as enterTextEditAction, cl as evaluate, cm as evaluateEnabled, cn as isLayerPainted, co as isLayerVisible, cp as linear, cq as rebaseLocalPose, cr as registerContentHandler, cs as resolveEasing, ct as resolveParams, cu as sliceAction, cv as specificity, cw as translateRectPose, cx as useAction, cy as useActionsRegistry, cz as useActiveToolContext, cA as useDecayLoop, cB as useDepRegistry, cC as useDepSource, cD as useOptionalActiveToolContext, cE as useOptionalDepRegistry, cF as usePointerContext, cG as useSelection, cH as useViewAnimation, cI as worldPoseLookup } from './registry-BwY_DxJM.js';
+import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-0Pbn5B2C.js';
+export { I as IMPERIAL_INCHES, M as METRIC_MM, P as PIXELS, R as RECT_ORIGIN_PROJECTION, c as Unit, f as formatUnit, g as gridSnapStrategy, p as pointToGridCell, r as resolveUnit } from './grid-0Pbn5B2C.js';
+import { R as RenderLayer, D as Dims, a as DeviceProfile, b as DetectedDeviceFacts, C as Condition, c as Rule, d as RuleCtx, V as VisibilityRules, e as ChromeCtx, f as ChromeId, A as Action, I as InertiaConfig, g as ViewAnimationOptions, h as DepSchema, S as SliceDep, i as ActionsRegistry, T as Tool, j as AffordanceHit, k as Dispatcher, l as ToolDef, m as ViewportToolDef, n as AnyTool, O as OverlayPosition, o as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, p as OngoingOverlay, q as ChromeState, r as SelectionApi, s as LayerGroup, U as UseSelectionOptions, t as InsertExtras, B as BuiltinShapeToolId, G as GeometryProjection, u as ContentHandlerEntry, v as SvgIngestOptions, P as PanBounds, w as ActionsProp, x as Animator, y as Affordance, z as AffordanceRegion, E as AffordanceBinding, F as CommonAffordanceScratch, J as ColorOverrideRegistry, K as BooleansAdapter, M as UseAnimatorOptions, N as SpringPresetName, Q as EasingSpec, W as AnimationHandle, X as VertexColorChannel, Y as SampledTrack, Z as Eligibility, _ as BindingScope, $ as Contribution, a0 as ScopedBinding } from './registry-BY-wI9gm.js';
+export { a1 as ALWAYS, a2 as ActionDeps, a3 as ActionDisabledReason, a4 as ActionEnabledResult, a5 as ActionEntry, a6 as ActionsProvider, a7 as ActionsScope, a8 as ActiveToolContextProvider, a9 as ActiveToolContextProviderIfRoot, aa as ActiveToolContextProviderProps, ab as ActiveToolContextValue, ac as AnimateToBoundsOptions, ad as AreaSelectDep, ae as BezierEasing, af as BindingOpts, ag as BooleanOp, ah as BooleanOpResult, ai as BoundGesture, aj as BuildRuleCtxArgs, ak as ClaimableGesture, al as ClipboardDep, am as ClipboardIngestCtx, an as ColorOverride, ao as ColorOverrideFn, ap as CustomPaintContext, aq as DecayLoopConfig, ar as DecayOptions, as as DepName, at as DepRegistry, au as DepRegistryProvider, av as DispatcherContext, aw as DragSample, ax as EASINGS, ay as EasingFn, az as EasingName, aA as EditAnchorsDep, aB as EventTrack, aC as GestureBinding, aD as IDENTITY_POSE_COMPOSITION, aE as ImmediateInvoker, aF as IngestCtx, aG as IngestionDep, aH as InsertDep, aI as Interpolate, aJ as InterpolatorFactory, aK as InvocationCtx, aL as Invoker, aM as KIT_SHAPE_KINDS, aN as Keyframe, aO as LassoSelectDep, aP as LayerCommandCache, aQ as LayerDrawFailure, aR as LayoutDep, aS as LoopFactory, aT as LoopOptions, aU as MatchResult, aV as NEVER, aW as NestedTimeline, aX as NodeAtPointDep, aY as OngoingHandle, aZ as OngoingInvoker, a_ as PhysicsHandle, a$ as PhysicsOptions, b0 as Point2, b1 as PointerContextProvider, b2 as PointerContextValue, b3 as PointerWorldPos, b4 as PoseAdapter, b5 as PoseComposition, b6 as ResizePolicy, b7 as ResolveAllOptions, b8 as ResolveOnlyResult, b9 as ResolvedCandidate, ba as SPRING_PRESETS, bb as SelectionExtendKey, bc as SelectionMode, bd as Selector, be as SnapDep, bf as SpringOptions, bg as SpringPreset, bh as StaggerBuilder, bi as StaggerDelay, bj as StaggerFactory, bk as StaggerOptions, bl as StaggerPerItem, bm as StaggerSpringPoseOptions, bn as StaggerTweenOptions, bo as SvgUnpacker, bp as TextEditDep, bq as TimelineHandle, br as TimelineOptions, bs as TimelineTrack, bt as ToolCtx, bu as ToolModifiers, bv as ToolPresentation, bw as ToolSlot, bx as Track, by as TweenLoopOptions, bz as TweenOptions, bA as UiOngoingControl, bB as VIEW_ANIMATION_KEY, bC as ViewAnimationApi, bD as ViewApi, bE as ViewChannel, bF as actionBindings, bG as applyBooleanOp, bH as buildRuleCtx, bI as clipboardCopyAction, bJ as clipboardCutAction, bK as composeRectPose, bL as composeWorldPose, bM as createDispatcher, bN as cubicBezierEasing, bO as decomposeRectPose, bP as describeRule, bQ as drawLayers, bR as drawOneLayer, bS as easeIn, bT as easeInBack, bU as easeInBounce, bV as easeInCirc, bW as easeInCubic, bX as easeInElastic, bY as easeInExpo, bZ as easeInOut, b_ as easeInOutBack, b$ as easeInOutBounce, c0 as easeInOutCirc, c1 as easeInOutCubic, c2 as easeInOutElastic, c3 as easeInOutExpo, c4 as easeInOutQuad, c5 as easeInOutQuart, c6 as easeInOutQuint, c7 as easeInOutSine, c8 as easeInQuad, c9 as easeInQuart, ca as easeInQuint, cb as easeInSine, cc as easeOut, cd as easeOutBack, ce as easeOutBounce, cf as easeOutCirc, cg as easeOutCubic, ch as easeOutElastic, ci as easeOutExpo, cj as easeOutQuad, ck as easeOutQuart, cl as easeOutQuint, cm as easeOutSine, cn as enterTextEditAction, co as evaluate, cp as evaluateEnabled, cq as isLayerPainted, cr as isLayerVisible, cs as linear, ct as rebaseLocalPose, cu as registerContentHandler, cv as resolveEasing, cw as resolveParams, cx as sliceAction, cy as specificity, cz as translateRectPose, cA as useAction, cB as useActionsRegistry, cC as useActiveToolContext, cD as useDecayLoop, cE as useDepRegistry, cF as useDepSource, cG as useOptionalActiveToolContext, cH as useOptionalDepRegistry, cI as usePointerContext, cJ as useSelection, cK as useViewAnimation, cL as worldPoseLookup } from './registry-BY-wI9gm.js';
 import { Stroke, FillStyle, TextureHandle, TilePatternSpec, GradientKind, GradStop, GradientFill, GradientUnits, MarkerKey, MarkerRef } from '@weasel-js/paint';
 export { FillStyle, GradStop, GradientFill, GradientKind, GradientUnits, KitMarkerKey, MarkerKey, MarkerRef, Region, STROKE_DASH_RATIOS, Stroke, StrokeAlign, StrokeDashStyle, TextureHandle, TilePatternSpec, alignedStrokeRect, dashForStrokeStyle, strokeDashStyleOf } from '@weasel-js/paint';
-import { R as RectPose, S as Scene, N as NodeId, a as Node$1, b as SerializedScene, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-DIQAisSG.js';
-export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, P as PoseOverride, g as PoseOverrides, h as SerializedNode, i as SystemLayerRecord, j as SystemLayerSpec, k as UserLayerRecord, l as asNodeId } from './types-DIQAisSG.js';
-import { B as Bounds, P as PoseProjection, V as ViewportDims } from './geometry-Dtt_k6Dq.js';
-export { F as FitViewToBoundsOptions, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-Dtt_k6Dq.js';
+import { N as NodeId, S as Scene, R as RectPose, a as Node$1, b as SerializedScene, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp, P as PoseOverrides, D as DerivedDep } from './types-bcc7jcUy.js';
+export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, g as PoseOverride, h as SerializedNode, i as SystemLayerRecord, j as SystemLayerSpec, k as UserLayerRecord, l as asNodeId } from './types-bcc7jcUy.js';
+import { B as Bounds, P as PoseProjection, V as ViewportDims } from './geometry-6fCNhAux.js';
+export { F as FitViewToBoundsOptions, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-6fCNhAux.js';
 import { GestureSpec, BodyClassification, IngestItem } from '@weasel-js/gestures';
 export { ClickSpec, DragSpec, DropSpec, GestureSpec, IngestItem, InputEvent, KeyHeldSpec, KeySpec, ModSpec, MultiTouchSpec, PasteSpec, TargetSpec, WheelSpec } from '@weasel-js/gestures';
-import { M as ModifierState, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, a as RotatedPose, e as RotateBehavior, S as SnapStrategy, c as ResizeAnchor, b as MoveBehavior, I as InsertBehavior } from './types-miXHGrZM.js';
-export { A as ActionBehavior, f as AreaSelectOverlay, g as BehaviorMoveResult, h as BehaviorResult, C as CloneBehavior, i as CloneLayer, j as ClonePose, G as GestureContext, k as GroupTransform, l as InsertMoveResult, m as InsertOverlay, n as InsertPoint, o as InsertProposed, p as LassoSelectMoveResult, q as LassoSelectOverlay, r as LassoSelectPose, s as LassoSelectProposed, t as PointSnapContext, d as PointSnapFrame, u as PointSnapResult, v as PointerState, w as ResizeMoveResult, x as ResizeOverlay, y as ResizeProposed, z as RotateMoveResult, D as RotateOverlay, E as RotateProposed } from './types-miXHGrZM.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-Dmthv94u.js';
-export { C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-Dmthv94u.js';
+import { M as ModifierState, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, L as LassoSelectBehavior, a as RotatedPose, e as RotateBehavior, S as SnapStrategy, c as ResizeAnchor, b as MoveBehavior, I as InsertBehavior } from './types-ei3UMl9R.js';
+export { A as ActionBehavior, f as AreaSelectOverlay, g as BehaviorMoveResult, h as BehaviorResult, C as CloneBehavior, i as CloneLayer, j as ClonePose, G as GestureContext, k as GroupTransform, l as InsertMoveResult, m as InsertOverlay, n as InsertPoint, o as InsertProposed, p as LassoSelectMoveResult, q as LassoSelectOverlay, r as LassoSelectPose, s as LassoSelectProposed, t as PointSnapContext, d as PointSnapFrame, u as PointSnapResult, v as PointerState, w as ResizeMoveResult, x as ResizeOverlay, y as ResizeProposed, z as RotateMoveResult, D as RotateOverlay, E as RotateProposed } from './types-ei3UMl9R.js';
+import { U as UseResizeOptions } from './autoPoseDescriptor-DF1SnnSx.js';
+export { A as AUTO_POSE_DESCRIPTOR, C as CORNER_ANCHORS, a as CornerAnchor, e as CornerEdge, b as CornerHandle, c as cornerPoint, d as cornerResizeHandles, h as hitCornerHandle, i as isPathLike, p as pointSnapToGrid } from './autoPoseDescriptor-DF1SnnSx.js';
 import { ResolvedCursor, CursorSpec } from '@weasel-js/cursor';
 export { BakeOptions, CursorGlyph, CursorGlyphName, CursorGlyphSpec, CursorSpec, ResolvedCursor, bakeCursor, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
-import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, b as LassoHitMode, c as LassoSelectAdapter, d as ResizeAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, a as SceneAdapter, f as LayoutSnap } from './types-XBcDEp3Y.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-XBcDEp3Y.js';
+import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, b as LassoHitMode, c as LassoSelectAdapter, d as ResizeAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, a as SceneAdapter, f as LayoutSnap } from './types-DEALFt5F.js';
+export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DEALFt5F.js';
 import { D as DebugSink, a as DebugConfig, b as DebugSnapshot, c as DebugStrokes, d as DebugTheme } from './types-BHK2dkMu.js';
 export { e as DebugFeature, f as DebugStroke, H as HandleKind, g as HitShape, R as RecordedBounds, h as RecordedHandle, i as RecordedHitbox, j as RecordedLayer, k as RecordedOrigin, l as RecordedSnap } from './types-BHK2dkMu.js';
 import { a as PolygonPath, P as Path, b as PathFillRule, R as RectPath } from './path-JEV2c5If.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { D as DrawCommand, b as ShaderProgramHandle, P as PathDrawCommand, M as Mat3$1 } from './DrawCommand-Ch8W63oQ.js';
-export { G as GroupDrawCommand, I as ImageDrawCommand, S as SPRITE_STRIDE, a as ShaderDrawCommand, c as ShaderUniform, e as SpritesDrawCommand, T as TextDrawCommand, m as mat3 } from './DrawCommand-Ch8W63oQ.js';
+import { D as DrawCommand, b as ShaderProgramHandle, P as PathDrawCommand, M as Mat3$1 } from './DrawCommand-CD-ug3d9.js';
+export { E as Effect, G as GroupDrawCommand, I as ImageDrawCommand, S as SPRITE_STRIDE, a as ShaderDrawCommand, c as ShaderUniform, e as SpritesDrawCommand, T as TextDrawCommand, m as mat3, r as registerEffect } from './DrawCommand-CD-ug3d9.js';
 import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
@@ -35,10 +35,10 @@ import { PlacementAlign, Rect, Mat3 } from '@weasel-js/geom';
 export { PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Rect, pathCommandCoordCount } from '@weasel-js/geom';
 import { TextRenderer, TextPose, StyledRun, TextStyle, TextPaint, TextVerticalAlign } from '@weasel-js/text';
 export { DEFAULT_TEXT_STYLE, LaidOutDecoration, LaidOutGroup, LaidOutLineBox, LaidOutOutlineGlyph, LaidOutQuad, LaidOutRuns, LayoutLine, LayoutResult, LayoutRunsOpts, MARKDOWN_RUN_GRAMMAR, MarkdownFontOptions, MeasureFn, MeasureTextBoundsOpts, MeasuredText, PositionedRun, ResolvedRun, ResolvedTextStyle, RunFlag, RunGrammar, RunMarker, SCRIPT_METRICS, StyledRun, TextAlign, TextDirection, TextLineBoxesOpts, TextPaint, TextPose, TextRenderer, TextStyle, TextVerticalAlign, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, toRuns, verticalAlignOffset } from '@weasel-js/text';
-import { g as ShaderProgram } from './stroke-Dq8nL4A2.js';
-export { a as ImageMinification, R as RenderTarget, b as SpriteSheet, f as frameRect, r as resolveStrokeWidth, v as viewToMat3 } from './stroke-Dq8nL4A2.js';
+import { i as ShaderProgram } from './builtins-BXFBXegF.js';
+export { a as ImageMinification, R as RenderTarget, b as SpriteSheet, e as blur, g as frameRect, r as resolveStrokeWidth, v as viewToMat3, h as vignette } from './builtins-BXFBXegF.js';
 import { G as Guide } from './types-D2tTKEU0.js';
-export { U as UseInsertOptions } from './options-CdFl510T.js';
+export { U as UseInsertOptions } from './options-DbYLImvq.js';
 export { UseClipboardOpsOptions, UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './clipboard.js';
 export { cloneByAltDrag } from './clone.js';
 export { FontVariant, LocalFontOutlinesResult, OutlineFontStyle, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
@@ -442,9 +442,11 @@ interface CreateParallaxLayerOpts<TData> extends ParallaxOpts {
 }
 /**
  * Wrap source RenderLayers in a parallax plane. The plane's inner view is
- * derived from the camera view per {@link deriveParallaxView}; source layers
- * run under that inner view and the result is emitted as `space: 'screen'`
- * so the outer Canvas applies no further transform.
+ * derived from the camera view per {@link deriveParallaxView}; each source
+ * layer is drawn through it by `drawOneLayer`, so a `space: 'world'` source
+ * gets the inner view's transform and a `space: 'screen'` one does not. The
+ * plane itself is emitted as `space: 'screen'` — its children already carry
+ * whatever transform they need, and the outer Canvas must add none.
  *
  * **Cosmetic only (v1):** pointer events still target the outer view.
  * Objects on parallax planes are paint, not clickable scene nodes. Use the
@@ -482,23 +484,9 @@ interface SimulationForce<TNode extends SimulationNode = SimulationNode> {
     (alpha: number): void;
     initialize?(nodes: TNode[], random?: () => number): void;
 }
-/** Options for `useSimulation`: the nodes to move, the forces acting on them,
- *  and the cooling schedule that decides when the simulation settles. */
-interface UseSimulationOptions<TNode extends SimulationNode> {
-    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
-    nodes: TNode[];
-    /** Forces applied per tick. Each may implement `initialize` for setup. */
-    forces?: SimulationForce<TNode>[];
-    /** Initial alpha. Default 1. */
-    alpha?: number;
-    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
-    alphaMin?: number;
-    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
-    alphaDecay?: number;
-    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
-    alphaTarget?: number;
-    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
-    velocityDecay?: number;
+/** Options for `useSimulation`: everything {@link SimulationOptions} carries,
+ *  plus the loop's own callbacks and clock. */
+interface UseSimulationOptions<TNode extends SimulationNode> extends SimulationOptions<TNode> {
     /** Fired after each integration step. */
     onTick?: (nodes: TNode[]) => void;
     /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */
@@ -508,7 +496,7 @@ interface UseSimulationOptions<TNode extends SimulationNode> {
     cancelFrame?: (handle: number) => void;
 }
 /**
- * A running force simulation over a set of nodes.
+ * A force simulation over a set of nodes, with no clock of its own.
  *
  * Each tick applies every force and then integrates velocities, scaled by
  * `alpha` — a temperature that decays toward `alphaTarget` so the layout
@@ -516,8 +504,12 @@ interface UseSimulationOptions<TNode extends SimulationNode> {
  * which is what a drag does.
  *
  * Nodes are mutated in place; the simulation holds the array, not a copy.
+ *
+ * Nothing here advances time. {@link Simulation} adds the frame loop; a caller
+ * that wants the whole relaxation at once — a layout pass, a pre-warm, a test
+ * — drives {@link SimulationCore.tick} itself.
  */
-interface Simulation<TNode extends SimulationNode> {
+interface SimulationCore<TNode extends SimulationNode> {
     readonly nodes: TNode[];
     setNodes(nodes: TNode[]): this;
     setForces(forces: SimulationForce<TNode>[]): this;
@@ -531,10 +523,6 @@ interface Simulation<TNode extends SimulationNode> {
     alphaMin(value: number): this;
     velocityDecay(): number;
     velocityDecay(value: number): this;
-    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
-    restart(): this;
-    /** Cancel the RAF loop. Does not change alpha. */
-    stop(): this;
     /**
      * Run the tick body synchronously `iterations` times. Does NOT fire
      * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.
@@ -542,6 +530,34 @@ interface Simulation<TNode extends SimulationNode> {
     tick(iterations?: number): this;
     isSettled(): boolean;
 }
+/** A {@link SimulationCore} running on a frame loop. */
+interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {
+    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
+    restart(): this;
+    /** Cancel the RAF loop. Does not change alpha. */
+    stop(): this;
+}
+/** What {@link SimulationCore} needs: the nodes, the forces acting on them,
+ *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */
+interface SimulationOptions<TNode extends SimulationNode> {
+    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
+    nodes: TNode[];
+    /** Forces applied per tick. Each may implement `initialize` for setup. */
+    forces?: SimulationForce<TNode>[];
+    /** Initial alpha. Default 1. */
+    alpha?: number;
+    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
+    alphaMin?: number;
+    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
+    alphaDecay?: number;
+    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
+    alphaTarget?: number;
+    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
+    velocityDecay?: number;
+    /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded
+     *  source to make a run reproducible. */
+    random?: () => number;
+}
 /** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */
 declare const DEFAULT_ALPHA_DECAY: number;
 /** Alpha below which a cooling simulation is considered settled. */
@@ -551,9 +567,24 @@ declare const DEFAULT_ALPHA_MIN = 0.001;
 declare const DEFAULT_VELOCITY_DECAY = 0.4;
 
 /**
- * Continuous N-body simulation primitive. Owns a RAF loop and a velocity-Verlet
- * integrator; forces are pluggable functions matching d3-force's protocol so
- * d3-force's bundled forces work without translation.
+ * The integrator, with no clock attached.
+ *
+ * Velocity-Verlet over a pluggable force list, contract-compatible with
+ * d3-force so d3's own bundled forces drop in untranslated. Nothing here
+ * advances time: `tick()` is the only thing that moves a node, and the caller
+ * decides how often to call it. `useSimulation` calls it once a frame; a
+ * layout pass calls it a few hundred times in one go and reads the result.
+ *
+ * Splitting it out is what lets a *pure* function run a relaxation — a React
+ * hook cannot, and the alternative was a second integrator drifting away from
+ * this one.
+ */
+
+declare function createSimulation<TNode extends SimulationNode>(opts: SimulationOptions<TNode>): SimulationCore<TNode>;
+
+/**
+ * Continuous N-body simulation primitive: `createSimulation`'s integrator on a
+ * frame loop.
  *
  * The kit is adapter-agnostic — `onTick(nodes)` fires after each integration
  * step and the consumer decides how (and whether) to write through to scene
@@ -562,6 +593,47 @@ declare const DEFAULT_VELOCITY_DECAY = 0.4;
  */
 declare function useSimulation<TNode extends SimulationNode>(opts: UseSimulationOptions<TNode>): Simulation<TNode>;
 
+/** What a producer is told before it is asked for a frame. */
+interface PoseRunCtx<TPose> {
+    /** Nodes another gesture is moving, and the pose each is drawn at. The run
+     *  will not write these, so a producer holds them fixed. */
+    pinned: ReadonlyMap<NodeId, TPose>;
+    /** Frames this run has produced, starting at 0. */
+    frame: number;
+}
+/** One frame of a run. */
+interface PoseRunStep<TPose> {
+    /** Where the nodes it drives are this frame — the whole picture, not a
+     *  delta. An id the frame omits stops being published, which is how a node
+     *  leaves the run's hands: a producer that drops a grabbed box and its rows
+     *  from one frame has released them by the next. */
+    poses: Iterable<readonly [NodeId, TPose]>;
+    /** Whether the run is finished. The frame is published either way, and a
+     *  finished run commits. */
+    done: boolean;
+}
+interface UsePoseRunOptions<TPose> {
+    scene: Scene<unknown, string, TPose>;
+    step: (ctx: PoseRunCtx<TPose>) => PoseRunStep<TPose>;
+    /** The undo entry's name. Default `'Layout'`. */
+    label?: string;
+    /** How many nodes the commit wrote. Fires after the ops land. */
+    onCommit?: (moved: number) => void;
+    /** Clock injection, for tests. Defaults to `requestAnimationFrame`. */
+    requestFrame?: (cb: (t: number) => void) => number;
+    cancelFrame?: (handle: number) => void;
+}
+interface PoseRun {
+    /** Begin, or continue where a `stop` left off. Idempotent while running. */
+    start(): void;
+    /** Finish now: commit what is published, then drop the overrides. */
+    stop(): void;
+    /** Abandon: drop the overrides and write nothing, like a canceled drag. */
+    cancel(): void;
+    isRunning(): boolean;
+}
+declare function usePoseRun<TPose>(opts: UsePoseRunOptions<TPose>): PoseRun;
+
 /**
  * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one
  * scene node needs: the node's world box, the projection from that box's
@@ -1157,7 +1229,7 @@ declare function zoomAt(view: View, anchor: {
  * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.
  *
  * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and
- * pinch actions, `fitViewToBounds`, `computeWheelAction`, `useZoom`. They
+ * pinch actions, `fitViewToBounds`, `computeWheelAction`. They
  * used to carry two disagreeing pairs, so a fit could legally land at 10x
  * and the next pinch frame would clamp it back to 8x.
  */
@@ -1195,73 +1267,6 @@ interface NodeClientRect {
  */
 declare function sceneNodeClientRect(opts: SceneNodeClientRectOpts): NodeClientRect | null;
 
-/**
- * @deprecated Prefer the descriptor-based viewport idiom: `<SceneCanvas>` now
- * registers `viewport.pan` and `viewport.zoom` action descriptors via
- * `useStandardActions` + `useGestureDispatcher`. Pass `useHandTool()` via
- * `ambient` for drag-to-pan. The former `useWheelZoomTool`,
- * `useKeyboardZoomTool`, and `useWheelPanTool` hooks are dissolved.
- * `useZoom` was the original controller-style API; it remains exported with
- * full test coverage but no kit-internal usage. Slated for removal in a future major.
- */
-interface UseZoomOptions {
-    zoom: number;
-    setZoom: (next: number) => void;
-    pan: {
-        x: number;
-        y: number;
-    };
-    setPan: (next: {
-        x: number;
-        y: number;
-    }) => void;
-    min?: number;
-    max?: number;
-    wheelStep?: number;
-    keyStep?: number;
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    sources?: {
-        wheel?: boolean;
-        keys?: boolean;
-        doubleClick?: boolean;
-        pinch?: boolean;
-    };
-    wheelRequiresModifier?: boolean;
-}
-/**
- * @deprecated See `UseZoomOptions` deprecation note. Prefer the
- * descriptor-based viewport idiom.
- */
-interface UseZoomReturn {
-    onWheel(e: WheelEvent | React.WheelEvent): void;
-    onKeyDown(e: KeyboardEvent | React.KeyboardEvent): void;
-    onDoubleClick(e: MouseEvent | React.MouseEvent): void;
-    zoomTo(level: number, focal?: {
-        x: number;
-        y: number;
-    }): void;
-    zoomBy(factor: number, focal?: {
-        x: number;
-        y: number;
-    }): void;
-    reset(): void;
-}
-/**
- * Wheel/key/double-click zoom with focal-point preservation; returns event handlers and `zoomTo`/`zoomBy`/`reset`.
- *
- * @deprecated Prefer the descriptor-based viewport idiom:
- * `<SceneCanvas>` registers `viewport.pan` and `viewport.zoom` action
- * descriptors automatically. Pass `useHandTool()` via `ambient` for
- * drag-to-pan. `useZoom` covers the same input surface but doesn't
- * integrate with the tool dispatcher, selection, or other gestures.
- * No demo, no kit-internal hook, and no app currently consumes `useZoom`;
- * slated for removal in a future major.
- */
-declare function useZoom(opts: UseZoomOptions): UseZoomReturn;
-
 /**
  * Compute zoom and pan that fit `contentW x contentH` (in content units)
  * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of
@@ -1578,7 +1583,7 @@ declare function actionShortcuts(action: Action): readonly ActionShortcut[];
  *
  * The per-frame poses still go *somewhere* the scene can see: the ephemeral
  * override table, which bypasses history entirely. That is what lets a node
- * deriving its geometry from a dragged one follow the drag — `scenePoseLookup`
+ * deriving its geometry from a dragged one follow the drag — `sceneDepLookup`
  * and the pick source both read overrides, and neither can see this action's
  * scratch. Keeping the frame in scratch alone is why the edge used to stay
  * anchored to the old endpoint and jump on drop.
@@ -2003,7 +2008,8 @@ declare const viewportDragPanAction: Action & {
  *
  * ## Design notes
  * The invoker switches on `params.kind`:
- * - `'wheel'`: computes factor from deltaY, anchors zoom at (clientX, clientY).
+ * - `'wheel'`: defers to `wheelZoom` (`core/viewport/wheelHandler`), the kit's
+ *   one statement of the wheel convention, anchored at (clientX, clientY).
  *   The dispatcher merges wheel event data into params at dispatch time, and
  *   converts the wheel event's client coords to canvas-local (subtracting the
  *   canvas's bounding rect) before merging — `zoomAt` expects canvas-local.
@@ -2090,11 +2096,10 @@ declare const viewportZoomAction: Action & {
  *
  * ## Design notes
  * The dispatcher merges wheel event data (deltaX, deltaY, clientX, clientY)
- * into params at dispatch time. The invoker
- * reads them from the params bag.
- *
- * Pan delta is divided by view.scale so that one screen-pixel scroll equals
- * one screen-pixel pan at any zoom level.
+ * into params at dispatch time. The invoker reads them from the params bag
+ * and defers to `wheelPan` (`core/viewport/wheelHandler`), the kit's one
+ * statement of the wheel convention — which divides the delta by `view.scale`
+ * so one screen-pixel scroll is one screen-pixel pan at any zoom.
  *
  * `axis` locks the pan to one axis, matching `viewport.dragPan`'s param of
  * the same name, so a consumer that wants a single-axis viewport can say so
@@ -2296,7 +2301,15 @@ interface UseStandardActionsOptions {
     pointer?: DepSchema['pointer'];
     /** Currently active tool id + hotkey-hold stack. */
     activeTool?: DepSchema['activeTool'];
+    /**
+     * Ids of kit-standard actions to leave unregistered, so a consumer can bind
+     * its own. Ids that name no kit action are ignored;
+     * `KIT_STANDARD_ACTION_IDS` is the full list.
+     */
+    exclude?: Iterable<string>;
 }
+/** Every id `useStandardActions` registers, in registration order. */
+declare const KIT_STANDARD_ACTION_IDS: readonly string[];
 /**
  * @experimental
  * Register each kit-standard dep source and action descriptor into the
@@ -2314,25 +2327,6 @@ interface UseStandardActionsOptions {
  */
 declare function useStandardActions(opts: UseStandardActionsOptions): void;
 
-/**
- * Shared scene-backed commit adapter for default actions.
- *
- * Default actions route data/layer/pose/parent mutations through the
- * consumer's `applyOps` commit hook when one is present; when it isn't, they
- * fall back to applying the committed ops directly against the scene through
- * this adapter. It carries the scene-backed op-apply methods (`setPose` /
- * `setParent` / `setData` / `setLayer` / `removeNode` / `insertNode` /
- * `setChildOrder`) plus the read-side queries (`getNode` / `getNodes` /
- * `getPose` / `getParent` / `getChildren` / `getSelection`) and
- * `setSelection`. Known exclusions from the op factory roster — surfaces the
- * scene doesn't own: `setPath` and `setText`.
- *
- * Lives in `interactions/actions/` (not `canvas/sceneAdapter.ts`) so default
- * actions never import from `canvas/` — that back-edge would create an
- * `interactions → canvas → interactions` cycle. Mirrors `moveGestureAdapter`,
- * widened to all op-apply methods.
- */
-
 /** Build the adapter the default actions commit through when the consumer
  *  supplies no `applyOps` hook of its own — it applies ops straight to the
  *  scene. Path and text ops are not covered; those surfaces belong to their
@@ -2344,6 +2338,7 @@ declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose
     getSelection: () => string[];
     setSelection: (ids: string[]) => void;
     getParent: (id: string) => string | null;
+    getRemovalClosure: (ids: readonly string[]) => string[];
     getChildren: (parentId: string | null) => string[];
     setChildOrder: (parentId: string | null, orderedIds: string[]) => void;
     setPose: (id: string, pose: TPose) => void;
@@ -2691,37 +2686,57 @@ interface VisibleRaf {
 declare function useVisibleRaf(frame: (time: number) => void, options?: VisibleRafOptions): VisibleRaf;
 
 /**
- * Pure wheel-event reducer. Stateless sibling of `useZoom`'s
- * `onWheel` handler — useful in tests, in non-React reducers, or anywhere
- * the focal-point zoom math is needed without React lifecycle.
+ * The kit's one wheel convention, as pure functions over `View`.
  *
- * Conventions match the rest of the kit: `zoom` is a multiplier where `1`
- * means 100%. The default bounds are the kit's system-wide zoom clamp
- * ({@link DEFAULT_MIN_ZOOM} – {@link DEFAULT_MAX_ZOOM}).
+ * ## Modifiers
+ * - bare wheel → pan
+ * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)
+ * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the
+ *   trackpad pinch, which browsers deliver as ctrl+wheel.
+ *
+ * ## Coordinates
+ * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the
+ * DOM reports them — is divided by `View.scale` before it lands. The zoom
+ * anchor is canvas-local: client coords minus the canvas's bounding rect.
+ *
+ * `viewport.wheelPan` and `viewport.zoom` are the wired form of these, and
+ * call them rather than restating the math.
  */
-/** Pure viewport state consumed and returned by `computeWheelAction`. */
-interface WheelState {
-    /** Multiplier; `1` = 100% / no zoom. */
-    zoom: number;
-    panX: number;
-    panY: number;
-}
-/** Wheel-event input, decoupled from the DOM `WheelEvent` shape for testability. */
+
+/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */
+declare const WHEEL_ZOOM_STEP = 1.1;
+/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */
 interface WheelInput {
     deltaX: number;
     deltaY: number;
-    mouseX: number;
-    mouseY: number;
+    /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */
+    x: number;
+    y: number;
     shiftKey?: boolean;
+    ctrlKey?: boolean;
     metaKey?: boolean;
 }
-/** Inclusive `[min, max]` zoom clamp for `computeWheelAction`. Multiplier scale. */
-interface ZoomBounds {
-    min: number;
-    max: number;
+/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed
+ *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */
+interface WheelPanOpts {
+    axis?: 'both' | 'x' | 'y';
+    swapAxis?: boolean;
 }
-/** Pure reducer: given current viewport state and a wheel input, return the next state (zoom, pan, or scroll). */
-declare function computeWheelAction(state: WheelState, input: WheelInput, bounds?: ZoomBounds): WheelState;
+/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling
+ *  a distance and back returns to the scale you started from. */
+declare function wheelZoomFactor(deltaY: number): number;
+/** Zoom one wheel sample about `anchor` (canvas-local pixels). */
+declare function wheelZoom(view: View, anchor: {
+    x: number;
+    y: number;
+}, deltaY: number, clamp?: ZoomClampOpts): View;
+/** Pan by one wheel sample. `delta` is in screen pixels. */
+declare function wheelPan(view: View, delta: {
+    deltaX: number;
+    deltaY: number;
+}, opts?: WheelPanOpts): View;
+/** Pure reducer: the whole wheel convention in one call. */
+declare function computeWheelAction(view: View, input: WheelInput, clamp?: ZoomClampOpts, opts?: Pick<WheelPanOpts, 'axis'>): View;
 
 /**
  * Convert client coords to element CSS-pixel coords (relative to the element's
@@ -3317,43 +3332,6 @@ declare function useHandTool(opts?: UseHandToolOptions): Tool<HandScratch | null
  *  factories and hit gating belong on those deps, not on the tool. */
 declare function useTextTool(): Tool<undefined>;
 
-/** The camera a pinch acts on, and the origin its anchor is measured from. */
-interface PinchZoomTarget {
-    view: View;
-    setView: (v: View) => void;
-    /** Client-space origin of the surface this camera paints into. */
-    origin: {
-        left: number;
-        top: number;
-    };
-}
-/** Options for `usePinchZoomTool`: the zoom limits, and whether it is wired
- *  at all. */
-interface PinchZoomToolOpts {
-    min?: number;
-    max?: number;
-    enabled?: boolean;
-    /**
-     * Which camera the anchor point belongs to. Return `null` — or omit this —
-     * for the canvas's own. A canvas hosting several views resolves the point
-     * here, so a pinch inside a panel zooms the panel rather than the canvas
-     * underneath it.
-     */
-    resolveTarget?: (clientX: number, clientY: number) => PinchZoomTarget | null;
-}
-/**
- * Two-finger pinch zoom on the canvas. Standalone hook (not a Tool record)
- * because it requires direct multi-pointer access on the canvas element.
- *
- * The anchor point under the gesture midpoint stays fixed on screen as the
- * view scales.
- *
- * @param getView Read at gesture time, not at render time: each pinch move
- *   applies a per-frame delta to the view the previous move produced, and the
- *   canvas does not re-render between them.
- */
-declare function usePinchZoomTool(canvasRef: React.RefObject<HTMLElement | null>, getView: () => View, setView: (v: View) => void, opts?: PinchZoomToolOpts): void;
-
 /**
  * In-progress pen anchor. `outHandle` is set when the anchor was placed via
  * click-drag (smooth anchor); undefined for click-placed corners.
@@ -4463,37 +4441,6 @@ interface HierarchicalAdapter<TNode, TPose> {
     getPose(id: string): TPose;
 }
 
-/**
- * The consumer-facing `viewport` prop shape for `<SceneCanvas>`.
- *
- * The features it names are wired by the `viewport.*` action descriptors
- * (`useStandardActions` + `useGestureDispatcher`) and by SceneCanvas itself,
- * which derives the hand tool and the registered flag inline.
- */
-
-/** Which viewport interactions `<SceneCanvas>` wires up — pan inertia, pinch
- *  zoom, wheel pan, wheel and keyboard zoom. Each may be switched off with
- *  `false` or tuned with an options object. */
-interface ViewportConfig {
-    inertia?: boolean | {
-        friction?: number;
-        minSpeed?: number;
-        boundary?: 'stop' | 'bounce' | 'spring';
-        bounds?: PanBounds;
-    };
-    pinchZoom?: boolean | {
-        min?: number;
-        max?: number;
-    };
-    /** Wheel pan (plain wheel → pan). Default: `true`. Set `false` to disable,
-     *  or pass a {@link WheelPanOptions} object to lock it to one axis. */
-    pan?: boolean | WheelPanOptions;
-    /** Wheel + keyboard zoom (Cmd+wheel, Cmd+=/-/0). Default: `true`. Set `false`
-     *  to disable, or pass a {@link ViewportZoomOptions} object to tune the wheel
-     *  trigger + scale clamp. */
-    zoom?: boolean | ViewportZoomOptions;
-}
-
 /**
  * The scene-tree reading methods Canvas feature-detects at draw time, as an
  * *optional* mixin. A `SceneCanvasAdapter` supplies them; flat / bare-Canvas
@@ -4763,7 +4710,7 @@ interface CanvasProps<TNode extends {
      * `setView` call passes through `clampView(next, viewBounds, {width, height})`
      * before commit, keeping the visible rect inside `viewBounds`. If the visible
      * rect is larger than the bounds along an axis (zoomed out past extent), that
-     * axis is centered. Has no effect on `scale` — wire `useZoom` bounds for that.
+     * axis is centered. Has no effect on `scale`.
      *
      * A viewport concern, not scene-shaped. Consumers that want the pan to stay
      * inside a document page boundary should wire this with the page dimensions.
@@ -4835,21 +4782,6 @@ interface CanvasProps<TNode extends {
      * report "no gesture in flight" and never fire.
      */
     gestureSource?: GestureSource;
-    /**
-     * Pinch-zoom DOM listener attachment for the canvas surface. When supplied,
-     * `<Canvas>` calls `usePinchZoomTool` with `canvasRef` so two-finger pinch
-     * events are handled directly on the canvas element.
-     *
-     * Hand tool registration, wheel pan/zoom action descriptors, and keyboard
-     * zoom shortcuts are SceneCanvas-level concerns and are NOT owned by Canvas.
-     * Those belong with the tool registry and gesture dispatcher that live in
-     * SceneCanvas — which is also why SceneCanvas does not pass this prop: it
-     * drives pinch through the `viewport.pinchZoom` action instead, and both
-     * paths at once would apply one gesture's zoom factor twice.
-     *
-     * When omitted, no pinch-zoom listener is attached.
-     */
-    viewport?: ViewportConfig;
     /**
      * FillStyle applied to the full canvas surface behind the scene. Accepts the
      * kit's `FillStyle` union (solid / pattern / linear-gradient / radial-gradient /
@@ -4938,6 +4870,13 @@ interface CanvasProps<TNode extends {
      * it is not drawn. Reordering two layers means naming all of them.
      */
     layerOrder?: string[];
+    /**
+     * Runs of consecutive layers that composite as one — the surface for
+     * blurring the world while the chrome above it stays sharp. Members are
+     * named by layer id, and a layer in no group draws exactly as it did
+     * before. See {@link LayerGroup}.
+     */
+    layerGroups?: readonly LayerGroup[];
 }
 
 /** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /
@@ -4967,6 +4906,7 @@ type SceneCanvasAdapter<TData, TLayer extends string, TPose> = MoveAdapter<Node$
     setSelection(ids: string[]): void;
     insertNode(node: Node$1<TData, TLayer, TPose>, index?: number): void;
     removeNode(id: string): void;
+    getRemovalClosure(ids: readonly string[]): string[];
     applyOps(ops: Op[], label?: string): void;
     snapshotSelection(ids: string[]): ClipboardSnapshot;
     commitPaste(clipboard: ClipboardSnapshot, offset: {
@@ -6257,9 +6197,6 @@ declare function SceneViewCanvasInner<TData, TLayer extends string, TPose>(props
  */
 declare const SceneViewCanvas: typeof SceneViewCanvasInner;
 
-/** Build a scene outside React. `useScene` is the usual entry point; reach for
- *  this in tests, in headless rendering, or wherever a scene must outlive a
- *  component. Throws if no system layers are declared. */
 declare function createScene<TData, TLayer extends string, TPose = RectPose>(options: UseSceneOptions<TData, TLayer, TPose>): Scene<TData, TLayer, TPose>;
 /** The scene's selection in the shape `createHistory` wants, for a consumer
  *  building a second History over the same scene (a modality machine, a
@@ -6320,18 +6257,90 @@ declare function useScene<TItem extends {
 declare function useScene<TData, TLayer extends string, TPose = RectPose>(options: UseSceneOptions<TData, TLayer, TPose>): Scene<TData, TLayer, TPose>;
 
 /**
- * Pure math helpers for `<MinimapCanvas>`.
+ * Build a {@link PoseOverrides} map.
+ *
+ * `getNode` resolves an id to the node object the painter memo is keyed on —
+ * the only thing this module needs from the scene, and the reason it doesn't
+ * import one. `onInvalidate` lets the scene invalidate derived nodes from the
+ * same chokepoint.
+ */
+declare function createPoseOverrides<TPose>(getNode: (id: NodeId) => {
+    data?: unknown;
+} | undefined, onInvalidate?: (id: NodeId) => void): PoseOverrides<TPose>;
+
+/** The subset of a node this module reads. Structural so a `Node` satisfies
+ *  it without importing the full generic shape. */
+interface PosedNode<TPose> {
+    id: NodeId;
+    kind?: 'leaf' | 'container';
+    pose: TPose;
+    /** Read only by the memo, which keys on its reference alongside the pose. */
+    data?: unknown;
+    dependsOn?: readonly NodeId[] | 'children';
+    derivePose?: (node: never, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
+    /** Read only when something asks a dependency for its `path`. */
+    derivePath?: (node: never, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null;
+}
+/** What resolving a pose needs: the overrides, and enough of the scene to
+ *  reach a node's dependencies. A `Scene` satisfies it. */
+interface PoseSource<TPose> {
+    readonly overrides: Pick<PoseOverrides<TPose>, 'get'>;
+    get(id: NodeId): PosedNode<TPose> | undefined;
+    childrenOf(id: NodeId): readonly NodeId[];
+}
+/**
+ * The pose `node` computes from its dependencies, or `null` when it derives
+ * nothing — it has no `derivePose`, nothing to derive from, or its
+ * `derivePose` returned `null`.
+ *
+ * A dependency is read through {@link effectivePose}, so a group of groups
+ * resolves bottom-up and a dragged dependency's override reaches the
+ * derivation the same frame it is published.
+ */
+declare function derivedPose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose | null;
+/**
+ * `id` as a derivation sees it: the node, the pose it is painted at, and the
+ * path it derives.
+ *
+ * The pose is resolved eagerly — every derivation reads it — and the path
+ * lazily, because most do not and resolving a route costs a router run. Both
+ * resolve *through* this function, so a dependency that is itself derived is
+ * resolved before it is read.
+ */
+declare function derivedDepOf<TPose>(source: PoseSource<TPose>, id: NodeId): DerivedDep<TPose> | undefined;
+/**
+ * The pose the *document* says `node` is at: derived when it derives, else
+ * authored. `effectivePose` minus the override step.
  *
- * `computeFitView` derives a `View` that fits a chosen world rect into a
- * minimap canvas of given pixel dims. `computeIndicatorCommand` builds the
- * dashed "visible window" rect — the main canvas's screen window projected
- * into the minimap's own screen coordinates.
+ * For a reader that must not see an in-flight gesture — an action capturing
+ * the `from` of a transform op, a placement computed against a sibling. A
+ * derived pose belongs here and an override does not: derivation is what the
+ * document means, an override is what one gesture is currently showing.
+ */
+declare function documentPose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
+/**
+ * The pose to draw, pick and measure `node` at.
  *
- * Neither helper touches GL, the DOM, or the renderer; they're pure
- * functions, unit-testable with `expect`.
+ * The one rule. Every pose a reader acts on comes from here: the three render
+ * walks, the pick walk, the adapters tools and actions commit through.
+ */
+declare function effectivePose<TPose>(source: PoseSource<TPose>, node: PosedNode<TPose>): TPose;
+
+/** Registry key for {@link unionOfChildren}. */
+declare const UNION_OF_CHILDREN = "kit:unionOfChildren";
+/**
+ * A container's pose as the envelope of what it holds — `unionAABB`, so a
+ * rotated member contributes the extent of its ink rather than its unrotated
+ * box. Paired with `dependsOn: 'children'`, this is what makes a group's
+ * bounds track its members instead of freezing at the moment it was made.
  *
- * See `docs/superpowers/specs/2026-05-31-detached-minimap-design.md`.
+ * Returns `null` for an emptied container, which falls back to its authored
+ * pose — the group stays where the last member left it rather than collapsing
+ * to a zero box at the origin.
  */
+declare function unionOfChildren<TPose>(_node: unknown, deps: readonly ({
+    pose: TPose;
+} | undefined)[]): TPose | null;
 
 /**
  * Fallback view returned when there is nothing to fit (empty scene, etc.).
@@ -7575,7 +7584,7 @@ interface UseSceneTextEditReturn extends UseTextEditReturn {
      *  bubble). The handler looks up the canvas via `e.target`, hits the
      *  top-most text node under the cursor via `pointInTextPose`, resolves
      *  a caret offset via `caretIndexAt`, and starts edit on that node. */
-    onDoubleClick: (e: MouseEvent$1<HTMLElement>) => void;
+    onDoubleClick: (e: MouseEvent<HTMLElement>) => void;
 }
 /** Wire double-click-to-edit text on a scene: mounts a DOM editing overlay
  *  over the node being edited and writes the result back as an undoable op. */
@@ -7916,15 +7925,16 @@ interface DeleteArgs<TNode extends {
     index?: number;
     /** Full slot, anchor included. Written by `apply`; supersedes `index`. */
     slot?: Slot;
-    /** Descendants of `node`, preorder (parents before children). `removeNode`
-     *  cascades the whole subtree, so an inverse that re-inserts `node` alone
-     *  brings the container back empty and drops every child on the floor.
-     *  Captured on apply; mirrored into the serialized args so a rebuilt op
-     *  can invert without having run. */
-    descendants?: Placed<TNode>[];
-}
-/** Op: remove `node` and its subtree from the scene; inverts to a re-insert
- *  of the whole subtree at its captured slots. */
+    /** Everything `removeNode` takes, `node` itself included — its subtree, and
+     *  whatever else the adapter cascades. An inverse that re-inserts `node`
+     *  alone brings a container back empty and leaves every dependent deleted.
+     *  Ordered so a node's parent precedes it, which is the order they have to
+     *  be re-inserted in. Captured on apply; mirrored into the serialized args so
+     *  a rebuilt op can invert without having run. */
+    cascaded?: Placed<TNode>[];
+}
+/** Op: remove `node` and everything the adapter cascades with it; inverts to a
+ *  re-insert of the whole set at its captured slots. */
 declare function createDeleteOp<TNode extends {
     id: string;
 }>(args: DeleteArgs<TNode>): Op;
@@ -8300,8 +8310,9 @@ declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPat
  * Polygon-vs-axis-aligned-rect tests. Pure functions; no React/kit deps.
  *
  * `polygon` is a closed polyline given as an ordered vertex array; the
- * closing edge from `polygon[N-1]` to `polygon[0]` is implicit. Even-odd
- * fill rule (matches `pointInPath`).
+ * closing edge from `polygon[N-1]` to `polygon[0]` is implicit. Even-odd fill
+ * rule, and one contour only — a path with holes or curves goes through
+ * `pathHitTest`, which reads its `fillRule`.
  */
 
 /** A 2D point or vector. */
@@ -8314,26 +8325,23 @@ interface Vec2 {
  * Path-vs-geometry hit-test helpers. Five pure functions covering all
  * combinations of path-vs-point, path-vs-rect, and path-vs-polygon.
  *
- * `RectPath` short-circuits to AABB arithmetic. `PolygonPath` delegates to
- * the polygon kernel in `polygonHitTestRect` after extracting vertices from
- * the command stream. Bezier segments in a `PolygonPath` are currently out of
- * scope (paths are rect or straight-line polygon only); a non-line
- * command will throw to surface accidental misuse early.
- *
- * For point-in-path specifically, use the existing `pointInPath` from
- * `hitTest.ts` which handles beziers and fill rules correctly.
+ * `RectPath` short-circuits to AABB arithmetic. A `PolygonPath` is treated as
+ * its filled region: whether a point is inside comes from `pointInPath`, so
+ * beziers are flattened and `fillRule` is honored, and every closed subpath
+ * counts — the hole of a donut is not part of the shape under `evenodd`. Open
+ * subpaths enclose no area and are ignored, matching `pointInPath`.
  */
 
 /** Returns true if (x, y) lies within the filled region of `path`. */
-declare function pathContainsPoint(path: Path, x: number, y: number): boolean;
+declare function pathContainsPoint(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
 /** Returns true if `rect` is entirely contained within `path`. */
-declare function pathContainsRect(path: Path, rect: Rect): boolean;
+declare function pathContainsRect(path: Path, rect: Rect, opts?: PointInPathOptions): boolean;
 /** Returns true if `rect` overlaps (intersects or contains) `path`. */
-declare function pathIntersectsRect(path: Path, rect: Rect): boolean;
+declare function pathIntersectsRect(path: Path, rect: Rect, opts?: PointInPathOptions): boolean;
 /** Returns true if every vertex of `polygon` lies inside `path`. */
-declare function pathContainsPolygon(path: Path, polygon: readonly Vec2[]): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Vec2[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[]): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[], opts?: PointInPathOptions): boolean;
 
 /**
  * Pure-geometry distance from a point to a path's boundary (stroke), with
@@ -8357,6 +8365,35 @@ declare function pathIntersectsPolygon(path: Path, polygon: readonly Vec2[]): bo
  *  combine with `pathContainsPoint` at the call site. */
 declare function pathDistanceToPoint(path: Path, px: number, py: number): number;
 
+/**
+ * A station along a path: where it is at a fraction of its length, and which
+ * way it is heading there.
+ *
+ * For anything positioned *along* geometry rather than beside it — a label on a
+ * routed edge, a tick on a curve, a badge near an arrowhead. Curves are
+ * flattened first, so the fraction is arc length along the drawn shape rather
+ * than a curve parameter, which is what makes 0.5 look like the middle.
+ */
+
+interface PathStation {
+    point: Vec2;
+    /** Unit vector along the path at `point`, pointing toward the end. */
+    tangent: Vec2;
+}
+interface PointAlongPathOptions {
+    /** Curve flattening tolerance, in world units. Default 0.5. */
+    flattenTolerance?: number;
+}
+/**
+ * Where `path` is at `t` of its total length, and its heading there.
+ *
+ * `t` is clamped to 0..1. Subpaths are measured in order and treated as one
+ * run, the way a browser measures a whole `<path>`. Returns `null` for a path
+ * with no points at all; a path of zero length answers at its single point,
+ * heading along +X.
+ */
+declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOptions): PathStation | null;
+
 /**
  * In-place and copy-out path transforms. Translation is the most common —
  * called every pointermove during a drag — so the polygon variant mutates
@@ -9018,8 +9055,13 @@ interface PaintBindContext {
      * convention; it is not gradient-specific.
      */
     spaceInverse(units: GradientUnits | undefined): Mat3$1;
-    /** Upload a stop ramp and bind it to a texture unit. */
-    bindRamp(stops: GradStop[], unit: number): void;
+    /**
+     * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
+     * unit, and return the `v` the ramp's own row sits at — every ramp in a
+     * frame shares one texture, so a paint must sample at the returned `v` and
+     * not at a constant.
+     */
+    bindRamp(stops: GradStop[], unit: number): number;
 }
 /**
  * One paint kind.
@@ -10890,4 +10932,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ANCHOR_HIT_BASE_PX, Action, type ActionShortcut, ActionsProp, ActionsProviderIfRoot, ActionsRegistry, Affordance, AffordanceBinding, AffordanceHit, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignBounds, type AlignBoundsProjection, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COARSE_TARGET_SCALE, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHelpers, type CanvasViewProps, type CaretIndexAtOpts, type CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type ColorSpace, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, Condition, ContentHandlerEntry, Contribution, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DefaultTextData, DepRegistryProviderIfRoot, DepSchema, type DeriveAlignmentGuidesOptions, DetectedDeviceFacts, DeviceProfile, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type Discriminator, Dispatcher, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EasingSpec, Eligibility, type EligibilityState, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, type FitTextPoseOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, HotkeyTrigger, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, IntersectIcon, type Joint, type JointTransform, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerHit, type LayerSlotValue, type LayersMap, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, Mat3$1 as Mat3, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, NodeId, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OngoingOverlay, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, OverlayPosition, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, type PaintedCursor, type PaintedCursorFrame, type PaintedCursorState, PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PinchZoomToolOpts, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerSession, type PointerSessionCallbacks, type PointerSessionCancelReason, type PointerSessionOptions, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseProjection, type PoseRotation, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, type ResolvableView, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasProps, Node$1 as SceneNode, type SceneNodeClientRectOpts, SceneRegistry, type SceneSlotConfig, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewDrawOne, ScopedBinding, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationForce, type SimulationNode, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGestureDispatcherOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, type UseZoomOptions, type UseZoomReturn, VERSION, type Vec2, type VelocityTracker, VertexColorChannel, View, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, ViewTransform, type ViewportConfig, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, editAnchorsAction, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isDebugEnabled, isEditableTarget, isGradientFill, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, openPointerSession, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, polylineFromPoints, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolveMarkerSize, resolvePatternSpec, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, setScratch, shapeCoversPoint, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromRuns, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, useZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };
+export { ANCHOR_HIT_BASE_PX, Action, type ActionShortcut, ActionsProp, ActionsProviderIfRoot, ActionsRegistry, Affordance, AffordanceBinding, AffordanceHit, AffordanceRegion, type AffordanceRegionHit, type AlignAdapter, type AlignAnchor, type AlignBounds, type AlignBoundsProjection, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorHit, type AnchorScratch, type AnchorState, type AnimateOnSetPoseOptions, AnimationHandle, Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, COARSE_TARGET_SCALE, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CanvasSurfaceHelpers, CanvasView, type CanvasViewHelpers, type CanvasViewProps, type CaretIndexAtOpts, type CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, ColorOverrideRegistry, type ColorSpace, CommonAffordanceScratch, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, Condition, ContentHandlerEntry, Contribution, type CornerResizeAffordanceOptions, type CornerResizeScratch, type CreateChildrenLayerOpts, type CreateParallaxLayerOpts, type CreatePathEditingOverlayLayerOptions, type CreatePathLayerOpts, type CreatePenPreviewLayerOptions, type CreateTextLayerOpts, type CreateViewResolverOpts, type CreateViewportLayerOpts, CropIcon, CursorCoordsHud, type CursorCoordsHudProps, type CurveRepKind, type CurveRepresentation, type CustomLayerEntry, type CycleHandle, type CycleVertexColorsOptions, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, DEFAULT_HANDLE_SIZE, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DefaultTextData, DepRegistryProviderIfRoot, DepSchema, type DeriveAlignmentGuidesOptions, DerivedDep, DetectedDeviceFacts, DeviceProfile, DeviceProfileProvider, type DeviceProfileProviderProps, Dims, type Discriminator, Dispatcher, type DistributeAdapter, type DistributeAxis, type DistributeMode, DivideIcon, type DragGestureController, type DragGestureCtx, type DragGestureEndCtx, type DragGesturePhase, type DragGesturePoint, type DragHandleOptions, type DragPanParams, type DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EasingSpec, Eligibility, type EligibilityState, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, type FitTextPoseOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GesturePreviewSource, type GestureSource, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, InertiaConfig as HandToolInertiaConfig, type HandleDragEnd, type HandleDragPoint, type HeadlessCanvasLike, type HostAnchorAlign, type HostAnchorInput, type HostAnchorOffset, type HostAnchorStyle, HotkeyTrigger, IDENTITY_JOINT, type IconProps, ImageIcon, type ImageNodeData, type ImageStatus, type IndicatorStyle, InertiaConfig, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, IntersectIcon, type Joint, type JointTransform, KIT_STANDARD_ACTION_IDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerGroup, LayerHit, type LayerSlotValue, type LayersMap, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, MIXED, MOVE_ANCHORS, type MarkerCtx, type MarkerEntry, type MarkerPaint, type MarkerSite, type MarkerSiteRequest, Mat3$1 as Mat3, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, NodeId, type NodeInk, type NodeInkCtx, type NodeOverlayFrame, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type NodeSilhouetteCtx, OngoingOverlay, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type OverlayPoint, OverlayPosition, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, type PaintBindContext, type PaintKind, type PaintKindEditorProps, type PaintKindEntry, type PaintProgram, type PaintedCursor, type PaintedCursorFrame, type PaintedCursorState, PanBounds, type ParallaxOpts, Path, type PathAnchor, type PathAnchorAffordanceOptions, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PathStation, type PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PencilPoint, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomOptions, type PixelRenderPlan, type PointAlongPathOptions, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerSession, type PointerSessionCallbacks, type PointerSessionCancelReason, type PointerSessionOptions, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseOverrides, PoseProjection, type PoseRotation, type PoseRun, type PoseRunCtx, type PoseRunStep, type PoseSource, type PosedNode, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, type ResolvableView, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SampledTrack, type ScalarOrXY, Scene, SceneAdapter, type SceneAdapterSelection, SceneCanvas, type SceneCanvasAdapter, type SceneCanvasApi, type SceneCanvasHit, type SceneCanvasProps, Node$1 as SceneNode, type SceneNodeClientRectOpts, SceneRegistry, type SceneSlotConfig, type SceneToAdapterOptions, SceneViewCanvas, type SceneViewCanvasProps, type SceneViewDrawOne, ScopedBinding, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandleStyle, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationCore, type SimulationForce, type SimulationNode, type SimulationOptions, type Skeleton, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringPoseOptions, SpringPresetName, type SpringVertexColorsOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, type StyleKey, type StylusData, SubtractIcon, SvgIngestOptions, TOOL_PREF_KINDS, type TextEditScreenPose, type TextEditSelection, TextIcon, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefEnumEncoding, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefObject, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenPoseOptions, type TweenVertexColorsOptions, UNION_OF_CHILDREN, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, UseAnimatorOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEyedropperToolOptions, type UseGestureDispatcherOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHostAnchorOptions, type UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, type UseNodeOverlayFrameOptions, type UsePenToolOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UsePoseRunOptions, UseResizeOptions, type UseResizePolicyOptions, type UseRotateOptions, type UseRotateToolOptions, UseSceneOptions, type UseSceneTextEditOptions, type UseSceneTextEditReturn, type UseSceneTrivialOptions, type UseSelectToolOptions, UseSelectionOptions, type UseSimulationOptions, type UseStandardActionsOptions, type UseStarToolOptions, type UseTextEditOptions, type UseTextEditReturn, type UseToolsOptions, VERSION, type Vec2, type VelocityTracker, VertexColorChannel, View, ViewAnimationOptions, type ViewRect, type ViewResolver, type ViewTarget, ViewTransform, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomAnimateOptions, type ViewportZoomOptions, VisibilityRules, type VisibleRaf, type VisibleRafOptions, type VisibleRafTarget, WHEEL_ZOOM_STEP, WeaselProvider, type WheelInput, type WheelPanOptions, type WheelPanOpts, ZoomBound, type ZoomClampOpts, ZoomFactor, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseOverrides, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createSimulation, createTextLayer, createTilePattern, createTransformOp, createVelocityTracker, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, dispatchApplyBatch, dlog, documentPose, domPositionToCharOffset, domToRuns, dwarn, editAnchorsAction, effectivePose, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isDebugEnabled, isEditableTarget, isGradientFill, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linePath, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, openPointerSession, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathPoseDescriptor, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointAlongPath, pointInPath, pointInRotatedRect, pointInTextPose, polygonFromPoints, polylineFromPoints, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerMarker, registerNodeShape, registerOpFactory, registerPaintKind, registeredOpNames, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolveMarkerSize, resolvePatternSpec, resolveSkeleton, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, setScratch, shapeCoversPoint, snap, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, textCommand, textCommandFromRuns, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, unionOfChildren, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useVisibleRaf, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };