@weasel-js/core 1.0.4 → 1.2.0

package/dist/index.d.ts

@@ -2,40 +2,40 @@ import * as React$1 from 'react';
 import React__default, { RefObject, ReactNode, Ref, MouseEvent as MouseEvent$1, 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-sfilv5HP.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-sfilv5HP.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, g as DepSchema, S as SliceDep, h as ActionsRegistry, T as Tool, i as AffordanceHit, j as Dispatcher, k as ToolDef, l as ViewportToolDef, m as AnyTool, O as OverlayPosition, n as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, o as ChromeState, p as SelectionApi, I as InsertExtras, G as GeometryProjection, q as ContentHandlerEntry, r as SvgIngestOptions, U as UseSelectionOptions, s as ActionsProp, t as Affordance, u as AffordanceRegion, v as AffordanceBinding, w as CommonAffordanceScratch, B as BooleansAdapter, E as Eligibility, x as BindingScope, y as Contribution, z as ScopedBinding } from './registry-QRg8KiNM.js';
-export { F as ALWAYS, J as ActionDeps, K as ActionDisabledReason, M as ActionEnabledResult, N as ActionEntry, P as ActionsProvider, Q as ActiveToolContextProvider, W as ActiveToolContextProviderIfRoot, X as ActiveToolContextProviderProps, Y as ActiveToolContextValue, Z as AreaSelectDep, _ as BindingOpts, $ as BooleanOp, a0 as BooleanOpResult, a1 as BoundGesture, a2 as BuildRuleCtxArgs, a3 as ClaimableGesture, a4 as ClipboardDep, a5 as ClipboardIngestCtx, a6 as CustomPaintContext, a7 as DepName, a8 as DepRegistry, a9 as DepRegistryProvider, aa as DispatcherContext, ab as DragSample, ac as EditAnchorsDep, ad as GestureBinding, ae as IDENTITY_POSE_COMPOSITION, af as ImmediateInvoker, ag as IngestCtx, ah as IngestionDep, ai as InsertDep, aj as InvocationCtx, ak as Invoker, al as LassoSelectDep, am as LayoutDep, an as MatchResult, ao as NEVER, ap as NodeAtPointDep, aq as OngoingHandle, ar as OngoingInvoker, as as OngoingOverlay, at as Point2, au as PointerContextProvider, av as PointerContextValue, aw as PointerWorldPos, ax as PoseAdapter, ay as PoseComposition, az as ResizePolicy, aA as ResolveAllOptions, aB as ResolveOnlyResult, aC as ResolvedCandidate, aD as SelectionExtendKey, aE as SelectionMode, aF as Selector, aG as SnapDep, aH as SvgUnpacker, aI as TextEditDep, aJ as ToolCtx, aK as ToolModifiers, aL as ToolPresentation, aM as ToolSlot, aN as UiOngoingControl, aO as ViewApi, aP as applyBooleanOp, aQ as buildRuleCtx, aR as clipboardCopyAction, aS as clipboardCutAction, aT as composeRectPose, aU as composeWorldPose, aV as createDispatcher, aW as decomposeRectPose, aX as describeRule, aY as drawLayers, aZ as enterTextEditAction, a_ as evaluate, a$ as evaluateEnabled, b0 as rebaseLocalPose, b1 as registerContentHandler, b2 as sliceAction, b3 as specificity, b4 as translateRectPose, b5 as useAction, b6 as useActionsRegistry, b7 as useActiveToolContext, b8 as useDepRegistry, b9 as useDepSource, ba as useOptionalActiveToolContext, bb as useOptionalDepRegistry, bc as usePointerContext, bd as useSelection, be as worldPoseLookup } from './registry-QRg8KiNM.js';
-import { S as Stroke, F as FillStyle, a as TextureHandle, T as TilePatternSpec, b as GradientKind, G as GradStop, c as GradientFill } from './paint-types-CnLIzqq1.js';
-export { d as GradientUnits, R as Region, e as StrokeAlign, f as alignedStrokeRect } from './paint-types-CnLIzqq1.js';
-import { B as Bounds, P as PoseProjection, F as FitViewToBoundsOptions, V as ViewportDims } from './geometry-5X6TrAkX.js';
-export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-5X6TrAkX.js';
-import { N as NodeId, S as Scene, a as Node$1, b as SerializedScene, R as RectPose, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-vqxpCFVp.js';
-export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, g as SerializedNode, h as SystemLayerRecord, i as SystemLayerSpec, j as UserLayerRecord, k as asNodeId } from './types-vqxpCFVp.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-ByZxoD6P.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-ByZxoD6P.js';
-import { U as UseResizeOptions } from './pointSnapToGrid-C3wowsQy.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-C3wowsQy.js';
-import { BodyClassification, IngestItem } from '@weasel-js/gestures';
+import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-DqOi0Vgi.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-DqOi0Vgi.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, g as DepSchema, S as SliceDep, h as ActionsRegistry, T as Tool, i as AffordanceHit, j as Dispatcher, k as ToolDef, l as ViewportToolDef, m as AnyTool, O as OverlayPosition, n as ToolKeybinding, H as HotkeyTrigger, L as LayerHit, o as ChromeState, p as SelectionApi, U as UseSelectionOptions, I as InsertExtras, G as GeometryProjection, q as ContentHandlerEntry, r as SvgIngestOptions, s as ActionsProp, t as Affordance, u as AffordanceRegion, v as AffordanceBinding, w as CommonAffordanceScratch, B as BooleansAdapter, E as Eligibility, x as BindingScope, y as Contribution, z as ScopedBinding } from './registry-l3JX0Z6b.js';
+export { F as ALWAYS, J as ActionDeps, K as ActionDisabledReason, M as ActionEnabledResult, N as ActionEntry, P as ActionsProvider, Q as ActiveToolContextProvider, W as ActiveToolContextProviderIfRoot, X as ActiveToolContextProviderProps, Y as ActiveToolContextValue, Z as AreaSelectDep, _ as BindingOpts, $ as BooleanOp, a0 as BooleanOpResult, a1 as BoundGesture, a2 as BuildRuleCtxArgs, a3 as ClaimableGesture, a4 as ClipboardDep, a5 as ClipboardIngestCtx, a6 as CustomPaintContext, a7 as DepName, a8 as DepRegistry, a9 as DepRegistryProvider, aa as DispatcherContext, ab as DragSample, ac as EditAnchorsDep, ad as GestureBinding, ae as IDENTITY_POSE_COMPOSITION, af as ImmediateInvoker, ag as IngestCtx, ah as IngestionDep, ai as InsertDep, aj as InvocationCtx, ak as Invoker, al as LassoSelectDep, am as LayerCommandCache, an as LayoutDep, ao as MatchResult, ap as NEVER, aq as NodeAtPointDep, ar as OngoingHandle, as as OngoingInvoker, at as OngoingOverlay, au as Point2, av as PointerContextProvider, aw as PointerContextValue, ax as PointerWorldPos, ay as PoseAdapter, az as PoseComposition, aA as ResizePolicy, aB as ResolveAllOptions, aC as ResolveOnlyResult, aD as ResolvedCandidate, aE as SelectionExtendKey, aF as SelectionMode, aG as Selector, aH as SnapDep, aI as SvgUnpacker, aJ as TextEditDep, aK as ToolCtx, aL as ToolModifiers, aM as ToolPresentation, aN as ToolSlot, aO as UiOngoingControl, aP as ViewApi, aQ as actionBindings, aR as applyBooleanOp, aS as buildRuleCtx, aT as clipboardCopyAction, aU as clipboardCutAction, aV as composeRectPose, aW as composeWorldPose, aX as createDispatcher, aY as decomposeRectPose, aZ as describeRule, a_ as drawLayers, a$ as drawOneLayer, b0 as enterTextEditAction, b1 as evaluate, b2 as evaluateEnabled, b3 as isLayerVisible, b4 as rebaseLocalPose, b5 as registerContentHandler, b6 as resolveParams, b7 as sliceAction, b8 as specificity, b9 as translateRectPose, ba as useAction, bb as useActionsRegistry, bc as useActiveToolContext, bd as useDepRegistry, be as useDepSource, bf as useOptionalActiveToolContext, bg as useOptionalDepRegistry, bh as usePointerContext, bi as useSelection, bj as worldPoseLookup } from './registry-l3JX0Z6b.js';
+import { S as Stroke, F as FillStyle, a as TextureHandle, T as TilePatternSpec, b as GradientKind, G as GradStop, c as GradientFill } from './paint-types-1fUdZUaH.js';
+export { d as GradientUnits, R as Region, e as StrokeAlign, f as alignedStrokeRect } from './paint-types-1fUdZUaH.js';
+import { B as Bounds, P as PoseProjection, F as FitViewToBoundsOptions, V as ViewportDims } from './geometry-C56YbnfD.js';
+export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-C56YbnfD.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 MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, a as LassoHitMode, b as LassoSelectAdapter, c as ResizeAdapter, d as SceneAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, f as LayoutSnap } from './types-DpQ0cWYC.js';
-export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DpQ0cWYC.js';
+import { N as NodeId, S as Scene, a as Node$1, b as SerializedScene, R as RectPose, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-C2R2bjxf.js';
+export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, L as LayerRecord, f as LeafNode, g as SerializedNode, h as SystemLayerRecord, i as SystemLayerSpec, j as UserLayerRecord, k as asNodeId } from './types-C2R2bjxf.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-BhrifbZ1.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-BhrifbZ1.js';
+import { U as UseResizeOptions } from './pointSnapToGrid-BBtn5bus.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-BBtn5bus.js';
+import { M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, a as LassoHitMode, b as LassoSelectAdapter, c as ResizeAdapter, d as SceneAdapter, L as LayoutStrategy, e as LayerEnumerableAdapter, I as InsertAdapter, C as ClipboardSnapshot, O as OrderedAdapter, f as LayoutSnap } from './types-DbysOO-2.js';
+export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-DbysOO-2.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-B6MMiodD.js';
 export { c as PATH_C, d as PATH_CMD_LENGTHS, e as PATH_L, f as PATH_M, g as PATH_Q, h as PATH_Z } from './path-B6MMiodD.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, d as StyledRun, R as ResolvedTextStyle, e as TextStyle, f as TextVerticalAlign } from './DrawCommand-BbPrSTra.js';
-export { g as DEFAULT_TEXT_STYLE, G as GroupDrawCommand, I as ImageDrawCommand, M as Mat3, h as ResolvedRun, a as ShaderDrawCommand, b as ShaderUniform, T as TextDrawCommand, i as fontString, j as markdownToRuns, k as resolveRuns, l as resolveTextStyle, n as runsToMarkdown, o as runsToPlainText, t as toRuns, v as verticalAlignOffset } from './DrawCommand-BbPrSTra.js';
-import { Op, CreateHistoryOptions, History } from '@weasel-js/history';
+import { D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, d as StyledRun, R as ResolvedTextStyle, e as TextStyle, f as TextVerticalAlign, M as Mat3$1 } from './DrawCommand-uNkv5TjO.js';
+export { g as DEFAULT_TEXT_STYLE, G as GroupDrawCommand, I as ImageDrawCommand, h as ResolvedRun, a as ShaderDrawCommand, b as ShaderUniform, T as TextDrawCommand, i as fontString, j as markdownToRuns, m as mat3, k as resolveRuns, l as resolveTextStyle, n as runsToMarkdown, o as runsToPlainText, t as toRuns, v as verticalAlignOffset } from './DrawCommand-uNkv5TjO.js';
+import { Op, HistorySelection, CreateHistoryOptions, History } from '@weasel-js/history';
 export * from '@weasel-js/history';
 export { Op } from '@weasel-js/history';
+export { I as ImageMinification, S as SpriteSheet, f as frameRect, r as resolveStrokeWidth, v as viewToMat3 } from './stroke-DaxnQ-u7.js';
 import { Mat3 } from '@weasel-js/geom';
 import { G as Guide } from './types-D2tTKEU0.js';
-export { U as UseInsertOptions } from './options-CbsIgQci.js';
+export { U as UseInsertOptions } from './options-C6HYCKP7.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 { I as ImageMinification, v as viewToMat3 } from './viewToMat3-CQW_YqDw.js';
 export { FontVariant, LocalFontOutlinesResult, OutlineFontStyle, OutlineSource, OutlineStatus, OutlineVariant, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
 import { CapabilityTag } from '@weasel-js/modes';
 
@@ -189,6 +189,79 @@ interface CellHighlightLayerOpts {
 /** Build a `RenderLayer` that fills a single grid cell — typically a snap-target preview. */
 declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderLayer<unknown>;
 
+/**
+ * @experimental
+ *
+ * A view the resolver can route input to: a camera and the rect it paints
+ * into, in canvas CSS-pixel space. A viewport node supplies one of these per
+ * frame; so could any other per-view surface.
+ */
+interface ResolvableView {
+    id: string;
+    view: View;
+    rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+/**
+ * @experimental
+ *
+ * The view an input event belongs to. `id` is `null` for the root view —
+ * the whole canvas, when no viewport contains the point.
+ *
+ * `origin` is the client-space origin of that view's surface, ready to hand
+ * to `clientToWorld` — which is the whole reason this type carries it rather
+ * than leaving callers to add the canvas rect and the view rect themselves.
+ */
+interface ViewTarget {
+    id: string | null;
+    view: View;
+    origin: {
+        left: number;
+        top: number;
+    };
+}
+/**
+ * @experimental
+ *
+ * Routes client points to views, and holds a captured pointer on the view its
+ * gesture started in.
+ *
+ * Stickiness is the point. A drag that leaves its view's rect — over a
+ * neighbouring view, or off the canvas — must keep reporting coordinates in
+ * the space it began in, or a marquee crossing a panel edge silently starts
+ * measuring against the wrong camera.
+ */
+interface ViewResolver {
+    /** Resolve and pin `pointerId`. Call on pointerdown. */
+    begin(pointerId: number, clientX: number, clientY: number): ViewTarget;
+    /**
+     * The view for a point. A pinned `pointerId` gets its pinned view, looked
+     * up fresh so a rect that moved mid-gesture is honored. Pass `null` for
+     * input with no pointer to capture — wheel, hover, keys.
+     */
+    at(pointerId: number | null, clientX: number, clientY: number): ViewTarget;
+    /** Release `pointerId`. Call on pointerup and pointercancel. */
+    end(pointerId: number): void;
+    /** Release every pin. */
+    clear(): void;
+}
+interface CreateViewResolverOpts {
+    /** Candidate views in paint order — the last one containing a point wins. */
+    views: () => readonly ResolvableView[];
+    /** The camera for points no view claims. */
+    root: () => View;
+    /** Client-space origin of the canvas element. */
+    canvasOrigin: () => {
+        left: number;
+        top: number;
+    };
+}
+declare function createViewResolver(opts: CreateViewResolverOpts): ViewResolver;
+
 /**
  * @experimental
  *
@@ -202,33 +275,50 @@ declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderL
  * lenses on the source.
  *
  * **Inner view semantics.** The source layers draw as if the inner view
- * filled the screen at world-origin (their own `viewToMat3(innerView)` runs
- * normally). The viewport then translates the result so that the inner
- * view's origin lands at `bounds.x, bounds.y` and clips to `(bounds.w,
- * bounds.h)`. Caller chooses `innerView.{x,y,scale}` to control which slice
- * of source-world is shown.
+ * filled the screen at world-origin — each is wrapped in `viewToMat3(view)`
+ * by the same `drawOneLayer` the outer canvas uses. The viewport then
+ * translates the result so that the inner view's origin lands at `bounds.x,
+ * bounds.y` and clips to `(bounds.w, bounds.h)`. Caller chooses
+ * `innerView.{x,y,scale}` to control which slice of source-world is shown.
  *
  * **Input is re-projected on request, not automatically.** `reproject` maps a
  * screen point into the inner view's world; a consumer that wants a click
- * inside a viewport to mean something calls it from its own handler. The
- * dispatcher is untouched, so tools still target the outer view — making
- * tools work *inside* a viewport is a larger question (which view a pinch
- * zooms, what a drag leaving the rect does) and wants its own design.
+ * inside a viewport to mean something calls it from its own handler, or feeds
+ * `resolvable` to `createViewResolver` to route a whole pointer stream.
+ * `<CanvasView>` is that wiring done for you; build on this directly for a
+ * viewport that takes no input, or to route it yourself.
  *
  * **Screen-space source layers** (e.g., debug overlays, selection chrome)
- * still render to the outer canvas, not into the viewport. To include
- * them, wrap them as world-space layers first.
+ * draw in the viewport's own CSS-pixel space: their coords are relative to
+ * the rect's top-left, and they clip to it, rather than to the outer canvas.
  */
-interface CreateViewportLayerOpts<TData> {
+interface CreateViewportLayerOpts<TData, TSource = TData> {
     id: string;
     label: string;
     /** Layers re-rendered through `view`. Each receives `(data, view, dims)`
-     *  exactly as the outer Canvas would call it. */
-    source: RenderLayer<TData>[];
-    /** The inner view. Static for now — a future revision will accept
-     *  `View | (outer: View, dims: Dims) => View` so derivations like
-     *  parallax and node-anchored scroll can compose. */
-    view: View;
+     *  exactly as the outer Canvas would call it.
+     *
+     *  Pass a thunk for a stack that is assembled elsewhere — it is read fresh
+     *  on every `draw`, the same way a thunked `view` is. */
+    source: readonly RenderLayer<TSource>[] | (() => readonly RenderLayer<TSource>[]);
+    /**
+     * The `data` the source layers receive, derived from what the outer canvas
+     * passed down. Omit and they get the outer canvas's own.
+     *
+     * A viewport showing the same scene through a second camera wants its own
+     * per-view helpers here — selection, chrome state and gesture previews that
+     * belong to *this* view rather than the one hosting it.
+     */
+    data?: (outer: TData) => TSource;
+    /**
+     * The inner view. Pass a thunk for a camera that moves — it is read fresh
+     * on every `draw`, `reproject` and `resolvable`, so those three cannot
+     * disagree about where the viewport is looking mid-gesture.
+     *
+     * The thunk receives the outer view and dims, so a derived camera
+     * (parallax, node-anchored scroll) is a function of the one hosting it.
+     */
+    view: View | ((outer: View, dims: Dims) => View);
     /** Where on the outer canvas this viewport is painted, in screen-space
      *  CSS pixels. Recomputed every frame so the rect can track an outer
      *  pose, follow a corner, etc. */
@@ -260,9 +350,9 @@ interface ViewportLayer<TData> extends RenderLayer<TData> {
      * `bounds` is a pure function of those, so this reproduces the exact rect
      * that was painted rather than a remembered one.
      *
-     * This does not touch the dispatcher: tools still receive outer-view
-     * coords, and a consumer that wants a click inside a viewport to mean
-     * something calls this from its own handler.
+     * This does not touch the dispatcher: a consumer that wants a click inside
+     * a viewport to mean something calls this from its own handler, or declares
+     * the viewport as a `<CanvasView>` and lets the canvas route to it.
      */
     reproject(outer: View, dims: Dims, screen: {
         x: number;
@@ -271,12 +361,20 @@ interface ViewportLayer<TData> extends RenderLayer<TData> {
         x: number;
         y: number;
     } | null;
+    /**
+     * This viewport as a routing candidate for {@link createViewResolver} —
+     * its inner view and the rect it paints into for the given outer frame.
+     *
+     * Pass the `outer` view and `dims` the frame was drawn with, for the same
+     * reason `reproject` wants them: `bounds` is recomputed, not remembered.
+     */
+    resolvable(outer: View, dims: Dims): ResolvableView;
 }
 /** Build a layer that renders other layers through a second view, inside a
  *  sub-region of the canvas — a minimap, an inset, a magnifier. Its
  *  `reproject` maps screen points back through the inner view so the region
  *  can be interacted with. */
-declare function createViewportLayer<TData>(opts: CreateViewportLayerOpts<TData>): ViewportLayer<TData>;
+declare function createViewportLayer<TData, TSource = TData>(opts: CreateViewportLayerOpts<TData, TSource>): ViewportLayer<TData>;
 /**
  * @experimental
  *
@@ -1007,7 +1105,17 @@ interface UseZoomReturn {
 declare function useZoom(opts: UseZoomOptions): UseZoomReturn;
 
 /**
- * Run `computeFitView` once when the viewport first has non-zero size, and
+ * Compute zoom and pan that fit `contentW x contentH` (in content units)
+ * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of
+ * each axis to fill (default 0.85 — leaves a uniform 15% margin).
+ */
+declare function computeFitViewport(viewportW: number, viewportH: number, contentW: number, contentH: number, padRatio?: number): {
+    zoom: number;
+    panX: number;
+    panY: number;
+};
+/**
+ * Run `computeFitViewport` once when the viewport first has non-zero size, and
  * apply the result via the supplied setters. Subsequent size changes are
  * ignored — this hook centers exactly once.
  */
@@ -1250,6 +1358,46 @@ interface UseHoverTrackingArgs {
  *  the component on every pointer move. */
 declare function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null;
 
+/**
+ * Project an action's keyboard bindings into the shape a shortcut chip
+ * renders from (`formatShortcut` / `formatShortcutParts` in
+ * `@weasel-js/ui`). Palette and menu surfaces show what an action answers
+ * to; the dispatcher reads the specs themselves.
+ */
+
+/** One keyboard shortcut, flattened for display. Structurally the
+ *  `ShortcutInput` weasel-ui formats — kept local so core doesn't depend on
+ *  the UI package. */
+interface ActionShortcut {
+    key: string;
+    mod: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/**
+ * The chip form of a single gesture spec, or `undefined` when the spec has
+ * none.
+ *
+ * Two kinds of collapsing, both because a binding list is written for a
+ * matcher rather than for a reader:
+ *
+ * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
+ *   shifted bracket reports as `'{'`). The first is the shortcut's name.
+ * - A modifier declared `'optional'` matches held or unheld, so it isn't
+ *   part of what the user has to press.
+ *
+ * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
+ * *required* `ctrl` or `meta` — nothing in the kit declares one, and the
+ * display shape carries only `mod`.
+ */
+declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
+/**
+ * Every keyboard shortcut an action answers to, in declaration order.
+ * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
+ * identical are emitted once; an action bound only to those returns empty.
+ */
+declare function actionShortcuts(action: Action): readonly ActionShortcut[];
+
 /**
  * `moveAction` — first `ongoing`-timing Action descriptor.
  *
@@ -1654,9 +1802,10 @@ declare const cloneAction: Action & {
  * variants can be registered as separate descriptors by consumers.
  *
  * ## Inertia
- * Not implemented — the descriptor ends cleanly at `onEnd`. The `useHandTool`
- * hook wires inertia via `useDecayLoop`; that remains available for consumers
- * who need it.
+ * Not implemented anywhere on the drag-pan path. `useHandTool` accepts an
+ * `inertia` option and calls `useVelocityTracker` / `useDecayLoop`, but its
+ * memo body ignores all three, so the option is inert — see docs/TODO.md.
+ * `useDecayLoop` itself works and is exported for consumers who wire it up.
  *
  * @see useHandTool — the React hook this descriptor parallels.
  */
@@ -1915,10 +2064,9 @@ declare function useStandardActions(opts: UseStandardActionsOptions): void;
  * 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`). Known exclusions from the op
- * factory roster — surfaces the scene doesn't own: `setSelection` (spread
- * `SelectionApi.adapterMethods` over this adapter when selection-carrying
- * ops must replay), `setPath`, and `setText`.
+ * `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
@@ -1928,12 +2076,14 @@ declare function useStandardActions(opts: UseStandardActionsOptions): void;
 
 /** 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. Selection, path and text ops are not covered; those surfaces belong
- *  to their own owners. */
+ *  scene. Path and text ops are not covered; those surfaces belong to their
+ *  own owners. */
 declare function defaultCommitAdapter<TPose>(scene: Scene<unknown, string, TPose>): {
     getNode: (id: string) => Node$1<unknown, string, TPose> | undefined;
     getNodes: () => Node$1<unknown, string, TPose>[];
     getPose: (id: string) => TPose;
+    getSelection: () => string[];
+    setSelection: (ids: string[]) => void;
     getParent: (id: string) => string | null;
     getChildren: (parentId: string | null) => string[];
     setChildOrder: (parentId: string | null, orderedIds: string[]) => void;
@@ -1961,6 +2111,55 @@ declare function useResizePolicy<TPose>(options: UseResizePolicyOptions<TPose>):
  *  run against the consumer's geometry. */
 declare function useSliceDep(dep: SliceDep): void;
 
+/**
+ * Everything about handling an input event that depends on *which view* it
+ * landed in: the dispatcher that runs it, and the three lookups that resolve
+ * a client point against that view's camera.
+ *
+ * @internal One per view. The hook builds the `id: null` one from its flat
+ *   options; `views` supplies the rest, and the hook chooses between them per
+ *   event, so that it — and its listener set — still mounts exactly once.
+ */
+interface DispatcherViewTarget {
+    /** `null` is the root view — the whole canvas. Matches `ViewTarget.id`. */
+    id: string | null;
+    dispatcher: Dispatcher;
+    affordanceAt: UseGestureDispatcherOptions['affordanceAt'];
+    classifyTarget: UseGestureDispatcherOptions['classifyTarget'];
+    clientToWorld: UseGestureDispatcherOptions['clientToWorld'];
+    /**
+     * The deps this view answers for itself — its camera, its selection, and
+     * whatever else is per-view rather than per-canvas. Read per event; every
+     * name it does not carry still resolves through the canvas registry.
+     *
+     * This is why a view does not get a `DepRegistryProvider` of its own. The
+     * registry is where a consumer registers *sources*, and one per view would
+     * fragment that: a consumer overriding `insert` would have to know how many
+     * views exist and override each. An overlay keeps one place to register and
+     * one authority per dep, with the view claiming only what is genuinely its.
+     *
+     * Without this a gesture inside a panel pans the whole canvas and selects
+     * into the canvas's selection — correct coordinates alone do not make
+     * routing correct.
+     */
+    deps?: () => Partial<DepSchema>;
+}
+/**
+ * The part of `features/viewports`' `ViewResolver` the dispatcher needs: which
+ * view a client point belongs to, pinned to the view a gesture began in.
+ *
+ * @internal Structural on purpose — a `ViewResolver` satisfies it, and the
+ *   dispatcher stays free of the viewport module.
+ */
+interface ViewIdResolver {
+    begin(pointerId: number, clientX: number, clientY: number): {
+        id: string | null;
+    };
+    at(pointerId: number | null, clientX: number, clientY: number): {
+        id: string | null;
+    };
+    end(pointerId: number): void;
+}
 /** Options for `useGestureDispatcher`: the element to listen on, the actions
  *  and tools in play, and the hooks that turn raw DOM events into the world
  *  coordinates and hit targets bindings match against. */
@@ -2088,6 +2287,24 @@ interface UseGestureDispatcherOptions {
      * wires this; tests / harnesses without chrome-caps state can omit it.
      */
     getRuleCtx?: () => RuleCtx;
+    /**
+     * Routing for a canvas hosting more than one view: the non-root dispatch
+     * records to choose between, read fresh per event, and the resolver that
+     * chooses. Omit for a single view — then every event runs on the record the
+     * flat options above describe, which is what they are: view zero.
+     *
+     * A resolved id with no live record falls back to the root, so a view that
+     * unmounts mid-gesture degrades instead of dropping the event.
+     *
+     * Keyboard and paste have no coordinates to resolve; they run on the view
+     * the last coordinate-bearing event resolved to.
+     *
+     * @internal
+     */
+    views?: {
+        targets: () => readonly DispatcherViewTarget[];
+        resolver: ViewIdResolver;
+    };
 }
 /**
  * Attach the input pipeline to a canvas: DOM pointer, wheel, keyboard and
@@ -2433,8 +2650,7 @@ interface ToolPrefColor extends ToolPrefBase<'color', string> {
  * app-supplied renderer. Deliberately NOT index-signatured so concrete
  * app interfaces stay assignable. Mirrors weasel-ui's `PrefCustom`.
  */
-interface ToolPrefCustom extends ToolPrefBase<string, unknown> {
-}
+type ToolPrefCustom = ToolPrefBase<string, unknown>;
 /**
  * A whole `FillStyle`, not a color inside one. Use it wherever the value is
  * the tagged paint union — a solid color, a pattern, a gradient — rather
@@ -2705,12 +2921,29 @@ 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)
@@ -3147,8 +3380,17 @@ interface CanvasExtensionApi {
      * `strength` carry through from the hit when the layer sets them.
      * A layer's owner binds a `kindOf` predicate on that kind to claim the
      * gesture; see `@weasel-js/hud` for the worked example.
+     *
+     * `frame` names the camera and surface size the point is expressed against.
+     * Omit it for the canvas's own view — the only case until a caller routes
+     * input to a viewport node, where the point is in that node's inner world
+     * and a layer resolving screen-pixel tolerances needs its view and rect
+     * size rather than the canvas's.
      */
-    hitTestExtras(worldX: number, worldY: number): {
+    hitTestExtras(worldX: number, worldY: number, frame?: {
+        view: View;
+        dims: Dims;
+    }): {
         layerId: string;
         hit: LayerHit;
     } | null;
@@ -3227,6 +3469,104 @@ interface GestureSource {
     getVersion(): number;
 }
 
+/**
+ * The half of {@link CanvasHelpers} that belongs to one view — everything
+ * answered by a camera's own tools, gestures and selection. A canvas hosting
+ * several viewports needs one of these per view; the surface half is shared.
+ */
+interface CanvasViewHelpers<TPose> {
+    /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,
+     *  otherwise the committed pose from the adapter. Returns `null` if the id
+     *  isn't known. */
+    getEffectivePose(id: string): TPose | null;
+    /** Overlay-aware bounds for `id`. */
+    getEffectiveBounds(id: string): Bounds | null;
+    /**
+     * World-space AABB of everything the in-flight gesture proposes — the
+     * displaced poses of nodes being moved / resized / rotated / cloned, plus
+     * any nascent insert that has no scene node yet. `null` when no gesture is
+     * in flight.
+     *
+     * This reports the *gesture*, not the document: committed content the
+     * gesture isn't touching is excluded, so a consumer that wants the union
+     * with the rest of the scene still walks its own ids through
+     * `getEffectiveBounds`. It exists because every other lookup here is keyed
+     * by node id, which can't answer "where is the shape the user is drawing
+     * right now" — a drag-to-insert has no id until pointer-up.
+     *
+     * Select-only gestures are deliberately excluded: a marquee or lasso has
+     * geometry but proposes no content, and a consumer sizing itself to the
+     * gesture must not grow because the user swept a selection rectangle.
+     *
+     * The result is a plain AABB — never rotated. Rotated parts are folded in
+     * by their rotated extent (a union of several oriented boxes has no single
+     * orientation to report).
+     */
+    getGestureBounds(): Bounds | null;
+    /**
+     * Subscribe to the gesture layer's change signal — the other half of the
+     * `useSyncExternalStore` contract for everything on this object that moves
+     * during a drag (`getEffectivePose`, `getEffectiveBounds`,
+     * `getGestureBounds`). Returns an unsubscribe.
+     *
+     * Fires once per dispatcher pump: gesture start, every pointermove that
+     * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing
+     * actions (a slider bound to an ongoing action pumps the same way). It
+     * fires on the pump, not on a diff: a pump that changed nothing observable
+     * still notifies, so don't hang expensive work directly off the callback.
+     *
+     * It does **not** cover committed scene edits (subscribe to the scene for
+     * those) or previews a consumer's own tool publishes from React state
+     * (that tool re-renders on its own).
+     *
+     * Without a gesture source wired — a bare `<Canvas>` — this is a no-op
+     * subscription that never fires.
+     */
+    subscribeGestures(fn: () => void): () => void;
+    /**
+     * Monotonic counter bumped on exactly the events `subscribeGestures` fires
+     * on. Pair the two for `useSyncExternalStore`:
+     *
+     * ```ts
+     * const gestureVersion = useSyncExternalStore(
+     *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),
+     *   () => helpersRef.current?.getGestureVersion() ?? 0,
+     * );
+     * ```
+     *
+     * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with
+     * no gesture source reports, forever.
+     */
+    getGestureVersion(): number;
+    /** Returns the live ChromeState built once per render. Affordances and
+     *  custom layers that need overlay-aware selection state (selection ids,
+     *  bounds, multi-union AABB, modifier flags) read from this. */
+    getChromeState(): ChromeState;
+}
+/**
+ * The half of {@link CanvasHelpers} that belongs to the surface — one GL
+ * context, one debug sink, one chrome-caps resolver, however many views are
+ * drawn on it.
+ */
+interface CanvasSurfaceHelpers {
+    /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that
+     *  want to participate in `hitboxes`/`bounds`/etc. visualization can
+     *  call into this from their `draw` callback. Returns `null` when
+     *  debug is off — no-op for production renders. */
+    getDebug(): DebugSink | null;
+    /** Chrome-caps visibility predicate, keyed by chrome id. Returns a
+     *  function that affordance/overlay layers can call per-element to
+     *  decide whether to draw / hit-test. When the parent didn't supply
+     *  a resolver, this returns the universal `() => true`. */
+    getIsVisible(): (id: string) => boolean;
+}
+/** Live overlay-aware lookups exposed to custom layers via `helpersRef`.
+ *  What a layer receives as its `data` argument, unchanged: the two halves
+ *  are split so a per-view set can be built independently of the surface's,
+ *  not to make layers ask for one. */
+interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {
+}
+
 /**
  * Selection overlay primitives — render layers for drawing selection
  * outlines and corner resize handles in world space.
@@ -3351,7 +3691,23 @@ interface SelectionHandlesLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
     };
 }
 /** Options for `createSelectionOverlayLayer`. */
-interface SelectionOverlayLayerOpts<TPose> extends SelectionLayerCommon<TPose> {
+interface SelectionOverlayLayerOpts<TPose> extends Omit<SelectionLayerCommon<TPose>, 'getSelection' | 'getPose'> {
+    /**
+     * Which ids to draw chrome for. Omit to take them from the `ChromeState` on
+     * the draw envelope, which is what makes one canvas's several views each
+     * outline their own selection — the layer is shared, the envelope is not.
+     *
+     * A multi-selection resolves to the synthetic union id, with the real
+     * members going to the outline pass, exactly as the explicit form does.
+     */
+    getSelection?: () => readonly NodeId[];
+    /**
+     * Resolve an id to the pose to draw chrome around. Omit to take bounds from
+     * the same envelope `getSelection` omitted takes ids from — one cascade,
+     * the one the chrome state was built with, rather than a second one here
+     * that has to agree with it.
+     */
+    getPose?: (id: string) => TPose | null;
     outline?: Stroke & {
         pad?: number;
     };
@@ -3818,86 +4174,26 @@ interface CanvasProps<TNode extends {
      * every chrome element visible (pre-chrome-caps behavior).
      */
     getIsVisible?: () => (id: string) => boolean;
-}
-/** Live overlay-aware lookups exposed to custom layers via `helpersRef`. */
-interface CanvasHelpers<TPose> {
-    /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,
-     *  otherwise the committed pose from the adapter. Returns `null` if the id
-     *  isn't known. */
-    getEffectivePose(id: string): TPose | null;
-    /** Overlay-aware bounds for `id`. */
-    getEffectiveBounds(id: string): Bounds | null;
-    /**
-     * World-space AABB of everything the in-flight gesture proposes — the
-     * displaced poses of nodes being moved / resized / rotated / cloned, plus
-     * any nascent insert that has no scene node yet. `null` when no gesture is
-     * in flight.
-     *
-     * This reports the *gesture*, not the document: committed content the
-     * gesture isn't touching is excluded, so a consumer that wants the union
-     * with the rest of the scene still walks its own ids through
-     * `getEffectiveBounds`. It exists because every other lookup here is keyed
-     * by node id, which can't answer "where is the shape the user is drawing
-     * right now" — a drag-to-insert has no id until pointer-up.
-     *
-     * Select-only gestures are deliberately excluded: a marquee or lasso has
-     * geometry but proposes no content, and a consumer sizing itself to the
-     * gesture must not grow because the user swept a selection rectangle.
-     *
-     * The result is a plain AABB — never rotated. Rotated parts are folded in
-     * by their rotated extent (a union of several oriented boxes has no single
-     * orientation to report).
-     */
-    getGestureBounds(): Bounds | null;
     /**
-     * Subscribe to the gesture layer's change signal — the other half of the
-     * `useSyncExternalStore` contract for everything on this object that moves
-     * during a drag (`getEffectivePose`, `getEffectiveBounds`,
-     * `getGestureBounds`). Returns an unsubscribe.
+     * Show or hide whole render layers by id. An id absent from the map falls
+     * back to the layer's own `defaultVisible`, and a layer marked `alwaysOn`
+     * ignores the map entirely.
      *
-     * Fires once per dispatcher pump: gesture start, every pointermove that
-     * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing
-     * actions (a slider bound to an ongoing action pumps the same way). It
-     * fires on the pump, not on a diff: a pump that changed nothing observable
-     * still notifies, so don't hang expensive work directly off the callback.
+     * Hiding a layer also stops it claiming pointer events through
+     * `hitTestExtras` — a layer nobody can see must not swallow a click.
      *
-     * It does **not** cover committed scene edits (subscribe to the scene for
-     * those) or previews a consumer's own tool publishes from React state
-     * (that tool re-renders on its own).
-     *
-     * Without a gesture source wired — a bare `<Canvas>` — this is a no-op
-     * subscription that never fires.
+     * This is `getIsVisible`'s coarser sibling: that one gates individual
+     * chrome elements *within* a layer, this one gates the layer.
      */
-    subscribeGestures(fn: () => void): () => void;
+    layerVisibility?: Record<string, boolean>;
     /**
-     * Monotonic counter bumped on exactly the events `subscribeGestures` fires
-     * on. Pair the two for `useSyncExternalStore`:
-     *
-     * ```ts
-     * const gestureVersion = useSyncExternalStore(
-     *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),
-     *   () => helpersRef.current?.getGestureVersion() ?? 0,
-     * );
-     * ```
+     * Draw order, by layer id, bottom first. Omit for the order the layers
+     * arrive in.
      *
-     * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with
-     * no gesture source reports, forever.
+     * **A listed order is the whole list:** any layer whose id is missing from
+     * it is not drawn. Reordering two layers means naming all of them.
      */
-    getGestureVersion(): number;
-    /** Returns the live ChromeState built once per render. Affordances and
-     *  custom layers that need overlay-aware selection state (selection ids,
-     *  bounds, multi-union AABB, modifier flags) read from this. */
-    getChromeState(): ChromeState;
-    /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that
-     *  want to participate in `hitboxes`/`bounds`/etc. visualization can
-     *  call into this from their `draw` callback. Returns `null` when
-     *  debug is off — no-op for production renders. */
-    getDebug(): DebugSink | null;
-    /** Chrome-caps visibility predicate, keyed by chrome id. Returns a
-     *  function that affordance/overlay layers can call per-element to
-     *  decide whether to draw / hit-test. When the parent didn't supply
-     *  a resolver, this returns the universal `() => true`. */
-    getIsVisible(): (id: string) => boolean;
+    layerOrder?: string[];
 }
 
 /** Which of a node's two per-anchor color arrays an override applies to. */
@@ -3924,6 +4220,77 @@ declare class ColorOverrideRegistry {
     version(): number;
 }
 
+/** One keyframe. `easing` shapes the approach INTO this key from the previous
+ *  one, so the first key's easing is never consulted. */
+interface Keyframe<T> {
+    /** Time within the track's timeline, in ms. */
+    t: number;
+    value: T;
+    easing?: EasingFn;
+}
+/** A track sampled as a pure function of the playhead. Scrubbing one is free
+ *  and order-independent. */
+interface SampledTrack<T> {
+    kind: 'sampled';
+    label?: string;
+    /** Sorted ascending by `t`. `sampleTrack` assumes this and does not sort. */
+    keys: Keyframe<T>[];
+    /** Required when T is not `number`; defaults to numeric lerp otherwise. */
+    interpolate?: Interpolate<T>;
+    /** Built once per segment and cached. Takes precedence over `interpolate`. */
+    interpolator?: InterpolatorFactory<T>;
+    onTick: (value: T) => void;
+}
+/** A track of edge crossings. Fires only when the playhead advances forward
+ *  under playback — never on `seek`. */
+interface EventTrack {
+    kind: 'event';
+    label?: string;
+    /** Sorted ascending by `t`. */
+    events: {
+        t: number;
+        fire: () => void;
+    }[];
+}
+/** A nested timeline, evaluated at `playhead - at`. Children are NOT registered
+ *  with the animator separately; the parent evaluates them. */
+interface TimelineTrack {
+    kind: 'timeline';
+    label?: string;
+    at: number;
+    timeline: NestedTimeline;
+}
+type Track = SampledTrack<any> | EventTrack | TimelineTrack;
+/** What a child timeline may declare. The parent owns playback, so `loop`,
+ *  `autoplay`, `onDone` and `cancelKey` have no meaning below the root. */
+interface NestedTimeline {
+    tracks: Track[];
+    /** Defaults to the largest end time across `tracks`. */
+    duration?: number;
+}
+interface TimelineOptions extends NestedTimeline {
+    /** `true` loops forever, `n` loops n additional times. Default false. */
+    loop?: boolean | number;
+    /** Default true. When false the timeline registers but holds at t=0 until resumed. */
+    autoplay?: boolean;
+    onDone?: () => void;
+    cancelKey?: string;
+}
+interface TimelineHandle extends AnimationHandle {
+    /** Move the playhead. Never fires event tracks, at any depth. */
+    seek(t: number): void;
+    /** Current playhead in ms. */
+    time(): number;
+    duration(): number;
+    tracks(): readonly Track[];
+    /** Run `fn`, then recompute duration, drop cached interpolators, and notify.
+     *  Every mutation must go through this — an edited keyframe otherwise keeps
+     *  interpolating toward its old value with no visible error. */
+    edit(fn: () => void): void;
+    /** Notified after each `edit`. Returns an unsubscribe. */
+    subscribe(cb: () => void): () => void;
+}
+
 /** An easing curve: maps normalized progress `t ∈ [0, 1]` to eased progress.
  *  Curves may leave the 0–1 range in the middle (back, elastic) but should
  *  pass through 0 at 0 and 1 at 1. */
@@ -4151,6 +4518,12 @@ interface Animator {
      */
     stagger<TItem>(items: readonly TItem[], delay: StaggerDelay): StaggerBuilder<TItem>;
     stagger<TItem>(items: readonly TItem[], delay: StaggerDelay, factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
+    /**
+     * Keyframe timeline. Registered like any other animation, so its playhead
+     * responds to `pause`, `setTimeScale` and `cancelKey`. Sampled tracks are a
+     * pure function of the playhead; event tracks fire only on forward playback.
+     */
+    timeline(opts: TimelineOptions): TimelineHandle;
     /** Per-node, per-channel color override registry consulted by the renderer's
      *  path layer before reading consumer accessors. Used by `tweenVertexColors`,
      *  `springVertexColors`, `cycleVertexColors`, `staggerVertexColors`. Cleared
@@ -4410,6 +4783,61 @@ interface UseRotateOptions<TPose> {
     pivot?: 'each' | 'union';
 }
 
+/** A rect on the surface, in CSS pixels from the canvas top-left. */
+interface ViewRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Props for `<CanvasView>`. @experimental */
+interface CanvasViewProps {
+    /** Identifies the view to the surface and to input routing. Must be unique
+     *  among the views on one canvas. */
+    id: string;
+    /** Where this view paints, recomputed every frame so the rect can track the
+     *  outer camera. A plain rect is accepted for a fixed panel. */
+    bounds: ViewRect | ((outer: View, dims: Dims) => ViewRect);
+    /** Camera. Supply this to control it; otherwise the view keeps its own,
+     *  seeded from `defaultView`. `onViewChange` fires either way. */
+    view?: View;
+    defaultView?: View;
+    onViewChange?: (v: View) => void;
+    /** Pan limits, applied to every camera change the same way `<Canvas>`
+     *  applies its own. */
+    viewBounds?: Bounds;
+    /** Which of the surface's layers this view paints. Defaults to all of them —
+     *  the same content through a second camera. */
+    layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];
+    /** Opaque ground painted before the source layers, so the surface does not
+     *  show through where the inner camera sees nothing. */
+    background?: string;
+    /** Paint and hit order. Defaults to `Infinity` — after every view the
+     *  surface declared as a prop. */
+    order?: number;
+    /** Label for debug overlays. Defaults to the id. */
+    label?: string;
+    /** A selection of this view's own, which actions dispatched inside it read
+     *  and write instead of the surface's. Omit both this and
+     *  `selectionOptions` and the view shares the surface's selection — the
+     *  default, so undo restores one selection rather than N. */
+    selection?: SelectionApi;
+    /** Opts this view into owning a selection, configured thus. Ignored when
+     *  `selection` is supplied. */
+    selectionOptions?: UseSelectionOptions;
+}
+/**
+ * @experimental
+ *
+ * One view on a shared canvas. Owns a camera, contributes the viewport node
+ * that paints it, and registers the dispatch record that sends gestures inside
+ * its rect to that camera rather than to the canvas's.
+ *
+ * Renders nothing itself — it is a declaration, and the surface does the
+ * drawing. Outside a surface that mounts a view registry it is inert.
+ */
+declare function CanvasView(props: CanvasViewProps): null;
+
 /**
  * Built-in shape tool ids handled by `useBuiltinShapeTools`. Each maps to a
  * kit tool hook + a default `create` that produces a leaf node compatible
@@ -5153,6 +5581,17 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      * subscriber list stays quiet).
      */
     animator?: Animator;
+    /**
+     * Extra views on this canvas: each is a camera over a rect of the same
+     * surface, drawn through one GL context, with input routed to it. The flat
+     * `view` / `onViewChange` props above stay the canvas's own camera — view
+     * zero — and are unaffected by anything declared here.
+     *
+     * Order is paint and hit order, low to high. Each entry is a
+     * `<CanvasView>`; mounting one as a child is the same declaration, and
+     * children land after every entry here.
+     */
+    views?: readonly CanvasViewProps[];
     /**
      * Children rendered alongside the canvas. Useful for siblings that need
      * the same `<ActionsProvider>` scope (e.g. shortcuts overlays, probes).
@@ -5628,6 +6067,14 @@ declare const SceneViewCanvas: typeof SceneViewCanvasInner;
  *  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
+ *  journal owner) that should restore selection the way the scene's own
+ *  history does. */
+declare function sceneSelectionStore(scene: {
+    getSelection(): readonly NodeId[];
+    setSelection(ids: readonly NodeId[]): void;
+}): HistorySelection;
 /** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.
  *  Function fields (e.g., `clipFromPose`) are resolved by string key via the
  *  registry passed in `options`. Throws on unknown version, unknown registry
@@ -7380,6 +7827,19 @@ declare function canBringForward(list: string[], ids: string[]): boolean;
 /** Symmetric to `canBringForward` — see that docstring. */
 declare function canSendBackward(list: string[], ids: string[]): boolean;
 
+interface RestoreEntry {
+    parentId: string | null;
+    before: string[];
+}
+/** @internal */
+interface ReorderArgs {
+    ids: string[];
+    direction: ReorderDirection;
+    label?: string;
+    /** Pre-mutation child order per touched parent. Filled in on first apply;
+     *  arrives populated when the op is rebuilt from a snapshot. */
+    prevOrders?: RestoreEntry[];
+}
 /** Direction of a sibling z-order reorder. */
 type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';
 /**
@@ -7389,11 +7849,7 @@ type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';
  *   - `'front'`    — move to the top, preserving relative order
  *   - `'back'`     — move to the bottom, preserving relative order
  */
-declare function createReorderOp(args: {
-    ids: string[];
-    direction: ReorderDirection;
-    label?: string;
-}): Op;
+declare function createReorderOp(args: ReorderArgs): Op;
 /** @internal */
 interface MoveToIndexArgs {
     ids: string[];
@@ -9660,6 +10116,69 @@ declare function rainbowVertexColors(n: number, opts?: {
  *  `to`-target typically needs. */
 declare function solidVertexColors(n: number, r: number, g: number, b: number, a?: number): number[];
 
+/**
+ * Sample a track at `t`. Pure: no state, no side effects, safe to call for any
+ * `t` in any order — which is what makes scrubbing free.
+ *
+ * `segmentCache` memoizes `interpolator` factories by the index of the segment's
+ * later key. Callers that mutate keys must drop the cache; `createTimeline`
+ * drops it wholesale on `edit`.
+ */
+declare function sampleTrack<T>(track: SampledTrack<T>, t: number, segmentCache?: Map<number, (u: number) => T>): T | undefined;
+
+/** A joint's local transform. Deliberately NOT the scene's generic `TPose`:
+ *  `TPose` is consumer-defined and may be a bare AABB with no rotation term,
+ *  which a joint chain cannot compose through. */
+interface JointTransform {
+    x: number;
+    y: number;
+    /** Radians. */
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+interface Joint {
+    name: string;
+    /** Parent joint name, or null for a root. */
+    parent: string | null;
+    /** Local transform at rest. */
+    bind: JointTransform;
+}
+/** Joints in topological order: every joint appears after its parent. */
+interface Skeleton {
+    joints: Joint[];
+}
+/** Local deltas from the bind pose, keyed by joint name. Absent joints and
+ *  absent fields mean "no change from bind". */
+type Pose = Record<string, Partial<JointTransform>>;
+declare const IDENTITY_JOINT: JointTransform;
+
+/**
+ * Weighted blend of poses. Weights are normalized, so `[1, 1]` means an even
+ * mix. A joint absent from a pose contributes its identity delta, and a field
+ * absent from a joint contributes that field's identity — 0 for translation and
+ * rotation, 1 for scale. Blending scale toward 0 for an absent field would
+ * collapse the joint, which is the bug this avoids.
+ *
+ * Rotation blends the short way around the circle, so 0.1 and TAU-0.1 average
+ * to 0 rather than to PI.
+ *
+ * This doubles as the interpolator for a `SampledTrack<Pose>`: interpolating
+ * between two poses at `u` is `blendPoses([a, b], [1 - u, u])`.
+ */
+declare function blendPoses(poses: Pose[], weights: number[]): Pose;
+
+/**
+ * Resolve every joint's world transform by walking the skeleton once and
+ * composing each joint onto its already-resolved parent.
+ *
+ * `skeleton.joints` must be in topological order — a joint whose parent has not
+ * been resolved yet throws rather than silently resolving against identity,
+ * because that failure is otherwise invisible until a limb renders in the wrong
+ * place.
+ */
+declare function resolveSkeleton(skeleton: Skeleton, pose: Pose): Map<string, Mat3$1>;
+
 /** Snap policy that never picks a target — every drop is rejected, which is
  *  what a free-form container wants. */
 declare function none<TPose>(): LayoutSnap<TPose>;
@@ -9919,4 +10438,4 @@ interface InsertOverlayStyle {
     lineWidth?: number;
 }
 
-export { ANCHOR_HIT_BASE_PX, Action, 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, type AnimateToBoundsOptions, type AnimationHandle, type Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, type 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 CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, type ColorOverride, type ColorOverrideFn, 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 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_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DecayLoopConfig, type DecayOptions, 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 DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EASINGS, type EasingFn, type EasingName, Eligibility, type EligibilityState, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, FillStyle, type FitTextPoseOptions, FitViewToBoundsOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GestureSource, GradStop, GradientFill, GradientKind, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragPoint, type HeadlessCanvasLike, HotkeyTrigger, type IconProps, type ImageNodeData, type ImageStatus, type IndicatorStyle, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type Interpolate, type InterpolatorFactory, IntersectIcon, KIT_SHAPE_KINDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerHit, type LayerSlotValue, type LayersMap, type LayoutLine, type LayoutResult, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, type LoopFactory, type LoopOptions, MIXED, MOVE_ANCHORS, type MarkdownFontOptions, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredText, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NodeClientRect, type NodeFill, NodeId, type NodeInk, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, OverlayPosition, PATH_ANCHOR_CHROME_ID, type 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, type PhysicsHandle, type PhysicsOptions, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomToolOpts, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, PoseProjection, type PoseRotation, type PositionedRun, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type Rect, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, ResolvedTextStyle, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SPRING_PRESETS, 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 SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, type SetFlagResult, type SetPathFields, ShaderProgramHandle, type ShapeCoversPointOptions, type SharedAnchor, type Simulation, type SimulationForce, type SimulationNode, SliceDep, type SnapPattern, type SnapPointOptions, SnapStrategy, type SplitByLineOptions, type SpringOptions, type SpringPoseOptions, type SpringPreset, type SpringPresetName, type SpringVertexColorsOptions, type StaggerBuilder, type StaggerDelay, type StaggerFactory, type StaggerOptions, type StaggerPerItem, type StaggerSpringPoseOptions, type StaggerTweenOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, Stroke, type StyleKey, StyledRun, type StylusData, SubtractIcon, SvgIngestOptions, type TextEditScreenPose, type TextEditSelection, TextIcon, type TextLineBoxesOpts, type TextPose, type TextRenderer, TextStyle, TextVerticalAlign, TextureHandle, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, TilePatternSpec, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type TweenLoopOptions, type TweenOptions, type TweenPoseOptions, type TweenVertexColorsOptions, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type 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 UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, 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 VertexColorChannel, View, ViewTransform, type ViewportConfig, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomOptions, VisibilityRules, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, bezierCubic, bezierQuadratic, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isDebugEnabled, isEditableTarget, isPatternSpec, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, liveScope, makeViewportZoomAction, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, 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, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerNodeShape, registerOpFactory, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolvePatternSpec, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, scaleDelta, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scopeBindings, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, setScratch, shapeCoversPoint, snap, snapPoint, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, styleAtRange, subscribeImageReady, textCommand, textLineBoxes, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, viewportDragPanAction, viewportZoomAction, viewportsAt, 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, type AnimateToBoundsOptions, type AnimationHandle, type Animator, AnyTool, AreaSelectAdapter, type ArrayAdapter, type ArrayAdapterConfig, BUNDLE_TOOLS, BindingScope, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, type 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 CellHighlightLayerOpts, ChromeCtx, ChromeId, ChromeState, type ClampBounds, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, type ColorOverride, type ColorOverrideFn, 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_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DebugConfig, DebugSink, DebugSnapshot, DebugStrokes, DebugTheme, type DecayLoopConfig, type DecayOptions, 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 DragPayload, type DragRadialController, type DragRadialCtx, type DragRadialEndCtx, type DragRadialPoint, type DragRadialState, type DragRectBounds, type DragRectController, type DragRectCtx, type DragRectEndCtx, type DragRectPoint, DrawCommand, type DropZoneOptions, EASINGS, type EasingFn, type EasingName, Eligibility, type EligibilityState, EllipseIcon, type EventTrack, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, type FillPoseBox, FillStyle, type FitTextPoseOptions, FitViewToBoundsOptions, type FlagKey, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GestureSource, GradStop, GradientFill, GradientKind, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HANDLE_BASE_PX, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragPoint, type HeadlessCanvasLike, HotkeyTrigger, IDENTITY_JOINT, type IconProps, type ImageNodeData, type ImageStatus, type IndicatorStyle, InsertAdapter, InsertBehavior, InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type Interpolate, type InterpolatorFactory, IntersectIcon, type Joint, type JointTransform, KIT_SHAPE_KINDS, type Keyframe, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, LayerEnumerableAdapter, LayerHit, type LayerSlotValue, type LayersMap, type LayoutLine, type LayoutResult, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, type LoopFactory, type LoopOptions, MIXED, MOVE_ANCHORS, type MarkdownFontOptions, Mat3$1 as Mat3, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredText, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, type Mixed, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type NestedHitOpts, type NestedHitTester, type NestedTimeline, type NodeClientRect, type NodeFill, NodeId, type NodeInk, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, OverlayPosition, PATH_ANCHOR_CHROME_ID, type 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, type PhysicsHandle, type PhysicsOptions, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomToolOpts, type PixelRenderPlan, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerProviderIfRoot, type PointerSample, type PointerStylusState, PolygonIcon, PolygonPath, type PolygonPoint, type Pose, PoseProjection, type PoseRotation, type PositionedRun, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, type RangeStyle, type RasterImage, type Rect, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, ResizePose, type ResolvableView, ResolvedTextStyle, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, Rule, RuleCtx, type RunStylePatch, SPRING_PRESETS, type 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 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 SpringOptions, type SpringPoseOptions, type SpringPreset, type SpringPresetName, type SpringVertexColorsOptions, type StaggerBuilder, type StaggerDelay, type StaggerFactory, type StaggerOptions, type StaggerPerItem, type StaggerSpringPoseOptions, type StaggerTweenOptions, type StaggerVertexColorsOptions, type StandardSlotConfig, type StandardSlotName, StarIcon, type StarPoint, type StartEditOptions, Stroke, type StyleKey, StyledRun, type StylusData, SubtractIcon, SvgIngestOptions, type TextEditScreenPose, type TextEditSelection, TextIcon, type TextLineBoxesOpts, type TextPose, type TextRenderer, TextStyle, TextVerticalAlign, TextureHandle, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, TilePatternSpec, type TimelineHandle, type TimelineOptions, type TimelineTrack, Tool, type ToolBundle, ToolDef, ToolKeybinding, type ToolPref, type ToolPrefBoolean, type ToolPrefBooleanControl, type ToolPrefColor, type ToolPrefCustom, type ToolPrefEnum, type ToolPrefEnumControl, type ToolPrefGroup, type ToolPrefKind, type ToolPrefLeaf, type ToolPrefNumber, type ToolPrefNumberControl, type ToolPrefNumberUnit, type ToolPrefPaint, type ToolPrefString, type ToolPrefStringControl, type ToolsApi, type Track, type TweenLoopOptions, type TweenOptions, type TweenPoseOptions, type TweenVertexColorsOptions, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type 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 UseHoverTrackingArgs, type UseImageToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, UseMoveOptions, 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 VertexColorChannel, View, type ViewRect, type ViewResolver, type ViewTarget, ViewTransform, type ViewportConfig, ViewportDims, type ViewportLayer, ViewportToolDef, type ViewportZoomOptions, VisibilityRules, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, 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, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createReparentOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetSelectionOp, createSetTextOp, createTextLayer, createTilePattern, createTransformOp, createViewResolver, createViewportLayer, cycleVertexColors, decomposePath, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deleteScratch, deriveAlignmentGuides, deriveParallaxView, dispatchApplyBatch, dlog, domPositionToCharOffset, domToRuns, dwarn, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, ellipsePath, enumerateAnchors, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getScratch, getStylusData, gradientForBounds, gradientGeometry, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isDebugEnabled, isEditableTarget, isPatternSpec, keySpecShortcut, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, liveScope, makeViewportZoomAction, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, 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, poseRotationOf, pressureToWidth, pxExtent, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerNodeShape, registerOpFactory, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, 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, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, styleAtRange, subscribeImageReady, textCommand, textLineBoxes, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, viewportDragPanAction, viewportZoomAction, viewportsAt, when, withAlpha01, withCoord, withGradientKind, withinPxBox, withinPxRadius, worldEditToStorage, zoomAt, zoomAtLeast };