@weasel-js/core 0.6.0 → 0.7.1

package/dist/index.d.ts

@@ -1,41 +1,62 @@
 import * as React$1 from 'react';
-import React__default, { RefObject, MutableRefObject, ReactNode, ReactElement, Ref, MouseEvent as MouseEvent$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-Cf87knjU.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-Cf87knjU.js';
-import { R as RenderLayer, D as Dims, S as SelectionApi, A as ActionDeps, P as Point2, G as GestureBinding, T as Tool, O as OngoingHandle, B as BindingOpts, I as Invoker, a as AffordanceHit, b as AnyTool, c as ToolsDispatcher, d as ToolCtx, e as ToolsDispatcherOptions, f as ToolKeybinding, H as HotkeyTrigger, C as ChromeState, U as UseSelectionOptions, g as Affordance, h as AffordanceBinding } from './index-DZBYMsHI.js';
-export { i as AffordanceRegion, j as CustomPaintContext, k as DblTapChannel, l as Decision, m as DragChannel, n as ImmediateInvoker, o as InvocationCtx, K as KeyboardChannel, p as OngoingInvoker, q as OngoingOverlay, r as PointerChannel, s as ResolveQuery, t as ResolveResult, u as RouteMatch, v as SelectionExtendKey, w as SelectionMode, x as ToolHit, y as ToolModifiers, z as ToolPresentation, E as ToolSlot, W as WheelChannel, F as createToolsDispatcher, J as drawLayers, L as routing, M as useSelection } from './index-DZBYMsHI.js';
-import { a as Stroke, F as FillStyle, D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, f as StyledRun, R as ResolvedTextStyle, g as TextStyle, h as TextVerticalAlign } from './DrawCommand-Dl0bXNfS.js';
-export { i as DEFAULT_TEXT_STYLE, G as GradStop, b as GroupDrawCommand, I as ImageDrawCommand, M as Mat3, j as Region, k as ResolvedRun, c as ShaderDrawCommand, d as ShaderUniform, l as StrokeAlign, T as TextDrawCommand, n as alignedStrokeRect, o as fontString, p as markdownToRuns, q as resolveRuns, s as resolveTextStyle, t as runsToMarkdown, u as runsToPlainText, v as toRuns, w as verticalAlignOffset } from './DrawCommand-Dl0bXNfS.js';
-import { B as Bounds, F as FitViewToBoundsOptions, V as ViewportDims } from './fitViewToBounds-evGsnR8Q.js';
-export { f as fitViewToBounds } from './fitViewToBounds-evGsnR8Q.js';
-import { N as NodeId, S as Scene, P as PoseComposition, a as Node$1, b as SerializedScene, R as RectPose, U as UseSceneOptions, c as SceneRegistry, d as RegisteredOp } from './types-Cpb4hii1.js';
-export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, I as IDENTITY_POSE_COMPOSITION, L as LayerRecord, f as LeafNode, g as PoseAdapter, h as SerializedNode, i as SystemLayerRecord, j as SystemLayerSpec, k as UserLayerRecord, l as asNodeId, m as composeRectPose, n as composeWorldPose, o as decomposeRectPose, r as rebaseLocalPose, t as translateRectPose, w as worldPoseLookup } from './types-Cpb4hii1.js';
-import { M as ModifierState, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, c as ResizeAnchor, L as LassoSelectBehavior, b as RotatedPose, e as RotateBehavior, f as AreaSelectBehavior, S as SnapStrategy, a as MoveBehavior, I as InsertBehavior } from './types-BjUi2vA-.js';
-export { A as ActionBehavior, g as AreaSelectMoveResult, h as AreaSelectOverlay, i as AreaSelectPose, j as AreaSelectProposed, k as BehaviorMoveResult, l as BehaviorResult, C as CloneBehavior, m as CloneLayer, n as ClonePose, G as GestureContext, o as GroupTransform, p as InsertMoveResult, q as InsertOverlay, r as InsertPoint, s as InsertProposed, t as LassoSelectMoveResult, u as LassoSelectOverlay, v as LassoSelectPose, w as LassoSelectProposed, x as PointSnapContext, d as PointSnapFrame, y as PointSnapResult, z as PointerState, D as ResizeMoveResult, E as ResizeOverlay, F as ResizeProposed, H as RotateMoveResult, J as RotateOverlay, K as RotateProposed } from './types-BjUi2vA-.js';
-import { CapabilityTag } from '@weasel-js/modes';
-import { IngestItem, InputEvent, GestureSpec } from '@weasel-js/gestures';
+import { a as UnitValue, b as UnitSystem, U as UseMoveOptions, O as OriginProjection } from './grid-CaSK9bHV.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-CaSK9bHV.js';
+import { R as RenderLayer, D as Dims, C as Condition, a as Rule, b as RuleCtx, V as VisibilityRules, c as ChromeCtx, d as ChromeId, A as Action, e as DepSchema, S as SliceDep, f as ActionsRegistry, T as Tool, g as AffordanceHit, h as Dispatcher, i as AnyTool, j as ToolCtx, k as ToolKeybinding, H as HotkeyTrigger, l as AffordanceBinding, m as ChromeState, n as SelectionApi, I as InsertExtras, G as GeometryProjection, o as ContentHandlerEntry, p as SvgIngestOptions, U as UseSelectionOptions, q as ActionsProp, r as Affordance, s as AffordanceRegion, t as CommonAffordanceScratch, B as BooleansAdapter } from './index-DOYRTfP0.js';
+export { u as ALWAYS, v as ActionDeps, w as ActionDisabledReason, x as ActionEnabledResult, y as ActionEntry, z as ActionsProvider, E as ActiveToolContextProvider, F as ActiveToolContextProviderIfRoot, J as ActiveToolContextProviderProps, K as ActiveToolContextValue, L as AreaSelectDep, M as BindingOpts, N as BindingScope, O as BooleanOp, P as BooleanOpResult, Q as BoundGesture, W as BuildRuleCtxArgs, X as ClipboardIngestCtx, Y as CustomPaintContext, Z as DepName, _ as DepRegistry, $ as DepRegistryProvider, a0 as DispatcherContext, a1 as DragSample, a2 as EditAnchorsDep, a3 as GestureBinding, a4 as ImmediateInvoker, a5 as IngestCtx, a6 as IngestionDep, a7 as InsertDep, a8 as InvocationCtx, a9 as Invoker, aa as LassoSelectDep, ab as LayoutDep, ac as MatchResult, ad as NEVER, ae as NodeAtPointDep, af as OngoingHandle, ag as OngoingInvoker, ah as OngoingOverlay, ai as Point2, aj as PointerContextProvider, ak as PointerContextValue, al as PointerWorldPos, am as ResizePolicy, an as ResolveAllOptions, ao as ResolveOnlyResult, ap as ResolvedCandidate, aq as ScopedBinding, ar as SelectionExtendKey, as as SelectionMode, at as Selector, au as SnapDep, av as SvgUnpacker, aw as TextEditDep, ax as ToolModifiers, ay as ToolPresentation, az as ToolSlot, aA as UiOngoingControl, aB as ViewApi, aC as applyBooleanOp, aD as buildRuleCtx, aE as createDispatcher, aF as describeRule, aG as drawLayers, aH as enterTextEditAction, aI as evaluate, aJ as evaluateEnabled, aK as registerContentHandler, aL as routing, aM as sliceAction, aN as specificity, aO as useAction, aP as useActionsRegistry, aQ as useActiveToolContext, aR as useDepRegistry, aS as useDepSource, aT as useOptionalActiveToolContext, aU as useOptionalDepRegistry, aV as usePointerContext, aW as useSelection } from './index-DOYRTfP0.js';
+import { a as Stroke, F as FillStyle, D as DrawCommand, S as ShaderProgramHandle, P as PathDrawCommand, f as StyledRun, R as ResolvedTextStyle, g as TextStyle, h as TextVerticalAlign } from './DrawCommand-CJtqqt8H.js';
+export { i as DEFAULT_TEXT_STYLE, G as GradStop, b as GroupDrawCommand, I as ImageDrawCommand, M as Mat3, j as Region, k as ResolvedRun, c as ShaderDrawCommand, d as ShaderUniform, l as StrokeAlign, T as TextDrawCommand, n as alignedStrokeRect, o as fontString, p as markdownToRuns, q as resolveRuns, s as resolveTextStyle, t as runsToMarkdown, u as runsToPlainText, v as toRuns, w as verticalAlignOffset } from './DrawCommand-CJtqqt8H.js';
+import { B as Bounds, P as PoseProjection, F as FitViewToBoundsOptions, V as ViewportDims } from './geometry-D9BDMiQi.js';
+export { R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, f as fitViewToBounds } from './geometry-D9BDMiQi.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-Cpb4hii1.js';
+export { A as AddLayerSpec, e as AddNodeSpec, C as ContainerNode, I as IDENTITY_POSE_COMPOSITION, L as LayerRecord, f as LeafNode, g as PoseAdapter, P as PoseComposition, h as SerializedNode, i as SystemLayerRecord, j as SystemLayerSpec, k as UserLayerRecord, l as asNodeId, m as composeRectPose, n as composeWorldPose, o as decomposeRectPose, r as rebaseLocalPose, t as translateRectPose, w as worldPoseLookup } from './types-Cpb4hii1.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-Dcaa0tPq.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-Dcaa0tPq.js';
+import { U as UseResizeOptions } from './pointSnapToGrid-C3EruUwt.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-C3EruUwt.js';
+import { 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 * as react_jsx_runtime from 'react/jsx-runtime';
-import { P as Path, a as PolygonPath, b as PathFillRule, R as RectPath } from './types-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 './types-B6MMiodD.js';
-import { Op, History, CreateHistoryOptions } from '@weasel-js/history';
-export * from '@weasel-js/history';
-export { Op } from '@weasel-js/history';
-import { L as LayoutStrategy, I as InsertAdapter, M as MoveAdapter, A as AreaSelectAdapter, R as RotateAdapter, a as LassoHitMode, b as LassoSelectAdapter, c as ResizeAdapter, d as SceneAdapter, e as LayerEnumerableAdapter, C as ClipboardSnapshot, O as OrderedAdapter, f as LayoutSnap } from './types-B_-khFM0.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-B_-khFM0.js';
 export { g as ContainerBounds, D as DropTarget, h as LayoutChild, i as LayoutContainer, j as LayoutDragged, S as SnapTarget } from './types-B_-khFM0.js';
-import { P as PoseProjection, U as UseResizeOptions } from './pointSnapToGrid-D7s7QmOF.js';
-export { C as CORNER_ANCHORS, a as CornerAnchor, g as CornerEdge, b as CornerHandle, R as RECT_POSE_DESCRIPTOR, c as ROTATED_POSE_DESCRIPTOR, d as cornerPoint, e as cornerResizeHandles, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-D7s7QmOF.js';
-import { Mat3 } from '@weasel-js/geom';
 import { D as DebugSink, a as DebugConfig, b as DebugSnapshot, c as DebugTheme } from './types-BJ8_cyT7.js';
 export { d as DebugFeature, H as HandleKind, e as HitShape, R as RecordedBounds, f as RecordedHandle, g as RecordedHitbox, h as RecordedLayer, i as RecordedOrigin, j as RecordedSnap } from './types-BJ8_cyT7.js';
-import { U as UseInsertOptions } from './options-BPPBWMa7.js';
+import { a as PolygonPath, P as Path, b as PathFillRule, R as RectPath } from './types-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 './types-B6MMiodD.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Op, CreateHistoryOptions, History } from '@weasel-js/history';
+export * from '@weasel-js/history';
+export { Op } from '@weasel-js/history';
 import { T as TextureHandle } from './registerTexture-BzHTLhD9.js';
+import { Mat3 } from '@weasel-js/geom';
 import { G as Guide } from './types-D2tTKEU0.js';
+export { U as UseInsertOptions } from './options-DMWeTELe.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 { F as FontVariant, I as ImageMinification, i as isCanvasFont, r as registerCanvasFont, a as registerFont, s as subscribeGlyphReady, u as unregisterCanvasFont, v as viewToMat3 } from './registerFont-CP-wCsrz.js';
+export { I as ImageMinification, v as viewToMat3 } from './viewToMat3-D4lrBigW.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 '@weasel-js/modes';
+
+/**
+ * The kit version a build was compiled from, so an app can report what it is
+ * running. Substituted at build time — by `tsup.config.ts` for the published
+ * package, and by `scripts/vite-build-info.ts` for anything in this repo that
+ * bundles core's source through the workspace aliases.
+ *
+ * Apps pair this with their own compile timestamp; the kit deliberately does
+ * not carry one, since a published package's build date says nothing about
+ * when the app embedding it was built.
+ */
+/**
+ * Semver of `@weasel-js/core` as of the build.
+ *
+ * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler
+ * that hasn't been given the define — honest about not knowing rather than
+ * throwing, since nothing about version reporting should be able to break a
+ * consumer's build.
+ */
+declare const VERSION: string;
 
 /** Round `value` to the nearest multiple of `cellSize`. Returns 0 when the result would be -0. */
 declare function roundToCell(value: number, cellSize: number): number;
@@ -836,182 +857,6 @@ declare function isEditableTarget(target: EventTarget | null): boolean;
  */
 declare function matchesKeyBinding(e: KeyboardEvent, b: KeyBinding): boolean;
 
-/**
- * Live state read by rule evaluation. Built once per frame on the consuming
- * surface — chrome-caps, the affordance pipeline, the dispatcher's
- * eligibility filter — and discarded.
- *
- * Adding a new field is additive: existing rules don't change, new
- * selector atoms can read it.
- */
-interface RuleCtx {
-    readonly focused: boolean;
-    readonly selection: readonly NodeId[];
-    readonly multiActive: boolean;
-    readonly modifiers: ModifierState;
-    readonly action: {
-        readonly kind: string | null;
-        readonly id: string | null;
-    };
-    readonly hover: NodeId | null;
-    readonly view: View;
-    /** Active mode id. `'normal'` when no non-default mode is engaged. */
-    readonly mode: string;
-    /** Capability tags allowed by the active mode (the union of
-     *  `ModeDefinition.allows` plus implicit tags). The `capability:`
-     *  selector reads this to determine whether a tag is permitted. */
-    readonly allowedCapabilities: ReadonlySet<CapabilityTag>;
-    /** Whether the current selection may be resized. `<SceneCanvas>` folds
-     *  `selectTool.resize.resizable` over the selection (true only when every
-     *  selected node is resizable). Read by the `resizable:` selector to gate
-     *  `selection.resize-handles`. Absent (legacy ctx builders) is treated as
-     *  resizable — back-compat: handles show unless a consumer opts a node out. */
-    readonly selectionResizable?: boolean;
-}
-interface BuildRuleCtxArgs {
-    focused: boolean;
-    selection: readonly NodeId[];
-    multiActive: boolean;
-    modifiers: ModifierState;
-    action: {
-        kind: string | null;
-        id: string | null;
-    };
-    hover: NodeId | null;
-    view: View;
-    mode: string;
-    allowedCapabilities: ReadonlySet<CapabilityTag>;
-    /** Optional — omitted means "resizable" (handles show). See {@link RuleCtx}. */
-    selectionResizable?: boolean;
-}
-declare function buildRuleCtx(args: BuildRuleCtxArgs): RuleCtx;
-
-/**
- * A selector is a conjunction of key/value tests. Multiple keys at the same
- * level AND together. Each key maps to a selector primitive in the evaluator.
- */
-interface Selector {
-    selection?: {
-        is?: number;
-        atLeast?: number;
-        empty?: boolean;
-    };
-    mode?: string | {
-        not: string;
-    } | {
-        in: readonly string[];
-    };
-    capability?: CapabilityTag | readonly CapabilityTag[] | {
-        in: readonly CapabilityTag[];
-    } | {
-        not: CapabilityTag;
-    };
-    gesturing?: boolean;
-    actionIs?: string;
-    modifierHeld?: keyof ModifierState;
-    focused?: boolean;
-    hovering?: boolean;
-    hoveringSelected?: boolean;
-    zoomAtLeast?: number;
-    /** Matches `ctx.selectionResizable`. Absent flag is treated as `true`
-     *  (resizable), so `{ resizable: true }` passes for legacy ctx builders
-     *  that don't compute it. */
-    resizable?: boolean;
-}
-/**
- * Composable visibility/eligibility rule. Trees of `all`/`any`/`not` nodes
- * over `Selector` leaves. `when` is the escape hatch — its closure is
- * opaque to introspection and should be avoided when a declarative form
- * exists. Empty `all` is true; empty `any` is false.
- */
-type Rule = Selector | {
-    all: readonly Rule[];
-} | {
-    any: readonly Rule[];
-} | {
-    not: Rule;
-} | {
-    when: (ctx: RuleCtx) => boolean;
-};
-/** Constant rules. Kept here so they have a single source. */
-declare const ALWAYS: Rule;
-declare const NEVER: Rule;
-declare function evaluate(rule: Rule, ctx: RuleCtx): boolean;
-
-/**
- * Live state read by chrome-visibility {@link Condition}s. Backward-compat
- * alias for the legacy ChromeCtx shape — kept for consumers that still
- * import `ChromeCtx`. Subset of `RuleCtx`: legacy ChromeCtx didn't carry
- * mode/capability info. The resolver builds a `RuleCtx` for evaluation;
- * surfaces that still operate in `ChromeCtx` shape supply defaults
- * (mode='normal', empty allowedCapabilities) at the construction site.
- */
-interface ChromeCtx {
-    readonly focused: boolean;
-    readonly selection: readonly NodeId[];
-    readonly multiActive: boolean;
-    readonly modifiers: ModifierState;
-    readonly action: {
-        readonly kind: string | null;
-        readonly id: string | null;
-    };
-    readonly hover: NodeId | null;
-    readonly view: View;
-}
-/**
- * Composable visibility predicate with fluent surface. Carries its underlying
- * `Rule` tree at `.rule` so the resolver can introspect / share trees with
- * the affordance pipeline and the dispatcher's eligibility filter.
- *
- * Callable form `cond(ctx)` evaluates the tree against ctx. The fluent
- * methods return new Conditions wrapping new trees.
- *
- * **Chain semantics: strict left-to-right, no precedence.**
- * `a.and(b).or(c)` is `(a && b) || c`; `a.or(b).and(c)` is
- * `(a || b) && c`. Mix `.and` and `.or` only when you mean
- * left-to-right evaluation. For grouped disjunction, name the
- * subexpression or use the top-level `or(...)`.
- */
-interface Condition {
-    (ctx: RuleCtx): boolean;
-    readonly rule: Rule;
-    /** `this && other` */
-    and(other: Condition | Rule): Condition;
-    /** `this || other` */
-    or(other: Condition | Rule): Condition;
-    /** `this && !other` */
-    andNot(other: Condition | Rule): Condition;
-    /** `this || !other` */
-    orNot(other: Condition | Rule): Condition;
-}
-/**
- * Stable identifier for one user-visible chrome element. The same id
- * gates both paint and hit-test — there is no separate
- * `affordance.X` / `selection.X` split — so toggling a rule cannot
- * leave a visually-present but un-hittable handle (or vice versa).
- *
- * Naming convention by lifecycle:
- *
- *   - `selection.*` — chrome reflecting committed selection state
- *     (persists between actions).
- *   - `action.*` — chrome that only exists during an in-flight
- *     action (vanishes on commit / cancel).
- *   - `snap.*` — snapping system chrome (guides, target highlights).
- *   - `grid`, `debug.*` — environment chrome.
- *
- * The intersection `(string & {})` keeps the union open so consumers
- * can register their own ids; the kit's built-ins are listed
- * explicitly for autocomplete.
- */
-type ChromeId = 'selection.outline' | 'selection.resize-handles' | 'selection.rotation-handle' | 'action.marquee' | 'action.lasso' | 'action.move-ghosts' | 'action.insert-preview' | 'action.commands' | 'snap.guides' | 'snap.targets' | 'grid' | (string & {});
-/**
- * Consumer override map. Merged on top of the kit's
- * `defaultVisibilityRules`; absent keys fall through to defaults,
- * absent ids fall through to `always`. Entries may be either fluent
- * `Condition` instances OR raw `Rule` trees — the resolver normalizes.
- */
-type VisibilityRules = Partial<Record<ChromeId, Condition | Rule>>;
-
 /**
  * Promote a Rule tree to a fluent Condition. The function form evaluates
  * the tree against a RuleCtx; combinator methods produce new Conditions
@@ -1079,1375 +924,111 @@ declare const modeIs: (m: string) => Condition;
 /** Active mode is one of `modes`. */
 declare const modeIn: (modes: readonly string[]) => Condition;
 /** Active mode is NOT `m`. */
-declare const modeNot: (m: string) => Condition;
-/** Active mode's `allows` includes capability `cap`. */
-declare const capabilityIs: (cap: string) => Condition;
-/** Active mode's `allows` includes ANY of `caps` (OR). */
-declare const capabilityIn: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` includes ALL of `caps` (AND). */
-declare const capabilityAll: (caps: readonly string[]) => Condition;
-/** Active mode's `allows` does NOT include capability `cap`. */
-declare const capabilityNot: (cap: string) => Condition;
-
-/**
- * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
- * at resolve time; consumer entries take precedence per id.
- *
- * Written as literal Rule trees rather than fluent chains so the inputs
- * each rule depends on are immediately visible. The fluent atoms compile
- * to the same trees; either form is valid in a VisibilityRules entry.
- *
- * Mode gating: selection chrome is suppressed in `path-edit` because the
- * path-editing overlay takes over visually. Path-edit-specific chrome
- * ids (`path-edit.*`) are positively gated to that mode. This replaces
- * the old `suppressedIds` set, which only the selection-outline path
- * honored.
- */
-declare const defaultVisibilityRules: VisibilityRules;
-
-/**
- * Build the per-frame visibility check. Merges consumer rules on top
- * of the kit defaults, then closes over `ctx` so each chrome-id
- * lookup runs its rule against the current state.
- *
- * `VisibilityRules` entries may be either fluent `Condition` values
- * (callable) or raw `Rule` trees — we normalize at lookup time.
- *
- * Predicates are O(1) and run once per chrome id per frame; no
- * memoization in v1 — profile before adding any.
- *
- * `ChromeCtx` is the legacy shape; surfaces still on it supply
- * `mode='normal'` and an empty `allowedCapabilities` to satisfy
- * `RuleCtx` when calling. We do the same here so callers in
- * legacy shape keep working transparently.
- */
-declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
-
-/**
- * Pure assembler for {@link ChromeCtx}.
- *
- * Called once per frame on the rendering side from whichever surface
- * needs to evaluate visibility rules — `composeAffordanceLayer`,
- * `createSelectionOverlayLayer`, the dispatcher overlay layer, etc.
- *
- * Sources are passed as plain getters / values rather than the live
- * objects they come from. This keeps `chrome-caps` from depending on
- * React, the dispatcher's concrete type, or `ChromeState`'s bounds
- * machinery — the same builder works from a test harness, a Storybook
- * fixture, or `<SceneCanvas>`.
- */
-
-interface BuildChromeCtxArgs {
-    focused: boolean;
-    selection: readonly NodeId[];
-    multiActive: boolean;
-    modifiers: ModifierState;
-    action: {
-        kind: string | null;
-        id: string | null;
-    };
-    hover: NodeId | null;
-    view: View;
-}
-declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
-
-/**
- * useHoverTracking — last-hovered NodeId for chrome-caps rules.
- *
- * Attaches a `pointermove` listener to the supplied canvas; on each
- * move, converts client coords → world coords and runs the supplied
- * `getNodeAtPoint`, caching the resulting id on a ref. Cleared on
- * `pointerleave` (pointer left the canvas → nothing is hovered).
- *
- * Returns a stable getter — call once per frame from `buildChromeCtx`.
- *
- * No re-render: the ref updates silently, and the next render that
- * reads it picks up the fresh value. Chrome-caps rules are evaluated
- * during paint, so the hover state is always read fresh.
- */
-
-interface UseHoverTrackingArgs {
-    canvasRef: RefObject<HTMLCanvasElement | null>;
-    /** Client → world conversion. Same shape as the dispatcher's. */
-    clientToWorld: (clientX: number, clientY: number) => {
-        x: number;
-        y: number;
-    };
-    /** Topmost-id resolver. Returns null when the world point hits nothing. */
-    getNodeAtPoint: (worldX: number, worldY: number) => {
-        id: NodeId;
-    } | null;
-    enabled?: boolean;
-}
-declare function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null;
-
-/** Boolean op identifiers — five Pathfinder primaries plus Crop. */
-type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop';
-/**
- * z-position descriptor for a path node. `parentId` is the direct parent
- * (or `null` for a top-level node); `index` is the position within that
- * parent's child order. Used by the optional `getZOrder` hook below to
- * reposition the result of a boolean op at the topmost source's slot.
- */
-/** @internal */
-interface BooleanZOrder {
-    parentId: string | null;
-    index: number;
-}
-/** Adapter the hook and the pure core both consume. */
-interface BooleansAdapter {
-    getSelection(): NodeId[];
-    getWorldPath(id: NodeId): Path | undefined;
-    compareZ(a: NodeId, b: NodeId): number;
-    /**
-     * Mint a new node from a boolean-op result `Path`. `producedBy` names the
-     * op that synthesized it — adapters that store provenance (e.g. for a
-     * layer-panel icon) record it; others ignore the arg.
-     */
-    createPathNode(path: Path, producedBy: BooleanOp): {
-        id: string;
-    };
-    /**
-     * Optional: return the full object for an id, used by the delete ops so
-     * their `invert` (an insert) can restore the complete object on undo.
-     * If omitted, a `{ id }` stub is captured — undo will reinstate the id
-     * but consumers reading other fields (path, fill, etc.) will see them as
-     * undefined. Mirrors `DeleteAdapter.getNode`; should be provided whenever
-     * undo over boolean ops is expected to be lossless.
-     */
-    getNode?(id: NodeId): {
-        id: string;
-    } | undefined | null;
-    /**
-     * Optional: return the parent + child-index of `id` so the result of a
-     * boolean op can be placed in the topmost source's z-slot. Adapters that
-     * also expose `getChildren`/`setChildOrder` (the `ReorderAdapter`
-     * contract) will have the kit emit a `createMoveToIndexOp` after the
-     * inserts. Adapters that omit this method get v1 behavior — the result
-     * lands wherever the adapter's plain `insertNode` defaults to.
-     */
-    getZOrder?(id: NodeId): BooleanZOrder | undefined;
-    applyOps?(ops: Op[], label?: string): void;
-    setSelection?(ids: NodeId[]): void;
-    insertNode?(node: {
-        id: string;
-    }): void;
-    removeNode?(id: string): void;
-}
-/** Outcome reported back to callers (lets the hook surface no-op signals). */
-type BooleanOpResult = {
-    kind: 'applied';
-    resultIds: string[];
-} | {
-    kind: 'noop';
-    reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result';
-};
-declare function applyBooleanOp(adapter: BooleansAdapter, op: BooleanOp): BooleanOpResult;
-
-/** Context handed to every content handler for one ingest event. */
-interface IngestCtx {
-    /** World-space arrival point (drop / pointed imperative ingest); `null`
-     *  for paste and point-less calls — handlers pick their own policy
-     *  (the kit image handler centers on the viewport). */
-    point: {
-        x: number;
-        y: number;
-    } | null;
-    /** Visible canvas area in world coordinates. */
-    viewportWorldRect(): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    /** The kit insert dep — id/layer/undoable-op supplied; the canonical way
-     *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */
-    insert: InsertDep;
-    /** Raw op commit for handlers that build their own ops. */
-    applyOps(ops: Op[], label?: string): void;
-    scene: Scene<unknown, string, unknown>;
-    selection: SelectionApi;
-    /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).
-     *  When absent, the kit image handler embeds as a `data:` URI. */
-    resolveSrc?: (file: File) => Promise<string>;
-    /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.
-     *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files
-     *  into scene nodes. */
-    svg?: SvgIngestOptions;
-    /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied
-     *  an adapter with `commitPaste`. `reviver` comes from
-     *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON
-     *  handler declines inert (dwarn, nothing ingested) — its matched items
-     *  were already consumed at match time, so they do NOT fall through;
-     *  only match-level misses flow on to other handlers. */
-    clipboard?: ClipboardIngestCtx;
-    /** Set to `true` by the kit weasel-JSON handler when it successfully
-     *  pastes a payload in this event. The `ctx` object is shared across all
-     *  handlers in one `runIngest` call, and higher-priority handlers' `handle`
-     *  bodies run (synchronously) before lower ones — so `kit:svg`'s
-     *  `text/plain` SVG fallback reads this to decline the SVG flavor of a copy
-     *  whose canonical weasel-JSON flavor already ingested (avoids a
-     *  double-paste when both flavors ride one clipboard event). */
-    consumedWeaselPayload?: boolean;
-    /** Full action-deps bag, for consumer handlers that need more. */
-    deps: ActionDeps;
-}
-interface ContentHandlerEntry {
-    /** Stable identifier — used for unregistration and debugging
-     *  (`'kit:image'`, `'app:csv'`). */
-    id: string;
-    /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. */
-    match: string | string[] | ((item: IngestItem) => boolean);
-    /** Higher runs earlier. Kit defaults register at -100 so any consumer
-     *  handler (default 0) beats them. */
-    priority?: number;
-    handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;
-}
-/** Register a content handler. Returns a disposer that removes it. */
-declare function registerContentHandler(entry: ContentHandlerEntry): () => void;
-
-/**
- * @experimental
- * PointerContext — a tiny ambient context that publishes the world-space
- * position of the canvas pointer, refreshed on every `pointermove` over
- * the canvas. Cleared (set to `null`) on `pointerleave`.
- *
- * Why ref-based and not state-based: cursor moves fire dozens of times per
- * second; routing those through React state would re-render every consumer
- * in the tree. The context exposes a stable `pointerRef` whose `.current`
- * is mutated directly by the publisher, plus a thunk `getDropPoint()` that
- * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk
- * inside their callbacks — no subscription, no re-render.
- *
- * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when
- * the caller didn't pass an explicit `getDropPoint` option. Other future
- * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse
- * the same context.
- */
-
-/** @experimental World-space pointer position, or `null` when the pointer
- *  isn't over the publishing canvas. */
-type PointerWorldPos = {
-    worldX: number;
-    worldY: number;
-} | null;
-/** @experimental */
-interface PointerContextValue {
-    /** Live ref — mutate to publish, read for the latest snapshot. The
-     *  identity is stable for the lifetime of the provider. */
-    readonly pointerRef: MutableRefObject<PointerWorldPos>;
-    /** Convenience thunk equivalent to `() => pointerRef.current`. Stable
-     *  identity for the lifetime of the provider; safe to pass to hooks. */
-    readonly getDropPoint: () => PointerWorldPos;
-}
-/**
- * @experimental
- * Wrap the part of the React tree that should share a pointer-position
- * context. Usually placed at the demo / app root, alongside
- * `<ActionsProvider>` and `<SelectionContextProvider>`.
- *
- * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts
- * an internal provider when no parent provider is in scope, so child hooks
- * (`useClipboard` without an explicit `getDropPoint`) read the canvas's
- * tracked pointer for free.
- */
-declare function PointerContextProvider({ children }: {
-    children: ReactNode;
-}): ReactNode;
-/** @experimental Read the surrounding pointer-context value, or `null` when
- *  no provider is in scope. */
-declare function usePointerContext(): PointerContextValue | null;
-
-interface ActiveToolContextValue {
-    active: string;
-    hotkeyStack: string[];
-    setActive(id: string): void;
-    pushHotkey(id: string): void;
-    popHotkey(): void;
-}
-interface ActiveToolContextProviderProps {
-    children: ReactNode;
-    initialActive?: string;
-}
-declare function ActiveToolContextProvider({ children, initialActive, }: ActiveToolContextProviderProps): react_jsx_runtime.JSX.Element;
-declare function useActiveToolContext(): ActiveToolContextValue;
-/**
- * Like `useActiveToolContext`, but returns `null` when no
- * `<ActiveToolContextProvider>` is in scope instead of throwing. Used by
- * `useStandardActions` to preserve its silent-no-op contract when no provider
- * is present.
- */
-declare function useOptionalActiveToolContext(): ActiveToolContextValue | null;
-/**
- * Conditional `<ActiveToolContextProvider>` wrapper. Mounts a provider only
- * when no parent provider is in scope — otherwise renders children unwrapped
- * so callers (e.g. `<WeaselProvider>`, `<SceneCanvas>`) defer to the host's
- * existing scope. Mirrors `ActionsProviderIfRoot` / `DepRegistryProviderIfRoot`.
- */
-declare function ActiveToolContextProviderIfRoot({ children, }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-
-/**
- * `enterTextEditAction` — immediate Action descriptor for entering in-place
- * text editing on a selected text node.
- *
- * ## Status: REAL
- *
- * Fires via `useTextTool.bindings` when the user clicks on a
- * selected text node. Calls `deps.textEdit.startEdit(id)` to activate the
- * contenteditable overlay managed by `useTextEdit` / `useSceneTextEdit`.
- *
- * ## No defaultBinding / defaultBinding
- *
- * This action has no ambient key or gesture binding — it fires ONLY via
- * `useTextTool`'s `Tool.bindings` entry:
- *
- * ```ts
- * bindings: [
- *   { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' },
- * ]
- * ```
- *
- * Keeping it binding-free avoids ambient double-fire and scopes the action to
- * the text tool context where `classifyTarget` is already wired.
- *
- * ## Self-guard: only act on text nodes
- *
- * The `classifyTarget` thunk yields `'selected-body'` for any selected node
- * kind — there's no per-kind filter yet (that's a Phase 14e follow-up). To
- * avoid entering text-edit mode when the text tool happens to have a non-text
- * node selected, the action self-guards via an optional `isTextNode` predicate
- * on `TextEditDep`:
- *
- * - When `isTextNode` is absent: action fires unconditionally (the binding
- *   spec is the real gate — consumers should only bind this action from the
- *   text tool).
- * - When `isTextNode(id)` returns `false`: action is a no-op for that node.
- *
- * ### Future: per-kind target classification (Phase 14e)
- *
- * Once `classifyTarget` surfaces node-kind info on body hits, the binding spec
- * can use a `{ kindOf: hit => hit?.kind === 'text' }` predicate to pre-filter
- * at dispatch time, making the `isTextNode` guard redundant. The action can
- * then drop `isTextNode` from `TextEditDep`.
- *
- * ## Migration plan for useTextTool
- *
- * When wiring `useTextTool` to `Tool.bindings`:
- *
- * 1. Add to `useTextTool`'s `bindings`:
- *    ```ts
- *    { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' }
- *    ```
- * 2. Register a `textEdit` dep sourced from the `useTextEdit` / `useSceneTextEdit`
- *    return value, plus an `isTextNode` predicate that checks `data.kind === 'text'`
- *    (or however the consumer identifies text nodes).
- * 3. The existing `hitExisting` gate in `useTextTool`'s click route becomes
- *    redundant — remove it in Phase 14e dead-code cleanup.
- */
-
-/**
- * Dep for `enterTextEditAction`.
- *
- * Wrap the return value of `useTextEdit` / `useSceneTextEdit` to source this
- * dep. The `isTextNode` predicate is optional — when absent the action fires
- * unconditionally (the binding spec acts as the gate).
- *
- * @example
- * ```ts
- * const textEdit = useSceneTextEdit({ scene, container });
- * useDepSource('textEdit', () => ({
- *   startEdit: textEdit.startEdit,
- *   isTextNode: (id) => scene.get(id as NodeId)?.data?.kind === 'text',
- * }));
- * ```
- */
-interface TextEditDep {
-    /**
-     * Begin editing the node with `id`. Activates the contenteditable overlay
-     * managed by `useTextEdit` / `useSceneTextEdit`.
-     */
-    startEdit(id: string, opts?: {
-        caret?: number | 'all';
-    }): void;
-    /**
-     * Optional predicate: returns `true` when the node with `id` is a text node.
-     * When absent the action fires on any selected node (binding spec is the gate).
-     * When present and returning `false`, the invocation is a no-op.
-     */
-    isTextNode?(id: string): boolean;
-}
-/**
- * @experimental
- * Static descriptor for the `enterTextEdit` Action.
- *
- * Requires dep-schema entries: `textEdit`, `selection`.
- *
- * No `defaultBinding` / `defaultBinding` — fires only via `Tool.bindings`.
- * Self-guards via `TextEditDep.isTextNode` when provided.
- */
-declare const enterTextEditAction: Action & {
-    requires: string[];
-};
-
-/**
- * Consumer-supplied commit for the Slice action. `commit` receives the finite
- * slice segment (world coords); the consumer scans the scene, splits crossed
- * paths via `splitPathByLine`, and applies the result as one undoable batch.
- */
-interface SliceDep {
-    commit(a: Point2, b: Point2): void;
-}
-/**
- * @experimental
- * Static descriptor for the `slice` Action.
- *
- * Ongoing drag invoker: tracks a slice line from drag start to current
- * pointer, renders a live line overlay while the gesture is in flight,
- * and on commit calls `SliceDep.commit(a, b)`. No-ops gracefully when
- * the `slice` dep is absent.
- */
-declare const sliceAction: Action & {
-    requires: string[];
-};
-
-/** Optional consumer seam: given a node and the affine `m` that a pose-transform
- *  action applied to the node's POSE, return updated `data` with the node's
- *  data-held geometry transformed by `m`, or `null` if this node has no
- *  data-held geometry (the kit leaves `data` alone). */
-interface GeometryProjection {
-    transform(node: {
-        id?: string;
-        data: unknown;
-        pose: unknown;
-    }, m: Mat3): unknown | null;
-}
-
-/** Minimal view API the action layer consumes. May be refined later. */
-interface ViewApi {
-    get(): View;
-    set(v: View): void;
-    /** Optional recenter callback. When wired, `viewportZoomAction`'s
-     *  `reset` branch (Cmd-0) calls this instead of resetting to identity —
-     *  letting consumers re-fit the page (or other reference bounds) into
-     *  the workspace. Receives no args; the consumer reads its own bounds
-     *  + host dims and dispatches `setView(...)`. */
-    recenter?(): void;
-    /** Optional canvas-local host dimensions (CSS px). When wired,
-     *  `viewportZoomAction`'s keyboard branches (Cmd+= / Cmd+-) anchor at the
-     *  host center instead of the top-left origin. Null when the host isn't
-     *  measurable (unmounted). */
-    hostSize?(): {
-        width: number;
-        height: number;
-    } | null;
-}
-/**
- * Adapter dep for `areaSelectAction`.
- *
- * Provided by `<SceneCanvas>` / `<StandardActionsRegistrar>` via AABB
- * overlap over scene nodes. Consumers with custom hit-testing override this
- * dep entry in their own registrar.
- */
-/**
- * Topmost-node-at-world-point dep, consumed by `moveAction` for
- * reparent-on-drop and available to any action that needs a single-best
- * pick. Mirrors the same hit-test plumbing `<SceneCanvas>` feeds to the
- * tool dispatcher; consumers with custom hit-testing override here.
- *
- * `exclude` is iterated once per call and treated as a set membership
- * test — the dep walks hits front-to-back and returns the first id not
- * in the exclude set. Pass moving-node roots + their descendants when
- * the caller wants to ignore the nodes it's manipulating.
- */
-type NodeAtPointDep = (point: {
-    x: number;
-    y: number;
-}, exclude?: Iterable<NodeId>) => NodeId | null;
-interface AreaSelectDep {
-    /** Return ids of all scene nodes whose AABB overlaps `bounds`. */
-    hitTestArea(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): NodeId[];
-    /** Return the current selection id list. */
-    getSelection(): NodeId[];
-    /** Replace the current selection. */
-    setSelection(ids: NodeId[]): void;
-}
-/**
- * Adapter dep for `editAnchorsAction`.
- *
- * Provides narrow read/write access to the editable polygon for a single
- * node. Consumers register this dep so anchor-edit actions can read/write
- * the polygon WITHOUT knowing whether it lives directly on the node's
- * pose (`pose.kind === 'polygon'`) or on `node.data.path` (the kit's
- * built-in pen-tool default, also WeaselDraw's shape).
- *
- * Note on live previews: in-flight edit state is surfaced through the
- * dispatcher's standard `OngoingHandle.previewIds/previewPose/previewData`
- * triple (not this dep), so chrome and preview-ghost stay in lock-step
- * via one source of truth.
- */
-interface EditAnchorsDep {
-    /** Id of the node currently being edited. Empty string means no node is
-     *  currently in edit mode — the chrome and gesture both opt out. */
-    editingId: string;
-    /** Enter/exit edit mode for a specific node. Pass `null` (or an empty
-     *  string) to exit. `enterPathEditAction` and `exitPathEditAction` call
-     *  this; consumers can call it directly to drive edit mode programmatically. */
-    setEditingId(id: string | null): void;
-    /** Returns the COMMITTED editable polygon in world coordinates, or
-     *  null if this node has no editable polygon. Does NOT consult in-
-     *  flight previews — callers that need live state read the dispatcher's
-     *  in-flight handles. */
-    getEditablePath(id: string): unknown;
-    /** Returns where the polygon is stored — `'pose'` when `node.pose`
-     *  IS the polygon, `'data'` when it lives on `node.data.path` with a
-     *  rect pose, or `null` when the node has no editable polygon. The
-     *  action uses this to know which preview-ghost axis to populate
-     *  (`previewPose` only / `previewData` + `previewPose` for data.path). */
-    getStorageKind(id: string): 'pose' | 'data' | null;
-    /** Returns the node's raw `pose` and `data` so storage-aware actions
-     *  can capture origin state at gesture-start and synthesize a matching
-     *  `previewPose` / `previewData` during `onMove`. Used by
-     *  `editAnchorsAction` for the data.path branch (rect pose + data
-     *  carrying extra fields like fill / stroke that must be preserved
-     *  through the preview). Returns null when the node is gone. */
-    getNodeShape(id: string): {
-        pose: unknown;
-        data: unknown;
-    } | null;
-    /** Commit `worldPath` as the new value for `id`. Implementation routes
-     *  to setPose (when pose IS the polygon) or batched setPose+update
-     *  (when the polygon lives on data.path). Records one history entry
-     *  labelled `label`. */
-    applyEdit(id: string, worldPath: unknown, label: string): void;
-}
-/**
- * Adapter dep for `lassoSelectAction`.
- *
- * Provides polygon-lasso hit-testing + selection read/write.
- * Consumers that don't implement `hitTestLasso` can omit it; the action
- * falls back to a bounding-box AABB test via `hitTestArea`.
- */
-interface LassoSelectDep {
-    /**
-     * Hit-test against a closed polygon (vertex order CW or CCW; last→first
-     * closing edge is implicit). Returns matching node ids.
-     * Optional — when absent, `lassoSelectAction` falls back to AABB via
-     * `hitTestArea`.
-     */
-    hitTestLasso?(polygon: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>, mode: 'centers' | 'intersect' | 'enclosed'): string[];
-    /** Return ids of nodes whose AABB overlaps the given rect (fallback). */
-    hitTestArea(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }): string[];
-    /** Return the current selection id list. */
-    getSelection(): string[];
-    /** Replace the current selection. */
-    setSelection(ids: string[]): void;
-}
-/**
- * Options for the kit `image/svg+xml` content handler, threaded from
- * SceneCanvas's `ingestion={{ svg }}` prop.
- */
-interface SvgIngestOptions {
-    /** Parse dropped/pasted/picked SVG files into native scene nodes (path /
-     *  text leaves under containers mirroring the source `<g>` structure)
-     *  instead of the default single embedded-image node.
-     *
-     *  Pass `unpackSvgFiles` from `@weasel-js/svg`:
-     *
-     *  ```ts
-     *  import { unpackSvgFiles } from '@weasel-js/svg';
-     *  <SceneCanvas ingestion={{ svg: { unpack: unpackSvgFiles } }} />
-     *  ```
-     *
-     *  It is injected rather than flagged on with `true` because the SVG parser
-     *  lives in `@weasel-js/svg`, which depends on this package — core importing
-     *  it back would make the two mutually dependent and unpublishable
-     *  separately. Passing the function keeps the parser out of core's bundle
-     *  for consumers who never unpack. */
-    unpack?: SvgUnpacker;
-}
-/** Parses SVG files and inserts the resulting nodes into `ctx.scene`, as one
- *  `applyOps` batch per file. Implemented by `unpackSvgFiles` in
- *  `@weasel-js/svg`; see {@link SvgIngestOptions.unpack}. */
-type SvgUnpacker = (files: File[], ctx: IngestCtx) => Promise<void>;
-/**
- * Clipboard-paste seam consumed by the kit weasel-JSON content handler
- * (`IngestCtx.clipboard`). Built by `<SceneCanvas>` from its own synthesized
- * adapter + the `ingestion.clipboard` prop; absent when the consumer set
- * `ingestion.clipboard.enabled === false` or the adapter lacks `commitPaste`.
- * Absence makes the handler decline inert (dwarn, nothing ingested) — its
- * matched items were already consumed at match time and do not fall through
- * to other handlers.
- */
-interface ClipboardIngestCtx {
-    /** The hosting canvas's adapter — `commitPaste` materializes the pasted
-     *  nodes (fresh ids, offset applied); insertion still goes through ops. */
-    adapter: InsertAdapter<{
-        id: string;
-    }>;
-    /** JSON reviver for the weasel wire payload (typed arrays etc.) — from
-     *  `SceneCanvasProps.ingestion.clipboard.reviver`. */
-    reviver?: (key: string, value: unknown) => unknown;
-}
-/**
- * Dep for the `ingest` action (external-content ingestion).
- * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>` via
- * `useIngestionDepSource` — canvas rect + current view.
- */
-interface IngestionDep {
-    /** Visible canvas area in world coordinates. */
-    viewportWorldRect(): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    /** Consumer file→src resolver (from SceneCanvas's `ingestion` prop).
-     *  Live accessor — read it at use time. Destructuring (or copying the
-     *  property early) snapshots the current value and won't track later
-     *  prop changes across an `await`. */
-    resolveSrc?: (file: File) => Promise<string>;
-    /** Kit SVG-handler options (from SceneCanvas's `ingestion` prop).
-     *  Live accessor, same caveat as `resolveSrc`. */
-    svg?: SvgIngestOptions;
-    /** Clipboard-paste seam for the kit weasel-JSON handler.
-     *  Live accessor, same caveat as `resolveSrc`. */
-    clipboard?: ClipboardIngestCtx;
-}
-/**
- * Per-kind extra geometry passed to `InsertDep.commit`.
- *
- * Built-in tools populate a typed variant so the kit's default factory can
- * render the true tool params (line endpoints, polygon side count, star
- * geometry, pencil sample list). Consumer-defined tools may pass any
- * `{ kind: string; ... }` payload; the kit's factory falls back to AABB
- * inscription for unknown kinds.
- *
- * `bounds` is still passed alongside as a useful AABB pose hint — factories
- * may use it as the node's pose even when richer geometry is available.
- */
-type InsertExtras = {
-    kind: 'rect';
-} | {
-    kind: 'ellipse';
-} | {
-    kind: 'line';
-    a: {
-        x: number;
-        y: number;
-    };
-    b: {
-        x: number;
-        y: number;
-    };
-} | {
-    kind: 'polygon';
-    sides: number;
-    rotation: number;
-    center?: {
-        x: number;
-        y: number;
-    };
-    radius?: number;
-} | {
-    kind: 'star';
-    points: number;
-    innerRadiusRatio: number;
-    rotation: number;
-    center?: {
-        x: number;
-        y: number;
-    };
-    outerRadius?: number;
-} | {
-    kind: 'pencil';
-    samples: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>;
-} | {
-    kind: 'text';
-    text?: string;
-} | {
-    kind: string;
-    [extra: string]: unknown;
-};
-/**
- * Adapter dep for `insertAction`.
- *
- * Provided by `<SceneCanvas>` / `<StandardActionsRegistrar>`. The `extras`
- * carry the active tool's kind + per-kind geometry. Callers
- * that need typed data must supply a richer `insert` dep.
- */
-interface InsertDep {
-    /**
-     * Materialise a new node from the given drag-rect bounds and typed
-     * per-kind extras. Returns the new node's id, or `null` if the consumer
-     * rejected the insert (e.g. sub-threshold bounds, unknown kind).
-     */
-    commit(bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, extras: InsertExtras): NodeId | null;
-}
-/**
- * Adapter dep for `resizeAction`.
- *
- * Carries the four behavior-shaping options the legacy `useResize` hook
- * exposed through `UseResizeOptions`: bounds-frame behaviors (e.g.
- * `lockAspectWithModifier`), world-space anchor-point snap behaviors (e.g.
- * `pointSnapToGrid`), group-expansion (`expandIds`), and pose↔bounds
- * projection (`geometry`).
- *
- * Optional in `DepSchema`: when absent, `resizeAction` falls back to
- * identity defaults (no behaviors, identity expandIds, `RECT_POSE_DESCRIPTOR`
- * geometry). Consumers wire the dep via `useDepSource('resizePolicy', ...)`
- * from any descendant of `<DepRegistryProvider>` / `<SceneCanvas>`.
- *
- * The generic is erased to `unknown` at the schema entry; consumers cast at
- * the call site (mirrors the `scene` entry's convention).
- */
-interface ResizePolicy<TPose> {
-    /** Bounds-frame constraints. Constrained to `TPose extends ResizePose` since
-     *  constraints read/write `{x,y,width,height}`. For non-rect TPose pass `[]`. */
-    constraints: TPose extends ResizePose ? BoundsConstraint<TPose>[] : never[];
-    /** World-space anchor-point snap behaviors. Same TPose constraint as
-     *  `constraints`. */
-    pointSnap: TPose extends ResizePose ? PointSnapBehavior<TPose>[] : never[];
-    /** Group-expansion at gesture start. Identity (`ids => ids`) when group
-     *  resize isn't wanted. */
-    expandIds: (ids: string[]) => string[];
-    /** Projection from `TPose` to bounds and back. Use `RECT_POSE_DESCRIPTOR`
-     *  for plain rect poses. */
-    projection: PoseProjection<TPose>;
-}
-/**
- * Layout-strategy lookup by container id, consumed by `moveAction` to run
- * the drag-time reflow pass. Sourced by `<SceneCanvas>` from its `layouts`
- * prop. Optional: `getLayout` returns null for any container when no layout
- * is configured, so the reflow pass is a no-op then.
- */
-interface LayoutDep {
-    getLayout(containerId: string): LayoutStrategy<unknown> | null;
-}
-interface DepSchema {
-    /** Kit selection state — ids of currently selected nodes. */
-    selection: SelectionApi;
-    /** Current viewport — camera position + scale. */
-    view: ViewApi;
-    /**
-     * Scene tree — structural reads + undoable mutations.
-     *
-     * The entry uses the fully-erased form `Scene<unknown, string, unknown>`
-     * because `DepSchema` must be concrete. Actions that need a typed scene
-     * should cast: `deps.scene as Scene<MyData, MyLayer, MyPose>`.
-     */
-    scene: Scene<unknown, string, unknown>;
-    /** Undo/redo history bound to the current scene. */
-    history: History;
-    /**
-     * Canvas pointer position in world space.
-     *
-     * Exposes `pointerRef` (mutable live ref) and `getDropPoint()` thunk.
-     * Marked `@experimental` in the source.
-     */
-    pointer: PointerContextValue;
-    /** Currently active tool id + hotkey-hold stack. */
-    activeTool: ActiveToolContextValue;
-    /**
-     * Area-select dep — AABB hit-test + selection read/write.
-     *
-     * Sourced from `<SceneCanvas>` via AABB overlap over all scene
-     * nodes. Override per-consumer for custom hit-testing (e.g. contain-mode,
-     * lock-aware filtering).
-     */
-    areaSelect: AreaSelectDep;
-    /**
-     * Topmost node at a world-space point. Sourced by `<SceneCanvas>` from
-     * the same picker that feeds the tool dispatcher's `getNodeAtPoint`.
-     * Optional: actions that read this (e.g. `moveAction` reparent-on-drop)
-     * fall back to a no-op when the dep isn't registered.
-     */
-    nodeAtPoint?: NodeAtPointDep;
-    /**
-     * Insert dep — node factory for drag-to-insert.
-     *
-     * Sourced from `<SceneCanvas>`. The `kind` param comes from
-     * the active binding's `opts.params.kind`. Override per-consumer to
-     * provide a typed node factory (e.g. with custom data payloads).
-     */
-    insert: InsertDep;
-    /**
-     * Lasso-select dep — polygon hit-test + selection read/write.
-     *
-     * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>`.
-     * Falls back to AABB hit-test when `hitTestLasso` is absent.
-     */
-    lassoSelect: LassoSelectDep;
-    /**
-     * Edit-anchors dep — narrow read/write of one polygon's path pose.
-     *
-     * Sourced from consumer. Wraps `getPose`/`setPose`/`applyOps`
-     * for the currently-being-edited polygon node.
-     *
-     * The `editAnchorsAction` requires this dep to be registered when anchor
-     * editing is active. If absent, `start` returns an empty handle (no-op).
-     */
-    editAnchors: EditAnchorsDep;
-    /**
-     * Text-edit dep — activates the in-place text editing overlay.
-     *
-     * Sourced from consumer via `useTextEdit` / `useSceneTextEdit`.
-     * The `enterTextEditAction` requires this dep to be registered by the text
-     * tool when text editing is available.
-     *
-     * The optional `isTextNode` predicate guards against entering edit mode on
-     * non-text nodes when no per-kind binding filter is available (Phase 14e
-     * follow-up will add per-kind classification to `classifyTarget`).
-     */
-    textEdit: TextEditDep;
-    /**
-     * Resize-policy dep — bounds constraints, point-snap behaviors,
-     * group expansion, and pose↔bounds projection for `resizeAction`.
-     *
-     * Optional: when omitted, `resizeAction` falls back to identity defaults
-     * (no constraints, no snap, identity expandIds, `RECT_POSE_DESCRIPTOR`).
-     * Consumers wire via `useDepSource('resizePolicy', ...)` or the
-     * `useResizePolicy` helper.
-     */
-    resizePolicy?: ResizePolicy<unknown>;
-    /**
-     * Booleans adapter — read selection ids, fetch world-space `Path`s,
-     * compare z-order, and mint result nodes for Pathfinder ops.
-     *
-     * Consumers wire via `useBooleansAdapter(adapter)` (a thin wrapper
-     * around `useDepSource('booleansAdapter', ...)`). The descriptor's
-     * `enabled` predicate reads `deps.selection` for the count check; the
-     * invoker reads `deps.booleansAdapter` to execute the op.
-     */
-    booleansAdapter?: BooleansAdapter;
-    /**
-     * Gesture dispatcher control surface — exposes `cancelAll(reason)` so
-     * actions that need to abort an in-flight handle (Escape cancels a
-     * drag, etc.) can do so. Sourced by `<SceneCanvas>` from the
-     * dispatcher instance it already owns.
-     */
-    dispatcher?: {
-        cancelAll(reason: 'commit' | 'cancel'): void;
-    };
-    /**
-     * Layout-strategy lookup. Sourced by `<SceneCanvas>` from `layouts`.
-     * Optional: absent (or all-null) → `moveAction` skips reflow.
-     */
-    layout?: LayoutDep;
-    /**
-     * Slice dep — consumer-supplied commit for the Slice action.
-     *
-     * Receives the finite slice segment in world coordinates; the consumer
-     * scans the scene, splits crossed paths via `splitPathByLine`, and
-     * applies the result as one undoable batch.
-     *
-     * Optional: when absent, `sliceAction` is a no-op.
-     */
-    slice?: SliceDep;
-    /**
-     * Optional consumer commit hook. When present, `moveAction` (and other
-     * default actions) submit their committed ops through it instead of
-     * `scene.applyBatch`, so apps with their own history integration
-     * (checkpoint + push entry) capture the gesture as one undo entry.
-     * When absent, commits fall back to `scene.applyBatch`.
-     */
-    applyOps?: (ops: Op[], label: string) => void;
-    /** Optional pose-composition strategy for hierarchical (local-pose) scenes.
-     *  When absent, defaults to IDENTITY (absolute-pose: nodes store world
-     *  coords). Local-pose consumers supply { compose: composeRectPose,
-     *  decompose: decomposeRectPose } (or their pose shape's equivalent). */
-    poseComposition?: PoseComposition<unknown>;
-    /**
-     * Ingestion dep — canvas viewport rect + consumer file→src resolver.
-     *
-     * Sourced from `<SceneCanvas>` / `<StandardActionsRegistrar>` via
-     * `useIngestionDepSource`. Feeds `ingestAction` with the world-space
-     * viewport rect for paste-placement and image fit-clamping, and forwards
-     * the consumer's optional `resolveSrc` seam.
-     *
-     * Optional: when absent, the `ingest` action no-ops (there is no
-     * placement geometry to work with).
-     */
-    ingestion?: IngestionDep;
-    /**
-     * Optional consumer seam for the eager-sync layer: lets pose-transform
-     * actions (resize/move/nudge/flip — NOT rotate) ALSO rewrite a node's
-     * data-held geometry. Given a node and the affine `m` applied to its pose,
-     * `transform(node, m)` returns updated `data` (geometry mapped by `m`) or
-     * `null` for nodes with no data-held geometry.
-     *
-     * Strictly opt-in: when absent (or when `transform` returns null), the kit
-     * emits only the pose op and leaves `data` untouched. apps/draw wires this
-     * to mirror `data.path` through `transformPath`. Rotate intentionally never
-     * consults this seam (rotation lives on the pose, baked at render).
-     */
-    geometryProjection?: GeometryProjection;
-}
-/**
- * Every dep name the registry knows about — derived from {@link DepSchema} so
- * the two can't drift.
- *
- * Declared here rather than beside the registry so that this `keyof` reference
- * resolves to the exported `DepSchema` declaration; from another module it
- * resolves to that module's import alias, which the API docs can't link.
- */
-type DepName = keyof DepSchema;
-
-interface DepRegistry {
-    register<K extends DepName>(name: K, source: () => DepSchema[K]): () => void;
-    get<K extends DepName>(name: K): DepSchema[K] | undefined;
-}
-declare function DepRegistryProvider({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function useDepRegistry(): DepRegistry;
-/**
- * Like `useDepRegistry`, but returns `null` when no `<DepRegistryProvider>` is
- * in scope instead of throwing. Used by `useStandardActions` to preserve its
- * silent-no-op contract when neither provider is present.
- */
-declare function useOptionalDepRegistry(): DepRegistry | null;
-/** Register a live source for `name` for the lifetime of the calling
- *  component. The `source` thunk is called at dispatch time and should
- *  return the latest value. */
-declare function useDepSource<K extends DepName>(name: K, source: () => DepSchema[K]): void;
-
-/**
- * Pure matcher primitives live in `@weasel-js/gestures`. This file
- * re-exports them for kit-internal consumers and layers the actions-layer
- * binding-scope / matchBest logic on top.
- */
-
-type BindingScope = 'ambient' | 'active' | 'hotkey';
-interface ScopedBinding {
-    binding: GestureBinding;
-    scope: BindingScope;
-    /** Tool id that owns this binding — `'&'`-channel phase atoms resolve
-     *  to this. `null` for ambient bindings that came from a registered
-     *  Action with no owning tool. */
-    ownerToolId: string | null;
-}
-interface MatchResult {
-    binding: GestureBinding;
-    scope: BindingScope;
-    /** Tool id that owns the binding — propagated from `ScopedBinding`
-     *  so the dispatcher can record it as the handle owner. */
-    ownerToolId: string | null;
-}
-
-/**
- * Dispatcher orchestrator — pure module, no React, no DOM.
- *
- * Assembles `ScopedBinding[]` from the actions registry, active tool, and
- * hotkey stack; matches input events via `matchSorted`; gates each candidate
- * on `enabled()`; then invokes `immediate` or `ongoing` invokers and tracks
- * in-flight handles.
- *
- * ## Specificity-ordered fall-through
- * `matchSorted` returns every matching binding in precedence order
- * (hotkey > active > ambient, first-declared within scope). The dispatcher
- * walks that list and fires the first action whose `enabled()` returns
- * `true`. If every candidate's `enabled()` returns a disabled reason, the
- * event is unhandled. This mirrors CSS-style specificity matching with a
- * `:not(:disabled)` filter, and lets a tool declare a high-specificity
- * binding (e.g. drag-on-empty → areaSelect) that gracefully falls through
- * to a lower-specificity ambient binding (e.g. drag → viewport.dragPan)
- * when its required deps aren't wired.
- *
- * ## gestureId scheme
- * - `key-held` ongoing actions: `key-held-<key>` (e.g. `key-held- ` for Space).
- *   Chosen because key-held gestures are identified by the held key alone.
- * - `pointerdown` / drag ongoing actions: `pointer-<pointerId>`, where
- *   `pointerId` defaults to `'mouse'` (Phase 3 has no real pointer IDs; the
- *   React seam in Task 4 will supply the actual DOM pointerId).
- * - `multitouch` ongoing actions: `multitouch-<fingers>`.
- * - Fallback for any other kind that triggers an ongoing invoker: `ongoing-<kind>`.
- *
- * ## Action-lookup miss behavior
- * When `matchBest` resolves a binding whose `actionId` has no entry in
- * `ctx.actions.list()`, the dispatcher emits `console.warn` and returns
- * `'unhandled'`. The user's input gesture falls through as if unmatched.
- * This preserves input flow (nothing is swallowed silently) while flagging
- * the misconfiguration at dev time.
- */
-
-interface DispatcherContext {
-    /** All registered actions; the dispatcher walks `.defaultBinding` for ambient bindings. */
-    actions: ActionsRegistry;
-    /** Dep sources keyed by name. */
-    depRegistry: DepRegistry;
-    /** Active tool's id (from ActiveToolContext). */
-    activeToolId: string;
-    /** Held-hotkey stack, top of stack last. */
-    hotkeyStack: readonly string[];
-    /** Lookup for tool definitions. */
-    toolsById: ReadonlyMap<string, Tool>;
-    /** Platform flag for `mod` shorthand resolution. */
-    isMac: boolean;
-    /**
-     * Thunk returning a fresh `RuleCtx` for the current frame. When
-     * supplied, the dispatcher filters matched candidates by their
-     * declared `Action.eligible` rule (omitted => always eligible).
-     * When omitted, no eligibility filtering is applied — preserves
-     * backward compatibility for callers (tests, legacy harnesses) that
-     * don't wire up chrome-caps state.
-     */
-    getRuleCtx?: () => RuleCtx;
-}
-/**
- * Handle returned by `Dispatcher.beginUiOngoing()` for driving an
- * ongoing invoker from a UI control (color picker, slider).
- *
- *  - `update(params)` rebuilds an `InvocationCtx` with the new params and
- *    calls the handle's `onMove`. Safe to call many times.
- *  - `end(reason)` calls `onEnd(ctx, reason)` once and removes the handle
- *    from the in-flight map. Idempotent — further calls are no-ops.
- */
-interface UiOngoingControl {
-    readonly gestureId: string;
-    update(params?: Record<string, unknown>): void;
-    end(reason: 'commit' | 'cancel'): void;
-}
-/**
- * Successful `Dispatcher.resolveOnly` prediction: the binding + action that
- * would fire if `event` were dispatched for real. `action` is the resolved
- * descriptor so callers (the hover-cursor pump) can read metadata like
- * `Action.cursor` without a second registry lookup.
- */
-interface ResolveOnlyResult {
-    actionId: string;
-    action: Action;
-    scope: BindingScope;
-    /** Tool id owning the winning binding; `null` for ambient action bindings. */
-    ownerToolId: string | null;
-}
-interface Dispatcher {
-    /**
-     * Route an input event through the binding pipeline. Returns `'handled'`
-     * when a binding matched and the action invoked successfully (whether it
-     * returned ops or not). Returns `'unhandled'` when no binding matched or
-     * the matched action's `enabled()` returned a disabled reason.
-     */
-    handleInput(event: InputEvent, ctx: DispatcherContext): 'handled' | 'unhandled';
-    /**
-     * Predict which action `event` would route to WITHOUT invoking it. Replays
-     * the same walk as `handleInput` — scope assembly, specificity-sorted
-     * match, eligibility filter, per-candidate `enabled()` gate — and returns
-     * the first candidate that would fire, or `null` when the event would go
-     * unhandled. Pure query: no invoker runs, no in-flight state changes, no
-     * trace-log entry.
-     *
-     * Known divergence from a real dispatch: an ongoing invoker that matches
-     * but returns an empty handle at `start()` (runtime bail) makes the real
-     * dispatch fall through to the next candidate; prediction cannot see that
-     * and reports the bailing action. Keep `enabled()` accurate on actions
-     * that rely on prediction (hover cursors).
-     */
-    resolveOnly(event: InputEvent, ctx: DispatcherContext): ResolveOnlyResult | null;
-    /**
-     * Synthesize an end-of-gesture for every in-flight ongoing handle.
-     * Used by tool-switch cancellation (Q2 decision).
-     */
-    cancelAll(reason: 'commit' | 'cancel'): void;
-    /**
-     * Read-only view of currently in-flight ongoing handles, keyed by gestureId.
-     * For debug/testing.
-     */
-    inFlight(): ReadonlyMap<string, OngoingHandle>;
-    /**
-     * Read-only iterator over currently in-flight `OngoingHandle` instances.
-     *
-     * Surface for the canvas's preview-ghost layer (`usePreviewGhostLayer`)
-     * to walk each handle's `previewIds()` / `previewPose(id)` and render
-     * dispatcher-driven gesture previews. Read-only by design:
-     * external consumers must not mutate the in-flight map.
-     */
-    getInFlightHandles(): Iterable<OngoingHandle>;
-    /**
-     * Subscribe to in-flight state changes. The callback fires after every
-     * mutation that affects what the preview-ghost / dispatcher-overlay
-     * layers read — handle start, every `onMove` pump, end, cancel,
-     * cancel-all. Consumers re-read `getInFlightHandles()` and re-render.
-     *
-     * Returns an unsubscribe function.
-     */
-    subscribe(fn: () => void): () => void;
-    /**
-     * Snapshot of the currently active action, for surfaces (chrome-caps
-     * visibility rules, debug HUDs) that need to react to "what action
-     * is in flight right now."
-     *
-     * - `kind` — the `OngoingHandle.kind` reported by the in-flight
-     *   handle (e.g. `'marquee'`, `'move'`). `null` when no action is
-     *   in flight OR the handle didn't declare a kind.
-     * - `id` — the dispatcher's internal `gestureId` (`pointer-mouse`,
-     *   `key-held-Space`, …) — the pointer/key channel the action rode
-     *   in on. `null` when no action is in flight.
-     *
-     * When multiple handles are in flight simultaneously (e.g. a key-held
-     * action overlapping a pointer action), the most-recently-started
-     * handle wins. This matches user intent: the latest interaction is
-     * the one consumers care about.
-     */
-    getActiveAction(): {
-        kind: string | null;
-        id: string | null;
-    };
-    /**
-     * Start an ongoing action driven by UI (not a gesture). Builds an
-     * `InvocationCtx` with the given `deps` and `params`, calls
-     * `action.invoker.start(ctx, { params })`, and registers the returned
-     * handle in the in-flight map so `getInFlightHandles()` reports it —
-     * enabling preview rendering via `SceneCanvas`.
-     *
-     * Returns `null` if `actionId` is unknown, the action's invoker is not
-     * ongoing, or `start` returned an empty handle.
-     *
-     * If a UI-driven handle for the same `actionId` is already in flight,
-     * it is committed (`end('commit')`) before the new one starts.
-     */
-    beginUiOngoing(actionId: string, deps: ActionDeps, params?: Record<string, unknown>): UiOngoingControl | null;
-}
-declare function createDispatcher(opts?: {
-    getAction?: (id: string) => Action | undefined;
-}): Dispatcher;
-
-/**
- * @experimental
- * A single entry in `Action.defaultBinding[]`. Either a bare `GestureSpec`
- * (no per-binding opts) or an object form that pairs a spec with
- * `BindingOpts` for parametric actions (e.g. `{ params: { axis: 'x' } }`).
- * Use the object form when two bindings for the same action differ only in
- * a runtime parameter — the dispatcher extracts `opts.params` and passes
- * them to `ImmediateInvoker.run` as its second argument.
- */
-type BoundGesture = GestureSpec | {
-    spec: GestureSpec;
-    opts: BindingOpts;
-};
-/**
- * @experimental
- * Single registered action. v1: one binding per action.
- */
-interface Action {
-    id: string;
-    label: string;
-    /** The gesture-spec form of the binding, read by the gesture dispatcher.
-     *  May be a single `GestureSpec`, a bare `GestureSpec[]` (any-of semantics),
-     *  or a `BoundGesture[]` where each entry is either a bare `GestureSpec` or
-     *  `{ spec, opts }` — use the object form for parametric actions where two
-     *  bindings for the same action differ only by `opts.params` (e.g. `flip`
-     *  with `axis: 'x'` vs `'y'`). The dispatcher extracts `opts.params` and
-     *  passes them to `ImmediateInvoker.run` as its second argument. */
-    defaultBinding?: GestureSpec | BoundGesture[];
-    /** Names of the deps this action's invoker reads (keys of `DepSchema`).
-     *  The dispatcher (and `trigger`, when `requires` is present) resolves
-     *  each name against the `DepRegistry` at invocation time and passes the
-     *  resulting bag to the invoker. Dev builds warn when the invoker reads a
-     *  dep it didn't declare here — see `buildDepsFromRequires`. */
-    requires?: readonly DepName[];
-    /** Inline-SVG icon for palette / toolbar surfaces. Mirrors
-     *  `ToolPresentation.icon` so a generic `<ActionBar>` can render from
-     *  action metadata the same way `<ToolPalette>` renders from tool
-     *  metadata. May be a static `ReactNode` or a function (rare; useful
-     *  for state-aware icons like a "lock" toggle). */
-    icon?: ReactNode | (() => ReactNode);
-    /** Grouping key for palette/menu surfaces. Free-form string; the kit
-     *  ships defaults for `'align'` (six edges/centers), `'distribute'`
-     *  (two axes), and recommends `'pathfinder'` for boolean ops. */
-    group?: string;
-    /** Display override for the keyboard shortcut. When omitted, palette
-     *  surfaces derive a label from `defaultBinding` via their own
-     *  formatter. */
-    shortcut?: string;
-    /** Pluggable invocation strategy. The gesture dispatcher routes matched
-     *  bindings through `invoker.start` / `invoker.run` depending on timing.
-     *  All kit-standard descriptors ship one; consumer-supplied actions
-     *  without an invoker can still register but won't be triggered. */
-    invoker?: Invoker;
-    /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey
-     *  `BindingScope` instead of the ambient scope — meaning it beats any
-     *  active-tool binding on the same input shape. Use for tool-switch
-     *  shortcuts and global held-key triggers. Default: ambient. */
-    scope?: 'hotkey';
-    /**
-     * @experimental
-     * Optional predicate the command palette consults when rendering. Return
-     * `true` when the action is currently triggerable. Return a reason string
-     * (e.g. `'Selection required'`) when disabled — the palette greys out
-     * the row, skips it in keyboard nav, ignores clicks, and shows the
-     * reason next to the label. Keystroke dispatch (the registered binding)
-     * is unaffected; the action's own `run` should self-guard.
-     *
-     * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and
-     * must not throw. If a call throws or exceeds the budget in dev mode,
-     * `evaluateEnabled` logs a one-time warning per action id; throws are
-     * caught and treated as disabled with reason `'(predicate threw)'`.
-     *
-     * Snapshot-on-open semantics: the palette evaluates `enabled` once when
-     * opened and does NOT re-evaluate on selection changes while open. Live
-     * reactive updates are deferred — palette is short-lived.
-     *
-     * The reason set is a closed enum — to add a new reason, edit
-     * `ActionDisabledReason` and the consumer's display map.
-     *
-     * The optional `deps` argument is the same bag passed to
-     * `ImmediateInvoker.run`; callers (`evaluateEnabled` / the ActionBar) may
-     * synthesize it from the surrounding `DepRegistry` so predicates can
-     * inspect selection / scene / etc. Predicates that don't need deps just
-     * ignore the arg.
-     */
-    enabled?: (deps?: ActionDeps) => true | ActionDisabledReason;
-    /**
-     * Declarative eligibility rule, evaluated against the current
-     * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =
-     * always eligible.
-     *
-     * Accepts either a fluent `Condition` (callable with `.rule`) or a
-     * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.
-     *
-     * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)
-     * over `mode:` rules — capability rules survive new modes being added
-     * that allow the same capability.
-     */
-    eligible?: Rule | Condition;
-    /**
-     * CSS cursor shown while the pointer hovers a spot where this action
-     * would win the drag. The hover-cursor pump (in `useGestureDispatcher`)
-     * runs `Dispatcher.resolveOnly` on each idle pointermove — the same
-     * match walk a real pointerdown takes — and applies the winning
-     * action's `cursor`, so the hint and the actual click target stay in
-     * sync by construction. Omitted = no override (the active tool's
-     * `Tool.cursor` shows). Affordance hits are resolved earlier in the
-     * pump via `AffordanceRegion.cursor` and never reach this field.
-     *
-     * Static string only. Prediction runs `enabled()` but cannot run the
-     * invoker, so an action that matches yet bails at `start()` (empty
-     * handle) may still show its cursor — keep `enabled` accurate for
-     * actions that declare one.
-     */
-    cursor?: string;
-}
-/**
- * @experimental
- * Closed enum of reasons an action might report itself as disabled. The
- * consumer (palette, menu, etc.) maps these symbolic values to display
- * strings via its own label map — see `demo/CommandPalette.tsx` for the
- * canonical mapping.
- */
-declare const ActionDisabledReason: {
-    readonly SelectionRequired: "selection-required";
-    readonly SceneEmpty: "scene-empty";
-    readonly NotApplicable: "not-applicable";
-    /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
-    readonly PredicateThrew: "predicate-threw";
-};
-type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
+declare const modeNot: (m: string) => Condition;
+/** Active mode's `allows` includes capability `cap`. */
+declare const capabilityIs: (cap: string) => Condition;
+/** Active mode's `allows` includes ANY of `caps` (OR). */
+declare const capabilityIn: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` includes ALL of `caps` (AND). */
+declare const capabilityAll: (caps: readonly string[]) => Condition;
+/** Active mode's `allows` does NOT include capability `cap`. */
+declare const capabilityNot: (cap: string) => Condition;
+
 /**
- * @experimental
- * Result of evaluating an Action's `enabled` predicate.
+ * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
+ * at resolve time; consumer entries take precedence per id.
+ *
+ * Written as literal Rule trees rather than fluent chains so the inputs
+ * each rule depends on are immediately visible. The fluent atoms compile
+ * to the same trees; either form is valid in a VisibilityRules entry.
+ *
+ * Gating is written in terms of **capabilities, not mode ids**. A
+ * capability rule keeps holding when a new mode is added that permits the
+ * same thing; a mode rule has to be found and edited every time. The one
+ * exception is the `path-edit.*` chrome below, which is genuinely
+ * mode-specific: it's the visual signature of that mode, not a statement
+ * about what the user is allowed to do.
+ *
+ * Chrome that gates on the *absence* of a capability (the selection
+ * outline, suppressed while an anchor-editing overlay owns the visuals)
+ * uses `capability: { not: … }` for the same reason.
  */
-interface ActionEnabledResult {
-    enabled: boolean;
-    reason?: ActionDisabledReason;
-}
-declare function evaluateEnabled(action: Action, deps?: ActionDeps): ActionEnabledResult;
+declare const defaultVisibilityRules: VisibilityRules;
+
 /**
- * @experimental
- * Partial override or full descriptor passed via `<SceneCanvas actions={...}>`.
- * `null` disables a default at this id.
+ * Build the per-frame visibility check. Merges consumer rules on top
+ * of the kit defaults, then closes over `ctx` so each chrome-id
+ * lookup runs its rule against the current state.
+ *
+ * `VisibilityRules` entries may be either fluent `Condition` values
+ * (callable) or raw `Rule` trees — we normalize at lookup time.
+ *
+ * Predicates are O(1) and run once per chrome id per frame; no
+ * memoization in v1 — profile before adding any.
+ *
+ * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
+ * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
+ * opted into modality behaves exactly like one sitting in normal mode.
  */
-type ActionEntry = null | Partial<Action> | Action;
+declare function resolveVisibility(consumer: VisibilityRules | undefined, ctx: ChromeCtx | RuleCtx): (id: ChromeId) => boolean;
+
 /**
- * @experimental
- * Shape of the `actions` prop on `<SceneCanvas>`. `null` disables all defaults.
+ * Pure assembler for {@link ChromeCtx}.
+ *
+ * Called once per frame on the rendering side from whichever surface
+ * needs to evaluate visibility rules — `composeAffordanceLayer`,
+ * `createSelectionOverlayLayer`, the dispatcher overlay layer, etc.
+ *
+ * Sources are passed as plain getters / values rather than the live
+ * objects they come from. This keeps `chrome-caps` from depending on
+ * React, the dispatcher's concrete type, or `ChromeState`'s bounds
+ * machinery — the same builder works from a test harness, a Storybook
+ * fixture, or `<SceneCanvas>`.
  */
-type ActionsProp = null | Record<string, ActionEntry>;
-/**
- * @experimental
- * Imperative API exposed by `useActionsRegistry()`.
- */
-interface ActionsRegistry {
-    register(action: Action): () => void;
-    unregister(id: string): void;
-    list(): readonly Action[];
-    /** Fire an immediate-invoker action by id. The optional `params` arg is
-     *  forwarded to `ImmediateInvoker.run` as its second argument — use it for
-     *  parametric actions (e.g. `trigger('tool.activate', { toolId: 'rect' })`).
-     *  Ongoing-invoker actions are not reachable from `trigger`. */
-    trigger(id: string, params?: Record<string, unknown>): boolean;
-    /**
-     * Subscribe to registry mutations. The callback fires after any
-     * `register`/`unregister` that changes the version. Returns an
-     * unsubscribe function. Designed for `useSyncExternalStore`-driven
-     * surfaces (e.g. `<ActionBar>` in `@weasel-js/ui`) that need to
-     * re-render when the action set changes.
-     */
-    subscribe(listener: () => void): () => void;
-    /**
-     * Start an ongoing action driven by UI (color picker, opacity slider).
-     * Returns a control object with `update(params)` and `end(reason)`.
-     *
-     * Returns `null` if no dispatcher is wired into this registry, the
-     * action is unknown, or its invoker is not ongoing.
-     *
-     * See `Dispatcher.beginUiOngoing` for full semantics including
-     * auto-commit when a prior UI handle for the same action is in flight.
-     */
-    begin(id: string, params?: Record<string, unknown>): UiOngoingControl | null;
-    /** Wire a dispatcher into the registry so `begin()` can delegate to it.
-     *  Call with `null` to detach. Idempotent. */
-    setDispatcher(d: Dispatcher | null): void;
-    /** Wire a `DepRegistry` into the registry so `trigger()` / `begin()` can
-     *  resolve action deps even when this provider is mounted ABOVE the dep
-     *  registry (e.g. a consumer's root `<ActionsProvider>` reused by
-     *  SceneCanvas's `ActionsProviderIfRoot`). Takes precedence over the dep
-     *  registry read from context at the provider's own level. Call with
-     *  `null` to detach. */
-    setDepRegistry(r: DepRegistry | null): void;
+
+interface BuildChromeCtxArgs {
+    focused: boolean;
+    selection: readonly NodeId[];
+    multiActive: boolean;
+    modifiers: ModifierState;
+    action: {
+        kind: string | null;
+        id: string | null;
+    };
+    hover: NodeId | null;
+    view: View;
 }
+declare function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx;
+
 /**
- * @experimental
- * Mounts an `ActionsRegistry` and one `document` keydown listener for its
- * lifetime. Children call `useActionsRegistry()` or `useAction()` to participate.
- */
-declare function ActionsProvider({ children }: {
-    children: ReactNode;
-}): ReactElement;
-/**
- * @experimental
- * Returns the parent `ActionsRegistry`, or `null` when no provider is in scope.
- */
-declare function useActionsRegistry(): ActionsRegistry | null;
-/**
- * @experimental
- * Register an `Action` for the lifetime of the calling component. No-op when
- * no `ActionsProvider` is in scope. Re-registers on `action` reference change
- * (consumers should memoize stable identities to avoid churn).
+ * useHoverTracking — last-hovered NodeId for chrome-caps rules.
+ *
+ * Attaches a `pointermove` listener to the supplied canvas; on each
+ * move, converts client coords → world coords and runs the supplied
+ * `getNodeAtPoint`, caching the resulting id on a ref. Cleared on
+ * `pointerleave` (pointer left the canvas → nothing is hovered).
+ *
+ * Returns a stable getter — call once per frame from `buildChromeCtx`.
+ *
+ * No re-render: the ref updates silently, and the next render that
+ * reads it picks up the fresh value. Chrome-caps rules are evaluated
+ * during paint, so the hover state is always read fresh.
  */
-declare function useAction(action: Action): void;
+
+interface UseHoverTrackingArgs {
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+    /** Client → world conversion. Same shape as the dispatcher's. */
+    clientToWorld: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    };
+    /** Topmost-id resolver. Returns null when the world point hits nothing. */
+    getNodeAtPoint: (worldX: number, worldY: number) => {
+        id: NodeId;
+    } | null;
+    enabled?: boolean;
+}
+declare function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null;
 
 /**
  * `moveAction` — first `ongoing`-timing Action descriptor.
@@ -2669,12 +1250,19 @@ declare const areaSelectAction: Action & {
  * delegating to the scene's `add()` with a sensible default data payload for
  * the given `kind`. Override per-consumer for custom node factories.
  *
+ * ## Modifiers and snapping
+ *
+ * Grid snapping comes from the optional `snap` dep, applied to the drag's
+ * start and current point (never to freehand pencil samples). The `line`
+ * kind additionally honors Shift (constrain to 15°) and reads Alt/center as
+ * "mirror the start around the pointer" rather than "grow a symmetric AABB".
+ * All of it resolves in `resolveEndpoints`, which both `overlay()` and
+ * `onEnd()` call — so the live preview and the committed node can't disagree.
+ *
  * ## What this does NOT wire (vs `useInsert`)
  *
- * - `InsertBehavior` pipeline (snap, etc.) — deferred to a later phase.
  * - `pointInsert` fallback for click / sub-threshold drags — not wired; a
  *   sub-threshold drag produces no insert.
- * - Live insert overlay — deferred to Phase 7 overlay surface.
  * - `clickOnly` mode — not applicable to the descriptor model.
  *
  * ## Live preview
@@ -2730,17 +1318,32 @@ declare const insertAction: Action & {
  * This avoids ambient double-fire and keeps the action scoped to select-tool
  * context where `classifyTarget` is wired.
  *
- * ## enabled
+ * ## enabled — the anchor-editing fall-through
+ *
+ * There is no "is anything selected?" guard: clearing an already-empty
+ * selection is a safe no-op, and the binding spec is the real gate for
+ * where the click landed.
+ *
+ * What `enabled` *does* do is decline while a path is in anchor-edit mode,
+ * so the dispatcher falls through to `selectAnchorAction`. This is the
+ * click twin of the opt-out `areaSelectAction.start` already performs for
+ * the drag gesture, and it exists for the same reason: `useSelectTool`
+ * binds this action at **active** scope while `selectAnchor` is **ambient**,
+ * so without the gate an anchor that happens to sit over empty canvas
+ * clears the node selection instead of selecting the anchor.
  *
- * Returns `SelectionRequired` disabled reason when nothing is selected, so the
- * dispatcher skips the action on an already-empty canvas (no-op guard).
+ * Capability eligibility (`creates-selection`, which `path-edit` does not
+ * allow) already covers consumers that wired a mode registry. Consumers
+ * without one get no eligibility filtering at all, so this gate is the only
+ * thing separating the two. Both mechanisms are needed — see the header of
+ * `anchorEditing.ts`.
  */
 
 /**
  * @experimental
  * Static descriptor for the `clearSelection` Action.
  *
- * Requires dep-schema entry: `selection`.
+ * Requires dep-schema entries: `selection`, `editAnchors`.
  *
  * Registered via `useStandardActions`; bound via `useSelectTool.bindings`.
  */
@@ -2920,40 +1523,43 @@ declare const viewportZoomAction: Action & {
 /**
  * `editAnchorsAction` — ongoing Action descriptor for editing polygon anchors.
  *
- * ## Status: REAL
+ * Owns the whole press-on-an-anchor gesture, because pressing and dragging
+ * an anchor are two outcomes of one interaction rather than two
+ * interactions:
+ *
+ *   - **Press** selects. Bare press replaces the anchor selection; Shift
+ *     toggles the pressed anchor in or out of it. Pressing an anchor that
+ *     is already part of a multi-anchor selection leaves the selection
+ *     alone, so you can grab a set and move it.
+ *   - **Drag** then moves whatever the press left selected — one anchor,
+ *     or every selected anchor together.
+ *   - **Dragging a control handle** moves just that handle, mirroring the
+ *     opposite one while the anchor is smooth. Alt breaks the mirror.
+ *
+ * Selection lives on the `editAnchors` dep (flat anchor indices) rather
+ * than in this handle's scratch, because the keyboard actions
+ * (`nudgeAnchors`, `deleteAnchors`) and the overlay all need to read it
+ * between gestures.
  *
- * The descriptor is fully operational when the consumer wires:
+ * ## Wiring
+ *
+ * The descriptor is operational when the consumer wires:
  *   1. `buildAffordanceAt` with a `getAnchorState` thunk so the dispatcher
  *      classifies anchor/control-handle hits as `anchor:N`, `controlIn:N`,
  *      or `controlOut:N` affordances on pointerdown.
  *   2. The `editAnchors` dep in the DepSchema.
  *
- * The invoker reads `ctx.drag.affordance.kind` to identify the hit anchor,
- * derives the coord index from `enumerateAnchors`, and on every `onMove`
- * writes the new absolute world position via `withCoord`. On `onEnd('commit')`
- * it dispatches a `createTransformOp` through `dispatchApplyBatch` so the
- * edit is undoable.
- *
  * When `ctx.drag.affordance` is absent or is not an anchor/control kind,
  * `start` returns `{}` (no-op) so other bindings can handle the drag.
  *
- * @see useEditAnchors — the React hook this descriptor mirrors.
  * @see buildAffordanceAt — the classifier that produces anchor affordances.
+ * @see anchorEdits — the pure geometry these handlers drive.
  */
 
 /**
  * Static descriptor for the `editAnchors` Action.
  *
  * Requires dep-schema entries: `selection`, `editAnchors`.
- *
- * The invoker reads `ctx.drag.affordance.kind` to identify the anchor hit.
- * If the affordance is absent or not an anchor kind, `start` returns `{}`
- * (no-op), allowing other bindings to handle the drag.
- *
- * Consumers must provide `buildAffordanceAt` with a `getAnchorState` thunk
- * so that anchor handles are classified at pointerdown.
- *
- * @see useEditAnchors — the React hook this descriptor mirrors.
  */
 declare const editAnchorsAction: Action & {
     requires: string[];
@@ -3130,8 +1736,28 @@ interface UseGestureDispatcherOptions {
     actions: ActionsRegistry;
     /** Tool definitions keyed by id. Typically passes an empty Map. */
     toolsById: ReadonlyMap<string, Tool>;
+    /** Ids (within `toolsById`) of always-on tools, whose bindings assemble at
+     *  ambient scope. See `DispatcherContext.ambientToolIds`. */
+    ambientToolIds?: readonly string[];
     /** Default true. Set false to opt out of dispatcher wiring (e.g. demos that disable it). */
     enabled?: boolean;
+    /**
+     * Observer fired whenever the dispatcher synthesizes a double click, in
+     * world coordinates. Runs BEFORE the event is dispatched and independently
+     * of which binding (if any) handles it.
+     *
+     * This is deliberately not an Action. `<SceneCanvas onDoubleClick>` is a
+     * notification — "the user double-clicked, here's what they hit" — and a
+     * notification must not compete with behavior for the gesture. As a binding
+     * it would lose to `enterPathEdit` on any body hit and silently never fire.
+     * Routing it here keeps a single definition of "double click" (the point of
+     * consolidating the kit's three detectors) without giving it
+     * first-match-wins semantics it shouldn't have.
+     */
+    onDoubleClick?: (world: {
+        x: number;
+        y: number;
+    }) => void;
     /**
      * Default true. Set false to leave the window `keydown`/`keyup` listeners
      * unattached so keyboard-bound actions never dispatch — pointer, wheel, and
@@ -3160,23 +1786,25 @@ interface UseGestureDispatcherOptions {
         y: number;
     }) => AffordanceHit | null;
     /**
-     * Optional body-target classifier. Called on every pointerdown with the
-     * world-space coordinates of the pointer. Returns a classification string
-     * that `matchTarget` uses to resolve string-form `TargetSpec` values in
-     * `Tool.bindings` drag specs.
+     * Optional body classifier. Called on every pointerdown with the world-space
+     * coordinates of the pointer. Its result is packed onto the event as
+     * `bodyTarget` + `bodyKind`, which `matchTarget` reads to resolve the
+     * string-form `TargetSpec` values in `Tool.bindings`.
      *
-     * Returns `'empty'` when nothing is under the pointer, `'selected-body'`
+     * `body` is `'empty'` when nothing is under the pointer, `'selected-body'`
      * when the topmost hit belongs to the current selection, or
-     * `'unselected-body'` when it belongs to a node that isn't selected.
+     * `'unselected-body'` when it belongs to a node that isn't selected. `kind`
+     * is the hit node's semantic kind, when the scene can name it.
      *
-     * When omitted, string-form target specs (`'empty'`, `'selected-body'`,
-     * `'unselected-body'`) never match — bindings using those specs are
-     * silently skipped. `<SceneCanvas>` wires this.
+     * When omitted, every body-derived target form (`'empty'`,
+     * `'selected-body'`, `'unselected-body'`, `kind:<k>`, `kind:<k>:selected`)
+     * never matches — bindings using those specs are silently skipped.
+     * `<SceneCanvas>` wires this.
      */
     classifyTarget?: (worldPoint: {
         x: number;
         y: number;
-    }) => 'empty' | 'selected-body' | 'unselected-body';
+    }) => BodyClassification;
     /**
      * Optional pre-created `Dispatcher`. When provided, this hook pumps events
      * into the supplied instance instead of creating its own. Lets a parent
@@ -3365,218 +1993,6 @@ declare function useViewAnimation(setView: (v: View) => void): {
     cancel: () => void;
 };
 
-interface ResizeController<TNode extends {
-    id: string;
-} = {
-    id: string;
-}, TPose = unknown> {
-    start(id: string, anchor: ResizeAnchor, worldX: number, worldY: number): void;
-    move(worldX: number, worldY: number, modifiers: ModifierState): boolean | void;
-    end(): void;
-    cancel(): void;
-    isResizing?: boolean;
-    overlay?: unknown;
-    adapter?: unknown;
-    readonly __posePhantom?: TPose;
-    readonly __nodePhantom?: TNode;
-}
-interface MoveController<TNode extends {
-    id: string;
-} = {
-    id: string;
-}, TPose = unknown> {
-    start(args: {
-        ids: string[];
-        worldX: number;
-        worldY: number;
-        clientX?: number;
-        clientY?: number;
-    }): void;
-    move(args: {
-        worldX: number;
-        worldY: number;
-        clientX?: number;
-        clientY?: number;
-        modifiers: ModifierState;
-    }): void;
-    end(): void;
-    cancel(): void;
-    adapter?: unknown;
-    readonly __posePhantom?: TPose;
-    readonly __nodePhantom?: TNode;
-}
-interface RotateController<TNode extends {
-    id: string;
-} = {
-    id: string;
-}, TPose = unknown> {
-    start(args: {
-        id: string;
-        worldX: number;
-        worldY: number;
-    }): void;
-    move(args: {
-        worldX: number;
-        worldY: number;
-        modifiers: ModifierState;
-    }): void;
-    end(): void;
-    cancel(): void;
-    readonly __posePhantom?: TPose;
-    readonly __nodePhantom?: TNode;
-}
-interface InsertController<TNode extends {
-    id: string;
-} = {
-    id: string;
-}, TPose = unknown> {
-    start(worldX: number, worldY: number, modifiers: ModifierState): void;
-    move(worldX: number, worldY: number, modifiers: ModifierState): void;
-    end(): void;
-    cancel(): void;
-    readonly __posePhantom?: TPose;
-    readonly __nodePhantom?: TNode;
-}
-interface AreaSelectController {
-    start(worldX: number, worldY: number, modifiers: ModifierState): void;
-    move(worldX: number, worldY: number, modifiers: ModifierState): void;
-    end(): void;
-    cancel(): void;
-}
-
-/** Pointer event handlers ready to spread onto a `<canvas>`. */
-interface PointerGestureBindings {
-    onPointerDown: (e: React__default.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerMove: (e: React__default.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerUp: (e: React__default.PointerEvent<HTMLCanvasElement>) => void;
-    onPointerCancel: (e: React__default.PointerEvent<HTMLCanvasElement>) => void;
-    onLostPointerCapture: (e: React__default.PointerEvent<HTMLCanvasElement>) => void;
-}
-/** Context object passed to body-hit / tap-empty callbacks. */
-interface PointerGestureCallbackCtx {
-    event: React__default.PointerEvent<HTMLCanvasElement>;
-    worldX: number;
-    worldY: number;
-    modifiers: ModifierState;
-}
-/** Options for `usePointerGestures` — wires move/resize/rotate/insert/area-select controllers into a single canvas. */
-interface UsePointerGesturesOptions<TMovePose, TResizePose> {
-    /** clientX/Y → world coords. Default: `clientToCanvas` (no pan/zoom). Apps
-     *  with a viewport transform compose pan/zoom into this callback. */
-    clientToWorld?: (canvas: HTMLCanvasElement, clientX: number, clientY: number) => [number, number];
-    /** Live move interaction. Omit to disable body-drag dispatch. */
-    move?: MoveController<{
-        id: string;
-    }, TMovePose>;
-    /** Live resize interaction. Omit to disable handle-drag dispatch. */
-    resize?: ResizeController<{
-        id: string;
-    }, TResizePose>;
-    /** Live rotation interaction. Omit to disable rotation-handle dispatch. */
-    rotate?: RotateController<{
-        id: string;
-    }, TResizePose>;
-    /** Live insert interaction. When `tool === 'insert'`, an empty-space
-     *  pointer-down dispatches to `insert.start` instead of `onTapEmpty`. */
-    insert?: InsertController<{
-        id: string;
-    }, unknown>;
-    /** Live area-select interaction. When `tool === 'select'` (or undefined),
-     *  an empty-space pointer-down dispatches to `areaSelect.start` instead of
-     *  `onTapEmpty`. */
-    areaSelect?: AreaSelectController;
-    /** Empty-space tool. Default `'select'`. Picks insert vs area-select on
-     *  empty-space pointer-down. Ignored if neither controller is wired. */
-    tool?: 'select' | 'insert' | 'none';
-    /** Currently rotatable target. The hook positions the rotation handle
-     *  above the (rotated) top-center of `bounds` and dispatches
-     *  `rotate.start({ id, ... })` on hit.
-     *
-     *  When omitted but `rotate`, `selection`, and `boundsOf` are all
-     *  supplied, defaults to single-selection bounds (multi → null). */
-    rotateTarget?: () => {
-        id: string;
-        bounds: Bounds;
-        rotation?: number;
-    } | null;
-    /** World-pixel distance from the top edge to the rotation handle.
-     *  Default `DEFAULT_ROTATION_HANDLE_DISTANCE`. */
-    rotationHandleDistance?: number;
-    /** Currently resizable target. Hook computes corner handles, hit-tests, and
-     *  dispatches `resize.start(id, anchor, ...)`. Return `null` for none.
-     *
-     *  When omitted but `selection` and `boundsOf` are both supplied, defaults
-     *  to single-selection bounds (multi-selection returns `null`). */
-    resizeTarget?: () => {
-        id: string;
-        bounds: Bounds;
-        rotation?: number;
-    } | null;
-    /** Hit-test radius for resize/rotation handles, in **screen** pixels.
-     *  Divided by `view.scale` (via `getView`) at compare time so the hit
-     *  area matches the visually rendered handle size under zoom.
-     *  Default 8. */
-    handleHitRadius?: number;
-    /** Returns the current view. Used to convert `handleHitRadius` (screen px)
-     *  into world units at hit-test time. Defaults to identity (scale=1) so
-     *  legacy callers retain world-px semantics until they wire a view. */
-    getView?: () => View;
-    /** Body hit-test for starting a move. Return id(s) to drag, or `null` to
-     *  fall through to `onTapEmpty`. */
-    pickEvery?: (worldX: number, worldY: number) => string | string[] | null;
-    /** Selection api (see {@link SelectionApi}). When supplied, the hook wires
-     *  selection-driven defaults: `onBodyHit` defaults to `selection.applyClick`
-     *  for the first hit id, `onTapEmpty` defaults to `selection.clear`, and
-     *  body-drag promotes-then-drags (clicking an unselected obj selects it
-     *  first, then drags the resulting selection; clicking a selected obj
-     *  drags the entire selection). Explicit callbacks override these defaults. */
-    selection?: SelectionApi;
-    /** Per-id bounds lookup. Combined with `selection`, defaults `resizeTarget`
-     *  to single-selection bounds when `resizeTarget` is not explicitly passed. */
-    boundsOf?: (id: string) => Bounds | null;
-    /** Called whenever a body hit occurs. Fires regardless of whether `move` is
-     *  wired — selection-only callers still receive notifications. */
-    onBodyHit?: (ids: string[], ctx: PointerGestureCallbackCtx) => void;
-    /** Called when the pointer hits neither a handle nor a body. Defaults to
-     *  `selection.clear()` when `selection` is supplied. */
-    onTapEmpty?: (ctx: PointerGestureCallbackCtx) => void;
-    /** Optional debug sink for the overlay subsystem. When supplied, body
-     *  hit-test results record one `recordHitbox(id, 'body', rect)` per id
-     *  that `pickEvery` returns — visualises which body shapes the kit
-     *  evaluated as hit. Tree-shakes when omitted (optional-chain). */
-    debug?: DebugSink;
-}
-/**
- * Pointer-event dispatcher that wires `useMove` + `useResize` to a canvas.
- * Owns the four `onPointer*` handlers, modifier extraction, world-coord
- * conversion, pointer capture, and the handle-vs-body dispatch decision.
- *
- * Caller still owns selection state, what counts as a body, and which
- * object (if any) is currently resizable. Pass a `selection` from
- * {@link useSelection} to opt into the standard click-promote-drag flow
- * with no extra wiring.
- *
- * Spread the returned bindings onto a `<canvas>`:
- * ```tsx
- * const bindings = usePointerGestures({ move, resize, pickEvery, selection });
- * return <canvas ref={canvasRef} {...bindings} />;
- * ```
- */
-declare function usePointerGestures<TMovePose, TResizePose>(options: UsePointerGesturesOptions<TMovePose, TResizePose>): PointerGestureBindings;
-
-/**
- * Identity helper for declaring a `Tool`. Exists for TypeScript inference:
- * passing the spec directly to a generic site loses `TScratch` inference, so
- * authors would have to spell out the type argument.
- *
- *   const pen = defineTool({
- *     id: 'pen',
- *     initScratch: () => ({ anchors: [] as Point[] }),
- *     drag: { onMove: (e, ctx) => { ctx.scratch.anchors.push(...); return 'claim'; } },
- *   });
- */
-declare function defineTool<TScratch = undefined>(spec: Tool<TScratch>): Tool<TScratch>;
-
 interface UseToolsOptions {
     /** Initial active-slot tool id. Must exist in `registry`. */
     active: string;
@@ -3586,40 +2002,17 @@ interface UseToolsOptions {
     registry: Record<string, AnyTool>;
     /** Always-on tools — listen continuously regardless of active slot. */
     ambient?: AnyTool[];
-    /** Optional fallback tool consulted ONLY for `pointer.onClick` when the
-     *  active tool's click handler returns `'pass'` (or has no handler).
-     *  Lets a non-select tool stay active while unhandled clicks fall through
-     *  to the select tool for click-to-select. Not consulted for pointerdown,
-     *  drag, keyboard, wheel, or dblTap. */
-    fallback?: AnyTool;
-    /** Per-event base ctx supplier. `<Canvas>` wires this to inject world
-     *  coords, modifiers, selection, adapter, applyOps. Tests can supply
-     *  a stub. Optional — the dispatcher works with a default empty ctx
-     *  for tests that don't need the wiring. */
-    getCtx?: (overrides?: {
-        clientX?: number;
-        clientY?: number;
-        modifiers?: {
-            alt: boolean;
-            shift: boolean;
-            meta: boolean;
-            ctrl: boolean;
-        };
-    }) => Omit<ToolCtx, 'scratch'>;
-    /** Optional scene hit-test for populating `ctx.target` on pointer events.
-     *  `<Canvas>` wires this from the effective `pickEvery` + adapter. Tests
-     *  may supply a stub; omit for the always-empty fallback. */
-    getNodeAtPoint?: ToolsDispatcherOptions['getNodeAtPoint'];
 }
 interface ToolsApi {
     /** Current active-slot tool id. */
     active: string;
-    /** Set the active-slot tool. Cancels any in-flight gesture. */
+    /** Set the active-slot tool. The gesture dispatcher watches the active
+     *  tool and cancels any in-flight handle itself. */
     setActive: (id: string) => void;
     /** Currently hotkey-engaged tool id (or `null`). Derived as the top of
      *  the hotkey stack for backwards compat with the pre-stack API. */
     hotkeyEngaged: string | null;
-    /** Engage a hotkey-slot tool by id. No-op if a gesture is in flight. */
+    /** Engage a hotkey-slot tool by id. */
     engageHotkey: (id: string) => void;
     /** Disengage the hotkey-slot tool, if any. */
     disengageHotkey: () => void;
@@ -3627,13 +2020,6 @@ interface ToolsApi {
     ambient: readonly AnyTool[];
     /** Full registry — for userland UI (palette buttons, etc.). */
     registry: Readonly<Record<string, AnyTool>>;
-    /** The dispatcher `<Canvas>` wires to its DOM events. */
-    dispatcher: ToolsDispatcher;
-    /** Increments whenever an in-flight gesture starts, transitions phase, or
-     *  ends. Consumers (e.g. `<Canvas>` cursor resolution) include this in
-     *  their render deps to re-evaluate derived state on real DOM events
-     *  rather than waiting for an unrelated re-render. */
-    gestureTick: number;
     /** Returns true if a tool with the given id is in the registry or ambient list. */
     has(id: string): boolean;
     /** All overlay layers from currently-engaged tools (active slot, hotkey
@@ -3643,7 +2029,12 @@ interface ToolsApi {
     getActiveOverlays(): RenderLayer<unknown>[];
 }
 /**
- * Manages the active tool, hotkey slot, and gesture dispatcher.
+ * Manages the active tool and hotkey slot.
+ *
+ * It used to also own a dispatcher: `useTools` constructed the tool-routing
+ * dispatcher and `<Canvas>` pumped DOM events into it. Input now belongs
+ * entirely to `useGestureDispatcher`, so what's left here is slot state plus
+ * the overlay roll-up.
  *
  * Requires `<ActiveToolContextProvider>` (or `<WeaselProvider>` /
  * `<SceneCanvas>`, which mount one internally) in scope: active/hotkey state
@@ -3664,10 +2055,20 @@ interface UseKeybindingsOptions {
      *  `tools.active` was when the hook first ran (i.e. the initial active
      *  tool). Pass `null` to disable Escape-returns-to-default behavior. */
     defaultTool?: string | null;
+    /**
+     * Gate for keyboard tool activation: return false to refuse a tool the
+     * active mode doesn't allow. `<SceneCanvas>` wires this from
+     * `getActiveMode` + each tool's `capabilities`, using the same predicate
+     * `ToolPalette` uses to grey a button out — so the grey-out becomes a
+     * guarantee rather than a hint.
+     *
+     * Omit for consumers with no mode registry: every tool stays activatable.
+     */
+    isToolEligible?: (toolId: string) => boolean;
 }
 declare function useKeybindings(tools: ToolsApi, options?: UseKeybindingsOptions): void;
 
-type ToolPrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color';
+type ToolPrefKind = 'number' | 'boolean' | 'string' | 'enum' | 'color' | 'paint';
 interface ToolPrefBase<K extends string, Value> {
     kind: K;
     /** Human-readable label. */
@@ -3734,7 +2135,22 @@ interface ToolPrefColor extends ToolPrefBase<'color', string> {
  */
 interface ToolPrefCustom extends ToolPrefBase<string, unknown> {
 }
-type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor;
+/**
+ * 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
+ * than a hex string.
+ *
+ * Addressing `…fill.color` instead reads `undefined` off a gradient (so the
+ * control shows its default and claims the text is black) and writes a
+ * hybrid `{ fill: 'gradient', stops, color }` that the renderer's structural
+ * `'color' in paint` checks then paint flat solid. The union has to be
+ * edited as a union.
+ */
+interface ToolPrefPaint extends ToolPrefBase<'paint', unknown> {
+    /** Offer an opacity control alongside the color. */
+    alpha?: boolean;
+}
+type ToolPref = ToolPrefNumber | ToolPrefBoolean | ToolPrefString | ToolPrefEnum | ToolPrefColor | ToolPrefPaint;
 /** Built-in or app-defined leaf. */
 type ToolPrefLeaf = ToolPref | ToolPrefCustom;
 /** Nestable group: branch nodes a tool can use to organize its prefs. */
@@ -3744,61 +2160,7 @@ interface ToolPrefGroup {
     children: Record<string, ToolPrefLeaf | ToolPrefGroup>;
 }
 
-interface InsertOverlayStyle {
-    fill?: string;
-    stroke?: string;
-    dash?: number[];
-    lineWidth?: number;
-}
-
-interface UseInsertToolOptions<TPose, TNode extends {
-    id: string;
-} = {
-    id: string;
-}> extends UseInsertOptions<TPose, TNode> {
-    overlayStyle?: InsertOverlayStyle;
-    /** Hit-test gate consulted before insertion. On hit, selects via
-     *  ctx.selection.set and skips both the click and drag paths. */
-    hitExisting?: (point: {
-        x: number;
-        y: number;
-    }) => string | string[] | null;
-}
-/** Drag-to-insert Tool. The legacy `useInsert` hook is
- *  no longer consumed here — the gesture is owned end-to-end by the
- *  dispatcher's `insertAction` (see `src/interactions/actions/defaults/insert.ts`),
- *  which requires the `insert` dep. `SceneCanvas` registers that dep via
- *  `useInsertDepSource`; consumers using bare `<Canvas>` must wire it themselves.
- *
- *  Note: this tool is now a thin declarative wrapper — no local route-table
- *  drag handler, no local insert overlay layer, no click-to-insert path.
- *  Live-preview marquee and click-to-insert are dispatcher-side features
- *  deferred to a later phase (see insertAction's "What this does NOT wire"
- *  comment). The `overlayStyle` / `hitExisting` / `pointInsert` options
- *  remain on the option surface for forward-compat but are currently
- *  ignored. */
-declare function useInsertTool<TNode extends {
-    id: string;
-}, TPose>(_adapter: InsertAdapter<TNode>, _options?: UseInsertToolOptions<TPose, TNode>): Tool<undefined>;
-
-/** Legacy style hooks for the area-select marquee. The dispatcher
- *  overlay layer (`useDispatcherOverlayLayer`) now owns marquee paint; this
- *  type is retained on the option surface for source-compat with callers
- *  threading it through. */
-interface AreaSelectOverlayStyle {
-    fill?: string;
-    stroke?: string;
-    dash?: number[];
-    lineWidth?: number;
-}
-/** Legacy style hook for the move ghost. The preview-ghost layer
- *  renders moved silhouettes via `drawOne` now. Retained for source-compat. */
-interface MoveOverlayStyle {
-    ghostAlpha?: number;
-}
-interface UseSelectToolOptions<TNode extends {
-    id: string;
-}, TPose> {
+interface UseSelectToolOptions<TPose> {
     /** Return ids of all objects whose painted body covers (worldX, worldY).
      *  Order doesn't matter — the tool collapses parent/child overlap via
      *  `pickTopMostHit`. When omitted, defaults to a rect AABB-vs-point scan
@@ -3809,45 +2171,60 @@ interface UseSelectToolOptions<TNode extends {
     /** Optional alt-aware selection-update hit returning the single id the
      *  click should act on. */
     pickBest?: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
-    /** Return the world-space bounds of `id`, or null if not found. */
-    boundsOf?: (id: string) => Bounds | null;
     /** Project a pose to its AABB. Default: identity. */
     poseBounds?: (pose: TPose) => Bounds;
+    /**
+     * How the default `pickEvery` decides a **leaf** node covers the pointer.
+     * Ignored when `pickEvery` is supplied.
+     *
+     * - `'aabb'` (default) — the pose rect. Cheap, and the historical behavior:
+     *   a click anywhere in the bounding box selects the node.
+     * - `'silhouette'` — the pose rect as a pre-test, then the ink the painter
+     *   lays down: `findShapeSilhouette` filled or not per the painter's `ink`,
+     *   plus its outline widened by the stroke half-width and `pickTolerance`.
+     *   A click inside the bounding box but outside the drawn shape misses —
+     *   the concave notch of a star, the corner outside an ellipse, the blank
+     *   half of a text box — while a click on the thin outline of an unfilled
+     *   shape hits.
+     *
+     * Container nodes already consult their silhouette unconditionally (it is
+     * how their clip is derived); this extends the same test to leaves. Not the
+     * default because it changes what a click selects for every existing
+     * consumer, and a painter with no `silhouette` is unaffected either way —
+     * it falls back to the AABB.
+     */
+    leafPicking?: 'aabb' | 'silhouette';
+    /**
+     * Grab slop around a shape's outline, in **world** units. Default 0.
+     *
+     * Only consulted under `leafPicking: 'silhouette'`. World units because
+     * this hook has no view; `<SceneCanvas>` takes a screen-pixel figure
+     * (`geometry.pickTolerancePx`) and divides by scale on its own pick path.
+     * Without some slop a hairline outline is an unhittable target.
+     */
+    pickTolerance?: number;
     /** Move-action options. The move gesture is dispatcher-routed,
      *  so only `behaviors` is consumed here — threaded into the move binding's
      *  `opts.behaviors`. Other `UseMoveOptions` fields are accepted for API shape
      *  but not read by this tool. */
     move?: UseMoveOptions<TPose>;
-    /** Legacy `useAreaSelect` options. Ignored now —
-     *  `areaSelectAction` configuration moved to the action registration. */
-    areaSelect?: unknown;
+    /**
+     * When this returns true, a Shift/Meta extend-click must NOT change the
+     * node selection.
+     *
+     * `<SceneCanvas>` wires it to "a path is in anchor-edit mode", where
+     * Shift-click means "add this anchor to the anchor selection". Without
+     * the lock the same click also toggles the edited node out of the node
+     * selection, and the `editAnchors` dep treats that as the edit target
+     * disappearing — so multi-selecting anchors silently exited edit mode.
+     *
+     * Only extend-clicks are locked. A plain click still re-selects, so
+     * clicking a different node exits edit mode as usual.
+     */
+    extendClickLocked?: () => boolean;
     /** Optional debug sink. Reserved for future overlay/affordance hitbox
      *  recording. */
     debug?: DebugSink;
-    /** Style for the area-select marquee. Pre-14e wired the legacy overlay;
-     *  after T3 it's consumed by the dispatcher overlay layer via
-     *  `useDispatcherOverlayLayer`'s `style` arg (not by this tool). Retained
-     *  for option-surface compat. */
-    areaSelectOverlayStyle?: AreaSelectOverlayStyle;
-    /** Style for the move ghost. Pre-14e wired the legacy overlay's alpha;
-     *  preview-ghost layer alpha now lives in `usePreviewGhostLayer`. */
-    moveOverlayStyle?: MoveOverlayStyle;
-    /** Consumer's draw function for ghost objects. Pre-14e the select tool
-     *  invoked this from its own overlay; the preview-ghost layer now calls
-     *  the scene slot's `drawOne` directly, so this option is no longer in
-     *  the runtime path. */
-    drawGhost?: (obj: TNode | null, pose: TPose, view: {
-        x: number;
-        y: number;
-        scale: {
-            x: number;
-            y: number;
-        };
-    }) => DrawCommand[];
-    /** Object lookup paired with `drawGhost`. Pre-14e runtime hook; vestigial. */
-    getNode?: (id: string) => TNode | null;
-    /** Returns the live selection ids. */
-    getSelection?: () => readonly string[];
     /** Reparent-on-drop behavior for drag-to-move. `'off'` (default)
      *  preserves translate-only commits. `'top'` lands the moved nodes at
      *  the top of the container under the drop point. `'above'` lands them
@@ -3855,33 +2232,16 @@ interface UseSelectToolOptions<TNode extends {
      *  semantics when the hit is itself a container). Requires the
      *  `nodeAtPoint` dep to be registered (sourced by `<SceneCanvas>`). */
     reparentOnDrop?: 'off' | 'top' | 'above';
-    /** Optional double-tap hook. */
-    onDoubleTap?: (args: {
-        worldX: number;
-        worldY: number;
-        ids: string[];
-        event: PointerEvent;
-    }) => void;
 }
 /** Intersection of the move + area-select adapter interfaces.
  *  Resize / rotate adapters moved to `useResizeTool` / `useRotateTool`. */
 type SelectAdapter<TNode extends {
-    id: string;
-}, TPose> = MoveAdapter<TNode, TPose> & AreaSelectAdapter;
-/** @internal */
-type SelectScratch = {
-    kind: 'idle';
-} | {
-    kind: 'move';
-    ids: string[];
-    deferredClickId: string | null;
-} | {
-    kind: 'area';
-};
+    id: string;
+}, TPose> = MoveAdapter<TNode, TPose> & AreaSelectAdapter;
 /** Active-slot Tool:
- *  - pointerDown classifier still runs the tool's own pickBest/pickEvery
- *    so click semantics (selection replace, extend, deferred collapse) are
- *    preserved across the same code path.
+ *  - `select.pick` classifies the press (pointerDown) — it runs the tool's own
+ *    pickBest/pickEvery so click semantics (selection replace, extend,
+ *    deferred collapse) live in one place.
  *  - drag is owned exclusively by the dispatcher via `Tool.bindings`
  *    (selected-body → moveAction, rotate-handle → rotateAction, handle:* →
  *    resizeAction, empty → areaSelectAction, click on empty → clearSelection).
@@ -3891,81 +2251,7 @@ type SelectScratch = {
  */
 declare function useSelectTool<TNode extends {
     id: string;
-}, TPose>(adapter: SelectAdapter<TNode, TPose>, options: UseSelectToolOptions<TNode, TPose>): Tool<SelectScratch>;
-
-/** @internal */
-interface HitAdapter<TNode extends {
-    id: string;
-}, TPose> {
-    getNode: (id: string) => TNode | undefined;
-    getNodes: () => TNode[];
-    getPose: (id: string) => TPose;
-    getParent: (id: string) => string | null;
-}
-interface NestedHitOpts<TNode extends {
-    id: string;
-}, TPose> {
-    /** Compose a child's local pose into world coords given its parent's world
-     *  pose. Same shape as `composeRectPose` (the default expectation). */
-    composePose: (parent: TPose, child: TPose) => TPose;
-    /** Derive an axis-aligned bounding rect from a (world-space) pose. Default
-     *  reads `x` / `y` / `width` / `height` straight off the pose (matches
-     *  `RectPose`). Override for non-rect poses (e.g. paths). */
-    poseBounds?: (pose: TPose) => Bounds;
-    /** Predicate for "this object is a nesting parent body". The leaf scan
-     *  skips objects for which this returns true so a click on a parent's
-     *  painted body resolves to a child leaf, not the parent itself. Default:
-     *  never (treat every object as hittable). */
-    isGroup?: (id: string, obj: TNode | undefined) => boolean;
-}
-interface NestedHitTester {
-    /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a
-     *  casual click selects the whole top-level ancestor. Returns `null` on
-     *  empty space. */
-    pickOutermost: (worldX: number, worldY: number) => string | null;
-    /** Alt-aware selection-update pick. Without `alt`, returns the outermost
-     *  ancestor (same as `pickOutermost`). With `alt`, returns one level
-     *  deeper than the deepest currently-selected ancestor in the leaf's
-     *  chain — repeated alt-clicks step ancestor → descendant → leaf. With
-     *  `alt` and nothing in the chain selected, jumps straight to the leaf.
-     *  Plug into `useSelectTool({ pickBest })`. */
-    pickBest: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
-}
-declare function nestedHitTester<TNode extends {
-    id: string;
-}, TPose>(adapter: HitAdapter<TNode, TPose>, opts: NestedHitOpts<TNode, TPose>): NestedHitTester;
-
-/** Adapter contract: SelectAdapter (Move + AreaSelect) plus the lookups
- *  `nestedHitTester` needs (`getParent` + the existing `getNode`/`getNodes`/`getPose`). */
-type NestedSelectAdapter<TNode extends {
-    id: string;
-}, TPose> = SelectAdapter<TNode, TPose> & {
-    getNode: (id: string) => TNode | undefined;
-    getNodes: () => TNode[];
-    getParent: (id: string) => string | null;
-};
-interface UseNestedSelectToolOptions<TNode extends {
-    id: string;
-}, TPose> extends NestedHitOpts<TNode, TPose>, Omit<UseSelectToolOptions<TNode, TPose>, 'pickBest'> {
-}
-/**
- * Convenience over `useSelectTool` for scenes with nesting. Builds a
- * `nestedHitTester` from `composePose` + `isGroup` and wires its `pickBest`
- * into the select tool — alt-clicks drill outermost ancestor → child → leaf
- * automatically. Casual clicks select the outermost ancestor.
- *
- * Equivalent to writing:
- *
- * ```tsx
- * const hitter = useMemo(() => nestedHitTester(adapter, { composePose, isGroup }), [adapter]);
- * const select = useSelectTool(adapter, { pickBest: (...args) => hitter.pickBest(...args) });
- * ```
- *
- * but with one fewer concept on the consumer surface.
- */
-declare function useNestedSelectTool<TNode extends {
-    id: string;
-}, TPose>(adapter: NestedSelectAdapter<TNode, TPose>, options: UseNestedSelectToolOptions<TNode, TPose>): ReturnType<typeof useSelectTool<TNode, TPose>>;
+}, TPose>(adapter: SelectAdapter<TNode, TPose>, options: UseSelectToolOptions<TPose>): Tool<null>;
 
 interface UseRotateToolOptions<TNode extends {
     id: string;
@@ -4036,7 +2322,10 @@ declare function useRotateTool<TNode extends {
  *    (resolve before calling) — this helper doesn't try to detect that.
  *
  * Pure sibling z-order without a parent/child relation is not resolved
- * here yet — see `docs/TODO.md`.
+ * here yet — see "Sibling z-order is unresolved in hit-picking" under
+ * Tools & gestures in `docs/TODO.md`. The shape it wants is an optional
+ * `getZIndex` / `compareZ` on the adapter below, composing with the
+ * parent/child collapse rather than replacing it.
  */
 interface PickTopMostHitAdapter {
     getParent?: (id: string) => string | null;
@@ -4098,40 +2387,16 @@ interface HandScratch {
  */
 declare function useHandTool(opts?: UseHandToolOptions): Tool<HandScratch | null>;
 
-interface UseTextToolOptions<TNode extends {
-    id: string;
-}> {
-    pointInsert: (point: {
-        x: number;
-        y: number;
-    }) => TNode | null;
-    commitInsert?: InsertAdapter<TNode>['commitInsert'];
-    hitExisting?: (point: {
-        x: number;
-        y: number;
-    }) => string | string[] | null;
-    minBounds?: {
-        width: number;
-        height: number;
-    };
-    marqueeStyle?: InsertOverlayStyle;
-}
-/** Text Tool. The legacy `useInsert` hook is dropped — drag-rect
- *  insertion is owned end-to-end by the dispatcher's `insertAction` (kind:
- *  'text'); click-on-selected-text-node enters edit mode via the
- *  `enterTextEdit` action.
- *
- *  Consumers must register both the `insert` dep (e.g. through `SceneCanvas`'s
- *  `useInsertDepSource`) and the `textEdit` dep (`enterTextEditAction`'s
- *  contract — see `src/interactions/actions/defaults/enterTextEdit.ts`).
- *
- *  Note: `pointInsert`, `hitExisting`, `marqueeStyle`, `minBounds` remain on
- *  the option surface for forward-compat but are currently ignored — they map
- *  onto dispatcher-side features that are wired through dep sources, not
- *  through the tool record. */
-declare function useTextTool<TNode extends {
-    id: string;
-}>(_options: UseTextToolOptions<TNode>): Tool<undefined>;
+/** Text tool. Drag-rect insertion is owned end-to-end by the dispatcher's
+ *  `insertAction` (kind: `'text'`); click-on-selected-text-node enters edit
+ *  mode via the `enterTextEdit` action.
+ *
+ *  Consumers must register both the `insert` dep (e.g. through
+ *  `SceneCanvas`'s `useInsertDepSource`) and the `textEdit` dep
+ *  (`enterTextEditAction`'s contract — see
+ *  `src/interactions/actions/defaults/enterTextEdit.ts`). Custom node
+ *  factories and hit gating belong on those deps, not on the tool. */
+declare function useTextTool(): Tool<undefined>;
 
 interface PinchZoomToolOpts {
     min?: number;
@@ -4147,51 +2412,13 @@ interface PinchZoomToolOpts {
  */
 declare function usePinchZoomTool(canvasRef: React.RefObject<HTMLCanvasElement | null>, view: View, setView: (v: View) => void, opts?: PinchZoomToolOpts): void;
 
-/**
- * Counts the path anchors used by the per-anchor coloring surface. An
- * "anchor" is the destination point of a path command: M, L, C, Q each
- * contribute one (the (x, y) where the pen ends up); Z contributes none
- * (it closes back to the subpath's first M). RectPath has four implicit
- * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.
- *
- * Consumers use this to size their per-anchor color array; the renderer
- * uses it to validate the array length in dev builds.
- */
-
-interface PenAnchor$1 {
-    x: number;
-    y: number;
-    inHandle?: {
-        x: number;
-        y: number;
-    };
-    outHandle?: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on
- * every `M` command; a subpath is closed iff it ends with `Z`.
- *
- * Cubic-segment control points become the outHandle of the previous anchor
- * and the inHandle of the next anchor. Quadratic segments are upgraded to
- * cubics (each control reused for both adjacent handles) — this loses no
- * geometry. Linear segments produce anchors with no handles.
- */
-declare function pathToAnchors(path: PolygonPath): {
-    anchors: PenAnchor$1[][];
-    closed: boolean[];
-};
-declare function countPathAnchors(path: Path): number;
-
 /**
  * In-progress pen anchor. `outHandle` is set when the anchor was placed via
  * click-drag (smooth anchor); undefined for click-placed corners.
  * `inHandle` is mirrored from the previous anchor's outHandle on segment
  * emission unless `altBroken` is set on that previous anchor.
  */
-interface PenAnchor {
+interface PenAnchor$1 {
     x: number;
     y: number;
     outHandle?: {
@@ -4207,57 +2434,32 @@ interface PenAnchor {
     altBroken?: boolean;
 }
 interface PenSubpath {
-    anchors: PenAnchor[];
+    anchors: PenAnchor$1[];
     closed: boolean;
 }
-/** Edit-mode state. `anchors` uses the kit's PenAnchor (committed/derived
- *  geometry); `altBroken` has no post-commit meaning and is correctly absent. */
-/** @internal */
-interface PenEditState {
-    objId: string;
-    anchors: PenAnchor$1[][];
-    closed: boolean[];
-    selectedAnchors: Set<string>;
-    activeHandle: {
-        sub: number;
-        anchor: number;
-        side: 'in' | 'out';
-    } | null;
-    dirty: boolean;
-    preConvert: {
-        path: unknown;
-        closed: boolean;
-        params: unknown;
-    } | null;
-    /** Snapshot of the path-as-it-was at the start of the current gesture
-     *  (drag, click, or nudge keystroke). Used as the `from` of the
-     *  SetPathOp emitted on gesture completion so each pushed entry rewinds
-     *  only its own gesture, not the whole edit session. Null between
-     *  gestures. */
-    gestureBaseline: {
-        path: unknown;
-        closed: boolean;
-        params: unknown;
-    } | null;
-    /** In-flight marquee rect (world-space). Null when not dragging. */
-    marquee: {
-        x0: number;
-        y0: number;
-        x1: number;
-        y1: number;
-        additive: boolean;
-    } | null;
-}
-/** Mutable scratch shared across pen-tool gestures. The hook keeps a stable
- *  reference to a single instance and `initScratch` returns it on every call,
- *  so click-by-click state survives gesture boundaries and the preview layer
- *  can read the same object. */
+/**
+ * Mutable scratch shared across pen-tool gestures. The hook keeps a stable
+ * reference to a single instance and `initScratch` returns it on every call,
+ * so click-by-click state survives gesture boundaries and the preview layer
+ * can read the same object.
+ *
+ * ## The pen creates paths and nothing else
+ *
+ * Reshaping an existing path is anchor editing: double-click a path to
+ * enter edit mode, then use the `editAnchors` / `insertPathAnchor` /
+ * `nudgeAnchors` / `deleteAnchors` / `marqueeAnchors` / `cutPathAtAnchor`
+ * Actions.
+ *
+ * The pen used to carry a second, private implementation of all of that,
+ * with its own scratch mode, hit-test override, overlay, and undo
+ * plumbing. It was reachable only through a `getPathObj` option whose
+ * contract required `pose.kind` to be `'polygon'` or `'rect'` — which no
+ * kit-created node has, including the ones the pen itself creates. So it
+ * was dead in every consumer while shadowing the live implementation, and
+ * the two had drifted. Its geometry now lives in
+ * `features/paths/anchorEdits.ts`, driven by those Actions.
+ */
 interface PenScratch {
-    /** Whether the pen is in create (draw new path) or edit (reshape existing
-     *  path) mode. Defaults to 'create'. */
-    mode: 'create' | 'edit';
-    /** Edit-mode state, populated when `mode === 'edit'`. Null in create mode. */
-    edit: PenEditState | null;
     finishedSubpaths: PenSubpath[];
     current: PenSubpath | null;
     cursor: {
@@ -4266,23 +2468,6 @@ interface PenScratch {
     } | null;
     draggingHandleAt: number | null;
     closeHintActive: boolean;
-    /** Pointer-down world coords + modifiers, captured on every pointer.onDown.
-     *  Used by drag.onStart (anchor lands at the down coords, not the
-     *  threshold-crossing coords) and by pointer.onClick. Internal. */
-    _pendingDown: {
-        worldX: number;
-        worldY: number;
-        alt: boolean;
-        shift: boolean;
-    } | null;
-    /** Timestamp + world coords of the most recent click, used to detect a
-     *  double-click on the last placed anchor (Illustrator convention for
-     *  open-finish). Internal. */
-    _lastClick: {
-        t: number;
-        x: number;
-        y: number;
-    } | null;
 }
 interface UsePenToolOptions<TPose> {
     /** Wrap a finished PolygonPath in the consumer's pose type. */
@@ -4293,9 +2478,6 @@ interface UsePenToolOptions<TPose> {
     adapter: {
         addNode: (pose: TPose) => string;
         setSelection: (ids: string[]) => void;
-        /** Apply an op batch (with optional history label). Required for pen-edit;
-         *  safe to omit if the consumer only uses create mode. */
-        applyOps?: (ops: Op[], label: string) => void;
     };
     /** Auto-select the new object after commit. Default `true`. */
     autoSelect?: boolean;
@@ -4329,33 +2511,6 @@ interface UsePenToolOptions<TPose> {
         x: number;
         y: number;
     };
-    /** Resolve a path obj from id. Returns the obj's path, closed flag, params,
-     *  and the tool that created it (used to decide whether the trapdoor applies).
-     *  Required when pen-edit is wanted; safe to omit if the consumer only uses
-     *  create mode (dblclick-to-edit will be a no-op). */
-    getPathObj?: (id: string) => {
-        path: PolygonPath | {
-            kind: 'rect';
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-        };
-        closed: boolean;
-        params: unknown;
-        tool: string;
-    } | null;
-}
-interface UsePenToolReturn {
-    tool: Tool<PenScratch>;
-    /**
-     * True when the pen is in edit mode (reshaping an existing path). Consumers
-     * should apply a CSS class like `pen-edit-active` to their canvas container
-     * when `isEditing` is true, to give users a visual cue that they're in edit
-     * mode (e.g. a subtle background tint). The kit does not own the DOM and
-     * ships no default stylesheet for this.
-     */
-    isEditing: boolean;
 }
 /**
  * Active-slot Tool: click + drag to build a `PolygonPath` Illustrator-style.
@@ -4367,12 +2522,9 @@ interface UsePenToolReturn {
  * discards. Shift constrains the placement-drag handle to 0/45/90/135°;
  * Alt during drag breaks the handle mirror for the next segment.
  *
- * @returns `{ tool, isEditing }` — the pen tool definition plus a reactive
- * `isEditing` boolean. Apply a CSS class like `pen-edit-active` to your canvas
- * container when `isEditing` is true for a visual cue. The kit owns no DOM and
- * ships no default stylesheet for this.
+ * Reshaping an existing path is not this tool's job — see {@link PenScratch}.
  */
-declare function usePenTool<TPose>(options: UsePenToolOptions<TPose>): UsePenToolReturn;
+declare function usePenTool<TPose>(options: UsePenToolOptions<TPose>): Tool<PenScratch>;
 declare namespace usePenTool {
     var prefs: {
         name: string;
@@ -4388,80 +2540,28 @@ declare namespace usePenTool {
     };
 }
 
-interface RectBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-interface UseRectToolOptions<TNode extends {
-    id: string;
-}> {
-    create: (bounds: RectBounds) => TNode | null;
-    label?: string;
-    minBounds?: {
-        width: number;
-        height: number;
-    };
-    overlayStyle?: InsertOverlayStyle;
-    /** Optional: snap world-space points to the active grid (or any other
-     *  snap target). Applied to every coord the gesture ingests, so both the
-     *  live overlay and the committed geometry use the snapped values. */
-    snapPoint?: (p: {
-        x: number;
-        y: number;
-    }) => {
-        x: number;
-        y: number;
-    };
-}
 /**
- * Drag-to-draw rectangle tool. The user drags a rect; on release the `create`
- * factory is called with the final bounds and the returned object is inserted
- * into the scene via an undoable op.
+ * Drag-to-draw rectangle tool.
  *
- * Role model for tools that create scene objects: uses `ctx.applyOps` +
- * `createInsertOp` directly rather than routing through adapter.commitInsert.
+ * The gesture is owned end-to-end by the dispatcher: the `drag` binding
+ * routes to `insertAction`, which tracks the live bounds, paints the
+ * preview through its `overlay()` surface, and commits via the `insert`
+ * dep on release. `<SceneCanvas>` sources that dep from
+ * `useInsertDepSource`; consumers wanting a custom node factory override
+ * the dep (`useDepSource('insert', …)`) rather than the tool.
+ *
+ * Grid snapping comes from the `snap` dep, also read by `insertAction` —
+ * see `SnapDep` in `interactions/actions/depSchema.ts`.
  */
-declare function useRectTool<TNode extends {
-    id: string;
-}>(options: UseRectToolOptions<TNode>): Tool<null>;
+declare function useRectTool(): Tool<null>;
 
-interface EllipseBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-interface UseEllipseToolOptions<TNode extends {
-    id: string;
-}> {
-    create: (bounds: EllipseBounds) => TNode | null;
-    label?: string;
-    minBounds?: {
-        width: number;
-        height: number;
-    };
-    overlayStyle?: InsertOverlayStyle;
-    /** Optional: snap world-space points to the active grid (or any other
-     *  snap target). Applied to every coord the gesture ingests, so both the
-     *  live overlay and the committed geometry use the snapped values. */
-    snapPoint?: (p: {
-        x: number;
-        y: number;
-    }) => {
-        x: number;
-        y: number;
-    };
-}
 /**
- * Drag-to-draw ellipse tool. The `create` factory receives the bounding
- * rect and returns the node to insert (consumer-defined shape — the kit
- * doesn't impose an ellipse geometry encoding here). Mirrors `useRectTool`.
+ * Drag-to-draw ellipse tool. Mirrors `useRectTool`: the `drag` binding
+ * routes to `insertAction`, which owns the live preview and commits
+ * through the `insert` dep. Alt toggles from-corner ⇄ from-center
+ * mid-drag via the action's live modifier read.
  */
-declare function useEllipseTool<TNode extends {
-    id: string;
-}>(options: UseEllipseToolOptions<TNode>): Tool<null>;
+declare function useEllipseTool(): Tool<null>;
 
 interface UseImageToolOptions {
     /** Image source for inserted nodes — a URL, a `blob:` URL, or a
@@ -4488,7 +2588,8 @@ interface UseEyedropperToolOptions {
      *  on a real hit; empty-click is a no-op in v1. */
     onPick: (color: string | null) => void;
     /** Map a node id to a color string, or `null` if the node has no color
-     *  to sample. Called on click with `ctx.target.id`. */
+     *  to sample. Called on click with the id of the topmost node under the
+     *  click point. */
     colorOf: (id: string) => string | null;
     /** Override the default `{ key: 'I' }` keybinding. Pass `null` to omit
      *  the keybinding entirely (palette-only or hotkey-only wiring). */
@@ -4504,6 +2605,10 @@ interface UseEyedropperToolOptions {
  *
  * Pure-read tool — does NOT mutate the scene. v1 is click-only; drag is
  * unbound (a future drag-to-sample option is additive).
+ *
+ * The node under the click comes from the `nodeAtPoint` dep, so an
+ * eyedropper in a consumer that never registered that dep samples nothing.
+ * `<SceneCanvas>` sources it from the same picker the rest of the kit hits.
  */
 declare function useEyedropperTool(opts: UseEyedropperToolOptions): Tool<null>;
 
@@ -4511,39 +2616,19 @@ interface LinePoint {
     x: number;
     y: number;
 }
-interface UseLineToolOptions<TNode extends {
-    id: string;
-}> {
-    create: (a: LinePoint, b: LinePoint) => TNode | null;
-    label?: string;
-    minLength?: number;
-    /** Optional: snap world-space points to the active grid (or any other
-     *  snap target). Applied to every coord the gesture ingests, so both the
-     *  live overlay and the committed endpoints use the snapped values.
-     *
-     *  Order with modifiers: the Shift-constrain-to-15° branch runs on raw
-     *  coords first, then the result is snapped — this preserves the user
-     *  intent (constrain the angle), then aligns the endpoint to grid. */
-    snapPoint?: (p: LinePoint) => LinePoint;
-}
-/** @internal */
-interface LineScratch {
-    start: LinePoint;
-    current: LinePoint;
-    /** Modifier snapshot captured on the latest move — used by the live
-     *  overlay so the ghost reflects shift-snap / alt-mirror in real time. */
-    shift: boolean;
-    alt: boolean;
-}
 /**
- * Click-down → drag → release-place line tool. Commits via the consumer's
- * `create` factory called with the two endpoints. Modifiers:
+ * Click-down → drag → release line tool. The `drag` binding routes to
+ * `insertAction`, which owns the live preview and commits through the
+ * `insert` dep with `{ kind: 'line', a, b }` endpoints (not the AABB
+ * diagonal), so the drag direction is preserved.
+ *
+ * Modifiers are applied by `insertAction`:
  *   - shift: constrain to 15° increments
- *   - alt: mirror end around start (drag is treated as half-line)
+ *   - alt: mirror the end around the start (the drag is treated as a
+ *     half-line) — the line-specific reading of the action's
+ *     corner ⇄ center origin toggle
  */
-declare function useLineTool<TNode extends {
-    id: string;
-}>(options: UseLineToolOptions<TNode>): Tool<LineScratch | null>;
+declare function useLineTool(): Tool<null>;
 
 /** Option surface for the `lasso-select` action.
  *
@@ -4652,54 +2737,31 @@ declare function useStarTool<TNode extends {
  *  `pressure: 0.5` while a button is held, `0` otherwise (per the Pointer
  *  Events spec), so a consumer that wants stylus-only modulation should
  *  gate on `pointerType` from the originating event — the kit exposes
- *  `usePointerStylus()` for that. */
+ *  `usePointerStylus()` for that.
+ *
+ *  The dispatcher accumulates these on the drag trail and hands the whole
+ *  array to `insertAction`, which forwards it as the `pencil` insert
+ *  extras' `samples`. A consumer that wants pressure-driven
+ *  `Stroke.vertexWidths` reads it off the samples in its own `insert` dep
+ *  (`useDepSource('insert', …)`) — see `apps/site/demos/VertexWidthsDemo.tsx`.
+ */
 interface PencilPoint {
     x: number;
     y: number;
-    /** 0..1. Optional for backward compat — older `create` factories that
-     *  treat samples as `{x,y}` keep working. */
+    /** 0..1. Absent when the originating event carried no pressure. */
     pressure?: number;
     /** Degrees, ±90. Zero for mouse/touch. */
     tiltX?: number;
     /** Degrees, ±90. Zero for mouse/touch. */
     tiltY?: number;
-    /** Per-sample stroke width, populated when the tool's
-     *  `pressureToWidth` option is set. Consumers can read these widths to
-     *  build a parallel `vertexWidths` array for a tapered stroke. */
-    width?: number;
-}
-interface UsePencilToolOptions<TNode extends {
-    id: string;
-}> {
-    create: (path: PolygonPath, opts: {
-        closed: boolean;
-        widths?: number[];
-    }) => TNode | null;
-    label?: string;
-    tolerance?: number;
-    closeThreshold?: number;
-    /** Optional callback that maps a captured sample to a stroke width.
-     *  When provided, every PencilPoint gets a `width` field and the
-     *  consumer's `create` factory also receives `widths`: one width per
-     *  output bezier anchor, ready to drop into `Stroke.vertexWidths`. The
-     *  default `pressureToWidth(p, { minWidth, maxWidth, gamma })` helper
-     *  is a common drop-in. */
-    pressureToWidth?: (sample: PencilPoint) => number;
-}
-/** @internal */
-interface PencilScratch {
-    samples: PencilPoint[];
 }
 /**
- * Freehand pencil tool. Captures pointer samples through the drag, then
- * runs `schneiderFit` on release to produce a cubic-Bezier path. If the
- * first and last samples are within `closeThreshold` world units, the
- * `create` factory receives `{ closed: true }` so the consumer can close
- * its path.
+ * Freehand pencil tool. The `drag` binding routes to `insertAction`,
+ * which accumulates the pointer trail and commits it as
+ * `{ kind: 'pencil', samples }`. The kit's default `insert` dep runs
+ * `schneiderFit` over the samples to produce a cubic-Bezier path.
  */
-declare function usePencilTool<TNode extends {
-    id: string;
-}>(options: UsePencilToolOptions<TNode>): Tool<PencilScratch | null>;
+declare function usePencilTool(): Tool<null>;
 
 /** Standard slot names — render in this canonical order.
  *  `cellHighlight` is internal: emitted from the `grid` slot's nested
@@ -4743,9 +2805,24 @@ interface CanvasExtensionApi {
     readonly element: HTMLCanvasElement | null;
     requestRedraw(): void;
     /** Register an externally-owned RenderLayer. The layer participates in the
-     *  draw stack and, if it implements `hitTest`, in the dispatcher's hit-test
-     *  pipeline (see `src/tools/dispatcher.ts`'s `getHitTestContext`). */
+     *  draw stack and, if it implements `hitTest`, in {@link hitTestExtras}. */
     registerLayer(layer: RenderLayer<unknown>): () => void;
+    /**
+     * Hit-test the registered layers (topmost-first, last-registered wins) at a
+     * world-space point. Returns the id of the layer that claimed the point and
+     * whatever its `hitTest` resolved, or `null` when none did.
+     *
+     * `<SceneCanvas>` folds this into the `affordanceAt` thunk it hands the
+     * gesture dispatcher — ahead of the kit's own selection chrome, since
+     * registered layers draw on top — so a hit surfaces to actions as an
+     * `AffordanceHit` with kind `layer:<id>` and the binding's `initialScratch`
+     * as its `payload`. A layer's owner binds a `kindOf` predicate on that kind
+     * to claim the gesture; see `@weasel-js/hud` for the worked example.
+     */
+    hitTestExtras(worldX: number, worldY: number): {
+        layerId: string;
+        binding: AffordanceBinding;
+    } | null;
     /** Feed external content into the ingestion pipeline imperatively — the
      *  same content-handler registry that OS drop and clipboard paste hit.
      *  `input` may be raw `File[]` (e.g. from `openFilePicker`) or
@@ -4775,6 +2852,52 @@ interface SceneCanvasApi extends CanvasExtensionApi {
     }): void;
 }
 
+/**
+ * Union math behind `CanvasHelpers.getGestureBounds()`.
+ *
+ * `getGestureBounds` answers "where is the thing the user is dragging right
+ * now, in total?" — a question every other lookup on `CanvasHelpers` can't
+ * answer because they're keyed by node id, and a drag-to-insert has no node
+ * yet. Canvas collects the parts (preview bounds per in-flight id, plus any
+ * id-less nascent-insert AABBs) and folds them here.
+ *
+ * Kept free of tool / dispatcher types so it stays a pure geometry fold that
+ * both `<Canvas>` and its tests can call without a render.
+ */
+
+/**
+ * Everything `<Canvas>` needs to know about in-flight gestures that it can't
+ * see for itself.
+ *
+ * `<Canvas>` is deliberately dispatcher-agnostic — it owns the union math and
+ * the `CanvasHelpers` contract, but the live gesture state lives in the
+ * gesture dispatcher that `<SceneCanvas>` creates. This is the one seam
+ * between them (`createGestureSource` in `SceneCanvas/dispatcherGestureBounds.ts`
+ * builds it); bare `<Canvas>` consumers leave it unwired and get the
+ * "no gesture in flight" answers.
+ *
+ * @public
+ */
+interface GestureSource {
+    /**
+     * Ids the in-flight gesture is previewing, so the canvas can resolve each
+     * one's preview bounds.
+     *
+     * Wider than `previewIdsExtra`, which honors `previewHidesSource: false`
+     * because its job is deciding whose committed paint to suppress: a clone
+     * ghost hides nothing yet still proposes content at the drag target.
+     */
+    ids(): Iterable<string> | null;
+    /** World-space AABBs of in-flight gestures that have no scene id at all —
+     *  a drag-to-insert, pre-commit. */
+    bounds(): Iterable<Bounds> | null;
+    /** Fires whenever the above can have changed. See
+     *  `CanvasHelpers.subscribeGestures` for the published guarantee. */
+    subscribe(fn: () => void): () => void;
+    /** Monotonic counter bumped on the same events `subscribe` fires on. */
+    getVersion(): number;
+}
+
 /**
  * Selection overlay primitives — render layers for drawing selection
  * outlines and corner resize handles in world space.
@@ -5146,16 +3269,6 @@ interface CanvasProps<TNode extends {
      * force-graph renderers or read-only viewers).
      */
     selection?: SelectionApi;
-    /**
-     * Fires when the canvas receives a pointer event that the tool dispatcher
-     * did not handle (no active gesture was started on pointerdown, or the
-     * pointer was released without a gesture). Useful for "click on background
-     * clears selection" — `<SceneCanvas>` wires this to `selection.clear()`.
-     *
-     * The listener is only installed when this callback is supplied. Omitting
-     * the prop means no background-click listener is registered.
-     */
-    onBackgroundClick?: () => void;
     /**
      * Pose↔bounds projection for non-rect `TPose` types. When supplied, drives
      * the default `boundsOf` fallback and the selection-overlay bounds source so
@@ -5291,6 +3404,14 @@ interface CanvasProps<TNode extends {
      * through geometry.getBounds(pose).
      */
     previewBoundsExtra?: (id: string) => Bounds | null;
+    /**
+     * In-flight gesture state `<Canvas>` can't see for itself. Backs the
+     * `getGestureBounds` / `subscribeGestures` / `getGestureVersion` trio on
+     * `helpersRef`; wired by `<SceneCanvas>` from the gesture dispatcher
+     * (`createGestureSource`). Leaving it unwired is fine — those three then
+     * 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
@@ -5346,19 +3467,6 @@ interface CanvasProps<TNode extends {
      * HUD shows the same best-candidate SceneCanvas would pick.
      */
     pickBest?: (worldX: number, worldY: number) => string | null;
-    /** Resolves a single hit (id + kind + pose + data) at world coords for the
-     *  tool dispatcher. `<SceneCanvas>` synthesizes this from its node-kind
-     *  registry and adapter via `makeGetNodeAtPoint`. When omitted, the
-     *  dispatcher receives no hit info and tool routing based on `target.kind`
-     *  will not fire. Bare-`<Canvas>` consumers that need kind-based routing
-     *  should build this with `makeGetNodeAtPoint`. */
-    getNodeAtPoint?: (worldX: number, worldY: number) => {
-        id: string;
-        kind: string;
-        pose: unknown;
-        data: unknown;
-        meta?: Record<string, unknown>;
-    } | null;
     /**
      * Optional mode-owned decoration layer. When supplied, Canvas inserts it
      * between the scene-render slot and the tool-overlay slot so decoration
@@ -5384,16 +3492,73 @@ interface CanvasProps<TNode extends {
      * predicate that closes over per-frame `ChromeCtx`. Omit to leave
      * 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;
+    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.
+     *
+     * 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. */
@@ -5863,27 +4028,6 @@ interface UseRotateOptions<TPose> {
     pivot?: 'each' | 'union';
 }
 
-/** Option surface for the `area-select` action.
- *
- *  Lives in a sibling file (not `areaSelect.ts`) so the type contract stays
- *  stable even after the legacy `useAreaSelect` hook is gone.
- *  Consumers should import from here directly; `areaSelect.ts`
- *  re-exports the same symbol for back-compat. */
-
-interface UseAreaSelectOptions {
-    behaviors?: AreaSelectBehavior[];
-    /** When set, overrides any behavior's `defaultTransient`. Default: behaviors decide. */
-    transient?: boolean;
-    /** Label used when transient is false and the hook falls back to applyOps. Default 'Area select'. */
-    label?: string;
-    onGestureStart?: () => void;
-    onGestureEnd?: (committed: boolean) => void;
-    /** Optional debug sink. When supplied, records the in-progress marquee
-     *  rectangle as a `bounds` entry under the synthetic id `'area-select'`
-     *  on every move. Tree-shakes via optional-chain when omitted. */
-    debug?: DebugSink;
-}
-
 /**
  * Built-in shape tool ids handled by `useBuiltinShapeTools`. Each maps to a
  * kit tool hook + a default `create` that produces a leaf node compatible
@@ -5907,10 +4051,13 @@ interface BuiltinToolOptions {
         mode?: LassoHitMode;
     };
     /** Snap world-space points to the active grid (or any other snap target).
-     *  Applied by the rect / ellipse / line tools to every coord they ingest,
-     *  so both the live overlay and the committed geometry use snapped
-     *  values. polygon / star / pencil / text go through the dispatcher's
-     *  `insertAction` descriptor, which doesn't yet honor this hook. */
+     *
+     *  Registered as the `snap` dep, which `insertAction` applies to the
+     *  drag start and current point — so the live preview and the committed
+     *  geometry agree — and which the pen tool reads for its own anchor
+     *  placement. Covers every drag-to-insert tool (rect / ellipse / line /
+     *  polygon / star / text); freehand pencil samples are deliberately left
+     *  unsnapped. */
     snapPoint?: (p: {
         x: number;
         y: number;
@@ -6081,7 +4228,13 @@ interface NodeShapeEntry<TData = unknown, TPose = unknown> {
     matches(node: Node$1<TData, string, TPose>): boolean;
     /** Emits the draw commands for the node's primary visual. `ctx` is an
      *  optional per-call paint context (see `NodePaintCtx`); painters that
-     *  don't need it can keep a two-argument signature. */
+     *  don't need it can keep a two-argument signature.
+     *
+     *  **The returned array belongs to the painter.** Callers must treat it as
+     *  immutable and copy before appending — a painter is free to memoize its
+     *  command list (`kit:shape` and `kit:path` do), and an in-place `push`
+     *  would grow that list on every frame. `defaultDrawOne` copies before
+     *  adding its label overlay for exactly this reason. */
     paint(node: Node$1<TData, string, TPose>, pose: TPose, ctx?: NodePaintCtx): DrawCommand[];
     /** Optional: derive the node's silhouette path from its pose.
      *  Used by clipping (when the container has no explicit
@@ -6089,6 +4242,26 @@ interface NodeShapeEntry<TData = unknown, TPose = unknown> {
      *  and by SVG export. Painters whose visual has no meaningful closed
      *  silhouette (e.g. text) leave this undefined. */
     silhouette?(node: Node$1<TData, string, TPose>, pose: TPose): Path | null;
+    /** Optional: how the silhouette is inked — whether the interior is filled,
+     *  and how wide the outline is. Read by picking, so that an unfilled shape
+     *  is grabbable by its outline rather than by its empty middle.
+     *
+     *  This is declared separately from `paint` rather than read back off the
+     *  emitted draw commands because picking runs on every pointer move, and
+     *  `paint` is allowed to be expensive (`kit:text` lays out glyphs). Keep it
+     *  to cheap field reads.
+     *
+     *  Painters that leave it undefined are treated as `{ filled: true,
+     *  strokeWidth: 0 }` — the pre-`ink` behavior, where the whole silhouette
+     *  interior is grabbable and the outline adds nothing. */
+    ink?(node: Node$1<TData, string, TPose>, pose: TPose): NodeInk | null;
+}
+/** How a painter inks its silhouette. See {@link NodeShapeEntry.ink}. */
+interface NodeInk {
+    /** True when the silhouette's interior is painted, and so grabbable. */
+    filled: boolean;
+    /** Stroke width in world units. `0` for no stroke. */
+    strokeWidth: number;
 }
 interface RegisterNodeShapeOptions {
     /** `'high'` puts the painter ahead of all normally-registered ones (so
@@ -6113,6 +4286,47 @@ declare function findNodeShape<TData, TPose>(node: Node$1<TData, string, TPose>)
  *  draws. (`paint()` is unaffected — it applies rotation via the render wrap,
  *  not the silhouette, so there is no double-rotation.) */
 declare function findShapeSilhouette<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose): Path | null;
+/** Find the painter for `node` and ask how it inks its silhouette. Returns
+ *  the painter's declared {@link NodeInk}, or `null` when no painter matches
+ *  or it declares none — callers substitute {@link DEFAULT_INK}. */
+declare function findShapeInk<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose): NodeInk | null;
+/** Options for {@link shapeCoversPoint}. */
+interface ShapeCoversPointOptions {
+    /** Extra grab distance around the outline, in **world** units. Callers
+     *  derive it from a screen-pixel slop and the view scale, the same way
+     *  affordance hit radii work.
+     *
+     *  Without slop a hairline is a mathematically zero-width target: the
+     *  stroke of a 1px outline is half a world unit wide at scale 1, which no
+     *  one can hit. Defaults to `0` so a caller that hasn't thought about the
+     *  view still gets exact geometry rather than a wrong guess. */
+    tolerance?: number;
+}
+/**
+ * Does the shape `node` actually paints cover the world point?
+ *
+ * The pose rect says a node covers its whole bounding box. That is wrong for
+ * everything that is not a rectangle: the concave notch of a star, the corner
+ * outside an ellipse, the blank right half of a text box. This asks the
+ * painter's silhouette instead, which is the same boundary used for clipping
+ * and SVG export, so "what you can click" and "what is drawn" answer together.
+ *
+ * "What is drawn" includes the *ink*, not just the boundary. A shape whose
+ * interior isn't filled — an outlined rect, a pencil stroke, a bare line — is
+ * grabbable along its outline and not through its empty middle, which is the
+ * opposite of what a fill test alone answers. The outline's grab width is the
+ * stroke's half-width plus `tolerance`.
+ *
+ * A painter with no `silhouette`, or one that returns `null` for this node
+ * (`kit:text` does, for a node with no non-blank lines), reports `true` —
+ * "no opinion", leaving the caller's own AABB test as the answer. Callers
+ * should keep that AABB test as a cheap pre-filter; this is the refinement,
+ * not a replacement.
+ *
+ * Rotation is already baked by `findShapeSilhouette`, so the point is in
+ * plain world coordinates.
+ */
+declare function shapeCoversPoint<TData, TPose>(node: Node$1<TData, string, TPose>, pose: TPose, x: number, y: number, opts?: ShapeCoversPointOptions): boolean;
 /** Snapshot of the current painters in evaluation order — `'high'` tier
  *  first, then `'normal'`. Useful for debugging which painter handles a
  *  given node. */
@@ -6240,6 +4454,35 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
          *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */
         pickEvery?: (worldX: number, worldY: number) => string | string[] | null;
         boundsOf?: (id: string) => Bounds | null;
+        /**
+         * What "the pointer is on this node" means for the default body-pick.
+         *
+         * - `'pose'` — the node's pose rect, rotation honored. What every
+         *   consumer got before `'shape'` existed, and now the opt-out.
+         * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter
+         *   actually lays down: its silhouette (`findShapeSilhouette`) filled
+         *   or not per the painter's `ink`, plus its outline widened by the
+         *   stroke half-width and `pickTolerancePx`. A click in the concave
+         *   notch of a star, in the corner outside an ellipse, or in the blank
+         *   half of a text box falls through to whatever is beneath; a click on
+         *   the thin outline of an unfilled shape hits it.
+         *
+         * Painters with no silhouette are unaffected — they keep the pose-rect
+         * answer either way, so this can never make a node unreachable.
+         *
+         * Ignored when `pickEvery` is supplied: that override owns the test.
+         */
+        picking?: 'pose' | 'shape';
+        /**
+         * Grab slop around a shape's outline, in **screen** pixels. Default 4.
+         *
+         * Screen pixels rather than world units so the target keeps its
+         * apparent size at any zoom. It widens the outline test under
+         * `picking: 'shape'` (a 1px hairline is otherwise a half-world-unit
+         * target, which is unhittable), and it grows the pose-rect pre-filter
+         * so those outline hits survive it. Set `0` for exact geometry.
+         */
+        pickTolerancePx?: number;
     };
     selectTool?: {
         move?: UseMoveOptions<TPose>;
@@ -6252,10 +4495,6 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
         rotate?: UseRotateOptions<TPose> | false;
         snap?: SnapStrategy<TPose>;
         handleHitRadius?: number;
-        /** Marquee area-select. Default: no behaviors (a drag from empty space
-         *  doesn't mutate the selection). Pass
-         *  `{ behaviors: [selectFromMarquee()] }` to enable rubber-band select. */
-        areaSelect?: UseAreaSelectOptions;
         /** Override the body-pick used on click/pointerdown. Alt-aware: receives
          *  the live alt state + current selection so consumers can implement
          *  alt-cycling through an overlapping stack. Default: top-most hit
@@ -6397,15 +4636,6 @@ type SceneCanvasProps<TData, TLayer extends string, TPose> = Omit<CanvasProps<No
      *  the default select. If you supply your own `tools` prop, this is
      *  ignored — wire `ambient` through your own `useTools` call instead. */
     ambient?: AnyTool[];
-    /** Click-only fallback tool. Its `pointer.onClick` fires only when the
-     *  in-flight tool didn't claim the click (e.g. the active select tool
-     *  returned `pass` on an empty-space click). Use it for a
-     *  click-to-deselect or click-to-spawn behavior that shouldn't interfere
-     *  with the active tool's own clicks. Forwarded to the internal
-     *  `useTools` as its `fallback` slot. If you supply your own `tools`
-     *  prop (takeover form), this is ignored — pass `fallback` to your own
-     *  `useTools` call instead. */
-    clickFallback?: AnyTool;
     /** Viewport feature wiring.
      *
      *  - `inertia`, `pinchZoom`, `animatedZoom` are opt-in: pass `true`
@@ -6737,10 +4967,11 @@ declare const inferredNodeRouting: readonly NodeRoutingEntry[];
  * registry: a declarative schema of the kind's editable properties.
  *
  * Leaf keys inside `schema` are dotted node paths (`pose.x`,
- * `data.fill`) — two segments, rooted at `pose` or `data` — so schema
- * consumers (weasel-ui `SelectionPanel`) can read/aggregate/write
- * generically with no per-kind code. Group keys are organizational
- * only; they do not contribute to the node path.
+ * `data.fill`, `data.style.fontSize`) — a path of any depth rooted at
+ * `pose` or `data` — so schema consumers (weasel-ui `SelectionPanel`)
+ * can read/aggregate/write generically with no per-kind code. Group
+ * keys are organizational only; they do not contribute to the node
+ * path.
  *
  * Kind names share the routing trait's vocabulary — an entry registered
  * as `'rect'` describes nodes `NodeRouting.classify` maps to `'rect'`.
@@ -7353,6 +5584,70 @@ declare function composeAffordanceLayer(id: string, label: string, affordances:
     }, isVisible?: (id: string) => boolean): AffordanceBinding | null;
 };
 
+/**
+ * The one affordance hit-test walk.
+ *
+ * The kit used to hit-test selection chrome two ways: this region walk
+ * (reached through `composeAffordanceLayer`'s `RenderLayer.hitTest`) and a
+ * hand-written classifier in `canvas/affordanceAt.ts` that re-derived corner
+ * positions, the rotate ring, and anchor points from `ChromeState` itself.
+ * Both read the same state and answered the same question, so the geometry
+ * lived twice and could disagree — and only the hand-written side ran for the
+ * kit's own chrome, which is why `AffordanceRegion.cursor` was declared, set,
+ * and never consumed.
+ *
+ * Now there is one walk. `composeAffordanceLayer.hitTest` delegates here, and
+ * so does `buildAffordanceAt`, so an affordance's `regions()` is the single
+ * source of truth for where its chrome is and what a press on it means.
+ */
+
+/** What the walk found: the region, plus the ids needed to describe it. */
+interface AffordanceRegionHit {
+    /** `Affordance.id` — also the chrome-caps visibility id. */
+    affordanceId: string;
+    /** `AffordanceRegion.id`. */
+    regionId: string;
+    /** The region itself, so callers can read `hitKind` / `cursor`. */
+    region: AffordanceRegion;
+    /** Result of the region's `bind()`, called exactly once. */
+    binding: AffordanceBinding;
+}
+/**
+ * Walk affordances for a world-space hit, topmost first.
+ *
+ * **Across affordances**: order mirrors paint. Affordances are drawn first →
+ * last (bottom → top), so the walk runs last → first and stops at the first
+ * one that claims the point. Layering wins outright — a nearer region on a
+ * lower affordance does not beat a farther one on top of it.
+ *
+ * **Within an affordance**: the *nearest* hit region wins, ties going to the
+ * later-declared one. Both hit-testers this replaced took the first region
+ * they found instead, in opposite orders, which is only invisible while
+ * regions don't overlap. They do: the four corner handles of a selection
+ * smaller than the hit radius all contain the same click, and "first in the
+ * table" silently answered top-left (or bottom-right) no matter which handle
+ * the pointer was actually on.
+ *
+ * `isVisible` (when supplied) gates by the same chrome id used at paint time,
+ * so chrome that isn't drawn can't be hit either.
+ */
+declare function hitAffordanceRegions(affordances: readonly Affordance[], wx: number, wy: number, state: ChromeState, view: View, isVisible?: (id: string) => boolean): AffordanceRegionHit | null;
+/**
+ * An annulus region's effective outer semi-axes, with `minBandPx` applied.
+ *
+ * The affordance declares the natural ellipse (typically the smallest one
+ * containing the inner rect) plus a screen-space floor on band thickness;
+ * this is where the floor becomes world units, because this is where the view
+ * is known. Paint calls it too, so the visible ring and the hoverable ring
+ * are the same ring.
+ */
+declare function annulusSemiAxes(shape: Extract<AffordanceRegion['shape'], {
+    kind: 'annulus';
+}>, view: View): {
+    rx: number;
+    ry: number;
+};
+
 interface CornerResizeAffordanceOptions {
     /** Hit radius (screen-px) for the corner handles. Default 8. */
     handleHitRadius?: number;
@@ -7361,12 +5656,19 @@ interface CornerResizeAffordanceOptions {
     fill?: string;
     stroke?: string;
 }
-interface CornerResizeScratch {
+interface CornerResizeScratch extends CommonAffordanceScratch {
     /** Resize anchor identifying the OPPOSITE corner (the one that stays
      *  fixed). Matches the kit's existing ResizeAnchor convention. */
     anchor: ResizeAnchor;
     /** Id of the resize target. In multi-mode this is `MULTI_RESIZE_TARGET_ID`. */
     targetId: string;
+    /** The fixed corner in **world** coords, with the target's rotation already
+     *  applied. `resizeAction` scales from this point, and it has no access to
+     *  the target transform, so the affordance resolves it here. */
+    fixedPoint: {
+        x: number;
+        y: number;
+    };
 }
 /**
  * @experimental
@@ -7400,10 +5702,15 @@ interface RotationAffordanceOptions {
     /** Cursor while hovering the ring. Defaults to `'grab'`. */
     cursor?: string;
 }
-interface RotationScratch {
+interface RotationScratch extends CommonAffordanceScratch {
     /** Id of the rotation target — single selection id, or
      *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */
     targetId: string;
+    /** Rotation pivot in world coords — the AABB (or union AABB) center. */
+    fixedPoint: {
+        x: number;
+        y: number;
+    };
 }
 /**
  * @experimental
@@ -7424,6 +5731,61 @@ interface RotationScratch {
  */
 declare function createRotationAffordance(opts?: RotationAffordanceOptions): Affordance;
 
+/**
+ * Path anchor + control-handle affordances.
+ *
+ * These were the last piece of selection chrome whose geometry lived only
+ * inside `canvas/affordanceAt.ts`'s hand-written classifier. Expressing them
+ * as regions puts every kit affordance behind one hit-test walk, which is
+ * what lets `AffordanceRegion.cursor` and nearest-region picking apply here
+ * too rather than only to the chrome that happened to be declarative already.
+ */
+
+/**
+ * Live anchor-editing state, read fresh on every hit-test.
+ *
+ * Anchors are not derivable from `ChromeState` — they come off the editable
+ * path behind whatever the consumer's `editAnchors` dep exposes — so this
+ * thunk is the seam. It's called on every pointer event, so it must be cheap
+ * (O(1) field reads); enumeration happens inside `regions()`.
+ */
+interface AnchorState {
+    /** Id of the path currently in anchor-edit mode, or `null`. Control handles
+     *  are only hittable on the path that is being edited. */
+    editingId: string | null;
+    /** Current editable path for a node id. Non-polygon values are ignored. */
+    getPose(id: string): unknown;
+}
+interface PathAnchorAffordanceOptions {
+    /** Hit radius (screen-px) for anchor and control points. Default 8. */
+    hitRadius?: number;
+    /** Cursor while hovering an anchor or control. Defaults to `'pointer'`. */
+    cursor?: string;
+}
+interface AnchorScratch extends CommonAffordanceScratch {
+    /** Node id of the path the anchor belongs to. */
+    targetId: string;
+    /** Sequential anchor index in path walk order. */
+    anchorIndex: number;
+    /** Which of the anchor's three grabbable points this is. */
+    part: 'anchor' | 'controlIn' | 'controlOut';
+}
+/** Chrome-caps id gating both returned affordances. */
+declare const PATH_ANCHOR_CHROME_ID = "path-edit.anchors";
+/**
+ * Anchor + control affordances for the selected paths, bottom → top.
+ *
+ * Returns **two** affordances rather than one so that a control handle beats
+ * an anchor regardless of which is nearer — the same preference `hitAnchor`
+ * encodes, and the same one the rendering has (controls draw on top). Within
+ * each of the two, nearest wins. They deliberately share one id: chrome-caps
+ * gates anchor editing as a single piece of chrome, and splitting the id
+ * would invent a visibility rule nothing asked for.
+ *
+ * Order matters — spread this into an affordance list in the returned order.
+ */
+declare function createPathAnchorAffordances(getAnchorState: () => AnchorState | null, opts?: PathAnchorAffordanceOptions): Affordance[];
+
 /** Pluggable text-painting strategy. The default fills white at `(x, y)`; markdown renderers replace this. */
 type TextRenderer = (ctx: CanvasRenderingContext2D, text: string, x: number, y: number) => void;
 /** Visual options for `renderLabel`. */
@@ -7505,6 +5867,17 @@ declare function createMarkdownRenderer(ctx: CanvasRenderingContext2D, text: str
  * already matches `style` (use `fontString(style)`).
  */
 
+/**
+ * Advance width of `text` in world units, tracking included.
+ *
+ * `letter-spacing` is not part of the CSS `font` shorthand, so a context
+ * whose `font` was set from `fontString(style)` measures glyphs only. The
+ * GL path (`layoutRuns`) adds `letterSpacing` after **every** code point
+ * including the last, matching CSS, so this does too — and every 2D-side
+ * width has to go through here or the two paths disagree about where a line
+ * breaks.
+ */
+declare function measuredWidth(ctx: CanvasRenderingContext2D, text: string, style: ResolvedTextStyle): number;
 /** Result of `measureText`: wrapped lines, per-line source offsets, and total block height. */
 interface MeasuredText {
     lines: string[];
@@ -7617,6 +5990,70 @@ declare function pointInTextPose(x: number, y: number, pose: TextPose, opts?: Po
  */
 declare function caretIndexAt(ctx: CanvasRenderingContext2D, x: number, y: number, pose: TextPose): number;
 
+/**
+ * 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`).
+ */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * Where a text node's lines actually sit inside its pose box.
+ *
+ * A text pose is a *wrap box*, not a bounding box: `"Away"` in a 309-unit-wide
+ * box leaves most of the box empty, and anything that treats the pose as the
+ * node's extent — picking, lasso, clipping, SVG export — claims that empty
+ * space. `textLineBoxes` returns the per-line rectangles instead.
+ *
+ * The numbers come from `layoutRuns`, the same walk that positions the glyphs,
+ * through the same `resolveTextStyle` → `resolveRuns` → `layoutRuns` chain as
+ * `textCommand` — so the boxes cannot drift from what is painted. In
+ * particular they honor `align` (a centered line reports its own span, not the
+ * wrap width) and `verticalAlign` (the block shifts inside `[y, y + height]`
+ * exactly as `drawText` shifts the quads).
+ *
+ * These are line boxes, not ink boxes: each is `fontSize * lineHeight` tall
+ * from the pen's line top. Ink can escape vertically at a `lineHeight` low
+ * enough — see the `bounds` note at the end of `layoutRuns` — which is the
+ * right trade for hit-testing, where a box that hugged the ink would make
+ * an `x` harder to click than an `X`.
+ */
+
+/** Options for {@link textLineBoxes}. */
+interface TextLineBoxesOpts {
+    /** Grow every box by this much on all four sides (world units). Default 0.
+     *  Picking wants a little slack so a single hairline row of text is still
+     *  grabbable; clipping and export want none. */
+    padding?: number;
+    /** Keep boxes for blank lines (zero width). Default `false` — a blank line
+     *  covers no area, so for hit-testing and silhouettes it is noise. Pass
+     *  `true` when the indices have to line up with the wrapped lines. */
+    includeEmpty?: boolean;
+    /**
+     * Wrap width. Default `pose.width`, which is what `createTextLayer` passes
+     * and what `TextPose` means by its box.
+     *
+     * Pass `Infinity` for a node painted by the built-in `kit:text` painter:
+     * that painter deliberately does **not** forward `maxWidth` (see
+     * `NodeShape.ts`), so its text does not wrap, and boxes computed with a
+     * finite width would wrap where the paint did not.
+     */
+    maxWidth?: number;
+}
+/** Per-line rectangles for a text pose, in world units, in layout order. */
+declare function textLineBoxes(pose: TextPose, opts?: TextLineBoxesOpts): Rect[];
+
 /**
  * Resize a text node's pose to fit its content. Pure helper — does not own
  * scene state. Call it whenever the text, style, or relevant axis changes,
@@ -7651,6 +6088,82 @@ interface FitTextPoseOptions {
 /** Recompute a `TextPose`'s `width`/`height` to fit its content; pure helper, doesn't mutate scene state. */
 declare function fitTextPose(ctx: CanvasRenderingContext2D, pose: TextPose, opts?: FitTextPoseOptions): TextPose;
 
+/**
+ * The kit-wide "these values disagree" sentinel. Used wherever a value is
+ * aggregated across more than one source and the sources don't agree — e.g.
+ * a UI panel aggregating a property across a multi-node selection, or text
+ * styling aggregated across the runs in a character range. One symbol, one
+ * `isMixed` check, regardless of what's being aggregated.
+ */
+declare const MIXED: unique symbol;
+type Mixed = typeof MIXED;
+
+/**
+ * Range-addressed styling over `StyledRun[]`. The panel addresses node paths;
+ * a caret addresses a character range — these are the functions for the
+ * second case. Pure and React-free so the semantics are unit-testable, the
+ * same split `SelectionPanel` makes between `model.ts` and its component.
+ *
+ * Character offsets index the concatenated run text (`runsToPlainText`), and
+ * a range is half-open: `[start, end)`. Ranges are clamped, never wrapped —
+ * a negative `start` clamps to 0, an `end` past the text clamps to its
+ * length, and a collapsed or inverted range (`start >= end`) is empty.
+ * Offsets are UTF-16 code units, as everywhere else in this feature, so a
+ * boundary can bisect a surrogate pair (`[1, 2)` over `'a👍b'` splits the
+ * thumbs-up into lone surrogates). A caret-derived range never does this.
+ *
+ * **Run-level flags are additive over the node's `TextStyle`: a run can
+ * turn `bold` / `italic` / `underline` / `strikethrough` on, never off.**
+ * So a flag is stored only when true, and absent reads as `false`. For
+ * `bold` this falls out of the model — node weight is numeric, and
+ * `run.bold ? 700 : baseWeight` has nowhere to put "not bold." For the
+ * boolean decorations it does not: both levels are booleans, so a tri-state
+ * (`true` / `false` / inherit) is expressible and we are collapsing it by
+ * choice, to keep one canonical form per styling. Resolution must therefore
+ * read decorations as `run.underline || style.underline` — a `??` would
+ * make "select a word in an underlined node, hit U to turn it off" look
+ * supported by the type while this file discards the `false` that expresses it.
+ *
+ * Copies here are shallow: a `fill` object is shared by reference between
+ * the input runs, the patch, every run the patch touched, and the value
+ * `styleAtRange` reports. Treat `fill` values as immutable.
+ */
+
+/** Every styleable key of a run, each either a concrete value or MIXED (the
+ *  runs in the range disagree at that key). */
+type RangeStyle = {
+    [K in Exclude<keyof StyledRun, 'text'>]?: StyledRun[K] | Mixed;
+};
+/**
+ * What `applyStyleToRange` writes. `text` is deliberately not part of it —
+ * this is a styling operation, not an edit.
+ */
+type RunStylePatch = Partial<Omit<StyledRun, 'text'>>;
+/** Every key of a run that carries styling — i.e. everything but `text`. */
+type StyleKey = Exclude<keyof StyledRun, 'text'>;
+/**
+ * The styling shared by every run overlapping `[start, end)`: a concrete
+ * value where the range agrees, `MIXED` where it doesn't. Keys no run
+ * in range sets are absent (they inherit the node's `TextStyle`) — except
+ * the additive flags, which read as `false` rather than `undefined` since a
+ * run cannot un-set them. An empty range reads as `{}`. A reported `fill`
+ * is the run's own object, not a copy — treat it as immutable.
+ */
+declare function styleAtRange(runs: readonly StyledRun[], start: number, end: number): RangeStyle;
+/**
+ * Write `patch` over `[start, end)`, splitting runs at the boundaries and
+ * coalescing neighbors that end up identical. A patch value of `undefined`
+ * or `false` deletes the key instead of storing it — see the additive-flags
+ * contract at the top of the file.
+ *
+ * Returns a new array of new runs; neither the input array nor its runs are
+ * mutated (though a nested `fill` is shared by reference). Normalization —
+ * merging identical neighbors, dropping empty runs — applies to the whole
+ * array, not just the patched span, and to every call, including one whose
+ * range is empty and so patches nothing.
+ */
+declare function applyStyleToRange(runs: readonly StyledRun[], start: number, end: number, patch: RunStylePatch): StyledRun[];
+
 /**
  * In-place text editing via a contenteditable overlay positioned over the
  * text node's screen-space pose. Enter / blur commit; Shift+Enter inserts a
@@ -7662,17 +6175,51 @@ declare function fitTextPose(ctx: CanvasRenderingContext2D, pose: TextPose, opts
  * (`isHidden: (n) => n.id === editingId`) so the overlay isn't drawn twice.
  */
 
+/**
+ * The caret's character range within the text being edited. Half-open
+ * `[start, end)` over the concatenated run text, normalized so `start <= end`
+ * regardless of which way the user dragged. `start === end` is a collapsed
+ * caret — a real position, not the absence of one, which is why the hook
+ * reports `null` rather than a zero-width range when there is no caret.
+ */
+interface TextEditSelection {
+    start: number;
+    end: number;
+}
 /** Screen-space pose passed to `useTextEdit` so the overlay can be placed and sized in CSS pixels. */
 interface TextEditScreenPose {
-    /** Top-left in CSS pixels relative to `container`. */
+    /** Top-left in CSS pixels relative to `container`. Always screen pixels,
+     *  including when `zoom` is set — the scale is anchored at this point, not
+     *  translated by it. */
     x: number;
     y: number;
+    /** Pre-scale — CSS pixels, or world units when `zoom` is set. */
     width: number;
     height: number;
-    /** Effective on-screen font size (style.fontSize * zoom). */
+    /** Pre-scale font size: `style.fontSize * zoom` when `zoom` is omitted, the
+     *  world-unit `style.fontSize` when it is set. */
     fontSize: number;
     /** Effective on-screen line height multiplier (defaults to style.lineHeight). */
     lineHeight?: number;
+    /**
+     * CSS scale applied to the overlay (`transform: scale(zoom)`, anchored at
+     * its top-left). Every other size on this pose, and every typographic
+     * metric the hook writes, is then **pre-scale** — pass world units and the
+     * transform does the world→screen conversion.
+     *
+     * This is the only way run-level typography can be correct at a zoom other
+     * than 1. `runsToDom` emits run `fontSize` / `letterSpacing` in world units
+     * and `domToRuns` reads them straight back; threading a scale through the
+     * writer and its inverse through the reader would go lossy on fractional
+     * zooms. Scaling the whole overlay instead leaves that serializer pure and
+     * scales node-level and run-level values by the same factor for free.
+     *
+     * Omit it (the default, `1`) and the pose is plain screen pixels — the hook
+     * then infers the world→screen factor from `fontSize / style.fontSize` to
+     * scale node-level `letterSpacing`, and run-level overrides are left
+     * unscaled. Correct only at zoom 1.
+     */
+    zoom?: number;
 }
 /** Options for `useTextEdit`. */
 interface UseTextEditOptions {
@@ -7697,9 +6244,27 @@ interface UseTextEditOptions {
      * Optional: commit rich-text runs back to the node. When omitted, only
      * `setText` is called with the plain-text form on commit. When provided,
      * commit calls both `setText` (with `runsToPlainText(runs)`) and
-     * `setRuns(id, runs)`.
+     * `setRuns(id, runs)` — but only when runs are actually in play: the node
+     * already had some, or the edit produced styling. A plain-text edit of a
+     * plain-text node still calls `setText` alone, so a node that has never
+     * been styled doesn't grow a single-run `runs` array just for being edited.
      */
     setRuns?: (id: string, runs: StyledRun[]) => void;
+    /**
+     * Is `el` part of the editor's own chrome — a character-options bar, a
+     * color popover, anything whose whole purpose is to style the text being
+     * edited? Focus moving into one does not end the edit.
+     *
+     * Without this, the controls the feature exists for are exactly what
+     * destroys it: clicking a size field blurs the overlay, blur commits, and
+     * the caret the control was about to act on is gone. Toggle buttons can
+     * dodge it by `preventDefault()`-ing their own mousedown, but a field the
+     * user has to type into cannot.
+     *
+     * Chrome focus does not disturb the reported `selection` either — see
+     * `UseTextEditReturn.selection`.
+     */
+    isEditorChrome?: (el: Element) => boolean;
 }
 /** Options for `useTextEdit().startEdit`. */
 interface StartEditOptions {
@@ -7716,6 +6281,37 @@ interface UseTextEditReturn {
     cancelEdit: () => void;
     commit: () => void;
     isEditing: (id: string) => boolean;
+    /**
+    * The caret's character range, or `null` when nothing is being edited. A
+    * collapsed caret reports `{ start: n, end: n }`, so `null` and "caret at
+    * n" stay distinguishable — a character-styling control routes the
+    * collapsed case to the node's `TextStyle` instead of to a range.
+    *
+    * Follows the DOM selection, which browsers (and jsdom) report from a task
+    * rather than synchronously; anything this hook writes itself updates it
+    * synchronously. A DOM selection that leaves the overlay does **not** clear
+    * it: that is what happens when the user clicks a styling control, and
+    * reporting `null` there would read as "collapsed caret" and send the
+    * control's patch to the node instead of to the range. It is cleared on
+    * `startEdit` and when the edit ends.
+    */
+    selection: TextEditSelection | null;
+    /**
+     * The styling shared by every run in `selection` — a concrete value where
+     * the range agrees, `MIXED` where it doesn't. `null` exactly when
+     * `selection` is `null`. A collapsed caret reports `{}`: no run is in
+     * range, so the range reader has nothing to say and the node's style is
+     * what applies.
+     */
+    rangeStyle: RangeStyle | null;
+    /**
+     * Write `patch` over `selection`. A no-op with no active edit, with a
+     * collapsed caret (there is no range to style — patch the node's
+     * `TextStyle` instead), or with an empty patch. The caret survives, so a
+     * second style can be applied without re-selecting, and `rangeStyle`
+     * reflects the write before this returns.
+     */
+    applyStyleToSelection: (patch: RunStylePatch) => void;
 }
 /** In-place text editing via a contenteditable overlay positioned over the text node's screen-space pose. */
 declare function useTextEdit(opts: UseTextEditOptions): UseTextEditReturn;
@@ -7748,8 +6344,10 @@ declare function unionBounds<TPose extends RectPose>(poses: Iterable<TPose>): Re
  * (`getText` / `getStyle` / `getRuns` / `setText` / `setRuns`).
  *
  * Pose component: the helper reads `(x, y, width, height)` straight off
- * the node's pose (typed `RectPose`). Consumers with non-rect poses or
- * zoom-aware screen mapping should drop down to raw `useTextEdit` and
+ * the node's pose (typed `RectPose`). Pass `view` and it projects that box
+ * through the viewport; omit it and world units are handed through as
+ * screen pixels, which is correct only for an unpanned, unzoomed canvas.
+ * Consumers with non-rect poses should drop down to raw `useTextEdit` and
  * supply their own `getScreenPose`.
  */
 
@@ -7775,6 +6373,25 @@ interface UseSceneTextEditOptions<TData> {
     setRuns?: (data: TData, runs: StyledRun[]) => TData;
     /** Fallback fontSize when `style.fontSize` is unset. Default `16`. */
     defaultFontSize?: number;
+    /**
+     * Current viewport. Supply it on a canvas that pans or zooms: the overlay
+     * is then positioned at the node's projected screen origin and CSS-scaled
+     * by the view, so every typographic metric on it — including the
+     * `fontSize` / `letterSpacing` a *run* carries — stays in world units and
+     * scales together. Omit it and the node's world box is passed through as
+     * screen pixels (correct at `{x: 0, y: 0, scale: 1}`).
+     *
+     * The overlay takes a single scale factor, so a non-uniform view scale is
+     * represented by its `scale.x`; text under `scale.x !== scale.y` will not
+     * match the canvas.
+     */
+    view?: View;
+    /**
+     * Forwarded to `useTextEdit`: is `el` part of the editor's own chrome?
+     * Focus moving into it does not end the edit. Wire it to whatever renders
+     * the character controls.
+     */
+    isEditorChrome?: (el: Element) => boolean;
 }
 /** Return shape extends `UseTextEditReturn` with an `onDoubleClick`
  *  binding for the canvas container. Double-clicking inside a text
@@ -7790,10 +6407,12 @@ interface UseSceneTextEditReturn extends UseTextEditReturn {
 declare function useSceneTextEdit<TData extends DefaultTextData, TLayer extends string, TPose extends RectPose = RectPose>(scene: Scene<TData, TLayer, TPose>, container: HTMLElement | null, options?: UseSceneTextEditOptions<TData>): UseSceneTextEditReturn;
 
 /**
- * Build a `TextDrawCommand` for a single plain-text string. The string is
- * wrapped in a single resolved run, taking style defaults via
- * `resolveTextStyle` + `resolveRuns`. For inline-styled (multi-run) text,
- * build the command directly using `resolveRuns(runs, resolveTextStyle(style))`.
+ * Build a `TextDrawCommand`. `textCommand` takes a plain string and wraps it
+ * in one run; `textCommandFromRuns` takes the styled runs directly. Both
+ * resolve through `resolveTextStyle` + `resolveRuns`, so every emitter of a
+ * text command derives `align` and per-run resolution the same way — a
+ * caller that assembles the command by hand is one field away from a
+ * silently different result.
  */
 
 declare function textCommand(x: number, y: number, text: string, style?: TextStyle, maxWidth?: number, height?: number, verticalAlign?: TextVerticalAlign): DrawCommand;
@@ -7823,8 +6442,15 @@ declare function charOffsetToDomPosition(parent: HTMLElement, offset: number): {
 /**
  * Inverse of `charOffsetToDomPosition`. Walks text nodes in document order;
  * sums the lengths of every text node preceding `node` and adds `offset`.
- * If `node` is an element (not a text node), counts to the end of the
- * preceding text content.
+ *
+ * When `node` is an element the DOM offset indexes *child nodes*, not
+ * characters, so it can't simply be added — `(overlay, 0)` is the start of
+ * the text and `(overlay, childNodes.length)` its end. That shape is not
+ * exotic: `Range.selectNodeContents`, which `useTextEdit` uses for its
+ * select-all caret, produces exactly it. So resolve an element position by
+ * counting the text that precedes the boundary point. A text node can never
+ * *contain* that point (the container isn't one), so each is wholly before
+ * or wholly after it.
  */
 declare function domPositionToCharOffset(parent: HTMLElement, node: Node, offset: number): number;
 
@@ -8072,6 +6698,48 @@ declare function registerOpFactory<A>(name: string, build: (args: A) => Op): voi
  *  a no-op placeholder so stack ordering survives across kit version skew). */
 declare function rebuildOp(name: string, args: unknown): Op | null;
 
+/** @internal */
+interface HitAdapter<TNode extends {
+    id: string;
+}, TPose> {
+    getNode: (id: string) => TNode | undefined;
+    getNodes: () => TNode[];
+    getPose: (id: string) => TPose;
+    getParent: (id: string) => string | null;
+}
+interface NestedHitOpts<TNode extends {
+    id: string;
+}, TPose> {
+    /** Compose a child's local pose into world coords given its parent's world
+     *  pose. Same shape as `composeRectPose` (the default expectation). */
+    composePose: (parent: TPose, child: TPose) => TPose;
+    /** Derive an axis-aligned bounding rect from a (world-space) pose. Default
+     *  reads `x` / `y` / `width` / `height` straight off the pose (matches
+     *  `RectPose`). Override for non-rect poses (e.g. paths). */
+    poseBounds?: (pose: TPose) => Bounds;
+    /** Predicate for "this object is a nesting parent body". The leaf scan
+     *  skips objects for which this returns true so a click on a parent's
+     *  painted body resolves to a child leaf, not the parent itself. Default:
+     *  never (treat every object as hittable). */
+    isGroup?: (id: string, obj: TNode | undefined) => boolean;
+}
+interface NestedHitTester {
+    /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a
+     *  casual click selects the whole top-level ancestor. Returns `null` on
+     *  empty space. */
+    pickOutermost: (worldX: number, worldY: number) => string | null;
+    /** Alt-aware selection-update pick. Without `alt`, returns the outermost
+     *  ancestor (same as `pickOutermost`). With `alt`, returns one level
+     *  deeper than the deepest currently-selected ancestor in the leaf's
+     *  chain — repeated alt-clicks step ancestor → descendant → leaf. With
+     *  `alt` and nothing in the chain selected, jumps straight to the leaf.
+     *  Plug into `useSelectTool({ pickBest })`. */
+    pickBest: (worldX: number, worldY: number, alt: boolean, selection: readonly string[]) => string | null;
+}
+declare function nestedHitTester<TNode extends {
+    id: string;
+}, TPose>(adapter: HitAdapter<TNode, TPose>, opts: NestedHitOpts<TNode, TPose>): NestedHitTester;
+
 /**
  * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
  * encoding behind move/line/curve/close calls and a final `build()`. Use
@@ -8173,6 +6841,44 @@ declare function linePath(a: {
 /** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */
 declare function boundsOfPath(path: Path): RectPath;
 
+/**
+ * Counts the path anchors used by the per-anchor coloring surface. An
+ * "anchor" is the destination point of a path command: M, L, C, Q each
+ * contribute one (the (x, y) where the pen ends up); Z contributes none
+ * (it closes back to the subpath's first M). RectPath has four implicit
+ * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.
+ *
+ * Consumers use this to size their per-anchor color array; the renderer
+ * uses it to validate the array length in dev builds.
+ */
+
+interface PenAnchor {
+    x: number;
+    y: number;
+    inHandle?: {
+        x: number;
+        y: number;
+    };
+    outHandle?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on
+ * every `M` command; a subpath is closed iff it ends with `Z`.
+ *
+ * Cubic-segment control points become the outHandle of the previous anchor
+ * and the inHandle of the next anchor. Quadratic segments are upgraded to
+ * cubics (each control reused for both adjacent handles) — this loses no
+ * geometry. Linear segments produce anchors with no handles.
+ */
+declare function pathToAnchors(path: PolygonPath): {
+    anchors: PenAnchor[][];
+    closed: boolean[];
+};
+declare function countPathAnchors(path: Path): number;
+
 interface Point {
     x: number;
     y: number;
@@ -8198,24 +6904,6 @@ interface PointInPathOptions {
 /** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
 declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
 
-/**
- * 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`).
- */
-interface Vec2 {
-    x: number;
-    y: number;
-}
-interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-
 /**
  * Path-vs-geometry hit-test helpers. Five pure functions covering all
  * combinations of path-vs-point, path-vs-rect, and path-vs-polygon.
@@ -8654,10 +7342,12 @@ declare function createPenPreviewLayer(opts: CreatePenPreviewLayerOptions): Rend
  * `getEditingId()` + `getPose(id)` thunks. Returns `[]` when no editing
  * target is set or the target isn't a polygon — the layer never throws.
  *
- * Visual treatment matches `penEditOverlay.ts` so the two overlays look
- * consistent: anchors render as small white-filled stroked squares;
- * control points as small filled circles connected to their anchor by a
- * thin stem line.
+ * Anchors render as small white-filled stroked squares — filled solid
+ * when selected; control points as small filled circles connected to
+ * their anchor by a thin stem line. This is the kit's only anchor
+ * chrome; the pen tool's parallel overlay and `apps/draw`'s
+ * mode-decoration painter both drew the same thing from different state
+ * and have been removed.
  *
  * All coordinates are projected via `worldToScreen` so the marker sizes
  * stay constant regardless of zoom.
@@ -8671,7 +7361,26 @@ interface CreatePathEditingOverlayLayerOptions {
     /** Returns the pose for an id, or null if the node has been deleted.
      *  Non-polygon poses are tolerated (the layer no-ops on them). */
     getPose(id: string): Path | null;
-    /** Optional styling overrides. Defaults match `penEditOverlay`. */
+    /** Flat indices of the selected anchors. Selected anchors render
+     *  filled; unselected ones hollow — the standard vector-editor cue for
+     *  "these are what the arrow keys and Delete will act on". Omit when
+     *  the consumer has no anchor selection to show. */
+    getSelectedAnchors?(): ReadonlySet<number>;
+    /** In-flight anchor-marquee rect in world coords, or null. Drawn as a
+     *  rubber band while `marqueeAnchorsAction` is dragging. */
+    getMarquee?(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** Chrome-caps predicate. The layer asks `'path-edit.anchors'` before
+     *  drawing anything, so paint and the anchor hit-test in
+     *  `affordanceAt` consult the same rule — otherwise a consumer that
+     *  hides the chrome still gets grabbable invisible anchors, or vice
+     *  versa. Omit to always draw when an edit target is set. */
+    isVisible?(chromeId: string): boolean;
+    /** Optional styling overrides. */
     style?: PathEditingOverlayStyle;
 }
 interface PathEditingOverlayStyle {
@@ -8685,6 +7394,13 @@ interface PathEditingOverlayStyle {
      *  curve / background show through, which matches Figma's "translucent
      *  handle dot" idiom. */
     handleDotFill?: string;
+    /** Fill of a selected anchor square. Defaults to the anchor stroke
+     *  color, so selection reads as "the marker filled in". */
+    anchorFillSelected?: string;
+    /** Stroke of the marquee rubber band. */
+    marqueeStroke?: string;
+    /** Fill of the marquee rubber band. */
+    marqueeFill?: string;
 }
 declare function createPathEditingOverlayLayer(opts: CreatePathEditingOverlayLayerOptions): RenderLayer<unknown>;
 
@@ -9421,36 +8137,6 @@ interface AnchorHit {
  *  are within `threshold` (controls are smaller and rendered on top). */
 declare function hitAnchor(path: PolygonPath, worldX: number, worldY: number, threshold: number): AnchorHit | null;
 
-/** Visual options for the anchor-edit overlay. */
-interface AnchorEditOverlayOpts {
-    /** Returns the live editing state (or `null` when not editing). The overlay
-     *  draws nothing when `null`. */
-    getOverlay: () => {
-        pose: PolygonPath;
-        selectedAnchors: number[];
-    } | null;
-    /** Tangent-line stroke color. Default `#888`. */
-    tangentStroke?: string;
-    /** Anchor circle radius (world units). Default 4. */
-    anchorRadius?: number;
-    /** Control circle radius (world units). Default 3. */
-    controlRadius?: number;
-    /** Anchor fill. Default `#fff`. */
-    anchorFill?: string;
-    /** Anchor stroke. Default `#1a130d`. */
-    anchorStroke?: string;
-    /** Selected-anchor fill (highlight). Default `#7fb069`. */
-    selectedAnchorFill?: string;
-    /** Control fill. Default `#1a130d`. */
-    controlFill?: string;
-    /** Control stroke. Default `#fff`. */
-    controlStroke?: string;
-}
-declare function createAnchorEditOverlayLayer(opts: AnchorEditOverlayOpts): RenderLayer<unknown>;
-
-/** Default area-select behavior: replace selection with hits inside the marquee, or extend with shift held. */
-declare function selectFromMarquee(): AreaSelectBehavior;
-
 /**
  * Typed keys for the gesture/behavior scratch store.
  *
@@ -10197,4 +8883,11 @@ declare function ExcludeIcon(): react_jsx_runtime.JSX.Element;
 declare function DivideIcon(): react_jsx_runtime.JSX.Element;
 declare function CropIcon(): react_jsx_runtime.JSX.Element;
 
-export { ALWAYS, type Action, ActionDeps, ActionDisabledReason, type ActionEnabledResult, type ActionEntry, type ActionsProp, ActionsProvider, ActionsProviderIfRoot, type ActionsRegistry, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, type ActiveToolContextProviderProps, type ActiveToolContextValue, Affordance, AffordanceBinding, AffordanceHit, type AlignAdapter, type AlignAnchor, type AlignBounds, type AlignBoundsProjection, type AlignEdge, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type AnchorEditOverlayOpts, type AnchorHit, type AnimateOnSetPoseOptions, type AnimateToBoundsOptions, type AnimationHandle, type Animator, AnyTool, AreaSelectAdapter, AreaSelectBehavior, type AreaSelectDep, type AreaSelectOverlayStyle, type ArrayAdapter, type ArrayAdapterConfig, BUNDLE_TOOLS, BindingOpts, type BindingScope, type BooleanOp, type BooleanOpResult, type BooleansAdapter, type BoundGesture, Bounds, BoundsConstraint, type BuildChromeCtxArgs, type BuildRuleCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, CURVE_REPS, type CanvasExtensionApi, type CanvasFocusReturn, type CanvasHelpers, type CanvasProps, type CanvasSelectionMode, type CanvasSize, type CanvasSizeSnapshot, type CellHighlightLayerOpts, type ChromeCtx, type ChromeId, ChromeState, type ClampBounds, type ClipboardIngestCtx, ClipboardSnapshot, type CoalescedCtx, type ColorInterpolate, type ColorOverride, type ColorOverrideFn, ColorOverrideRegistry, type ColorSpace, type ComposeSelectionPoseOpts, type ComputeFitViewOptions, type Condition, type ContentHandlerEntry, 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_THEME, 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, DebugTheme, type DecayLoopConfig, type DecayOptions, type DefaultTextData, type DepName, type DepRegistry, DepRegistryProvider, DepRegistryProviderIfRoot, type DepSchema, type DeriveAlignmentGuidesOptions, Dims, type Discriminator, type Dispatcher, type DispatcherContext, 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, type EditAnchorsDep, type EllipseBounds, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, FillStyle, type FitTextPoseOptions, FitViewToBoundsOptions, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, type GeometryProjection, GestureBinding, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, HandIcon, type InertiaConfig as HandToolInertiaConfig, type HandleDragPoint, type HeadlessCanvasLike, HotkeyTrigger, type IconProps, type ImageNodeData, type ImageStatus, type IndicatorStyle, type IngestCtx, type IngestionDep, InsertAdapter, InsertBehavior, type InsertDep, type InsertExtras, type InsertNodeFactory, type InsertOp, type InsertOverlayStyle, type Interpolate, type InterpolatorFactory, IntersectIcon, Invoker, KIT_SHAPE_KINDS, type LabelOptions, LassoHitMode, LassoIcon, LassoSelectAdapter, LassoSelectBehavior, type LassoSelectDep, LayerEnumerableAdapter, type LayerSlotValue, type LayersMap, type LayoutDep, type LayoutLine, type LayoutResult, LayoutSnap, LayoutStrategy, type LifecycleAnimation, LineIcon, type LinePoint, type LoopFactory, type LoopOptions, MOVE_ANCHORS, type MarkdownFontOptions, type MatchResult, type MeasureFn, type MeasureTextBoundsOpts, type MeasuredText, MinimapCanvas, type MinimapCanvasProps, type MinimapFit, ModifierState, type MomentumOptions, MoveAdapter, MoveBehavior, type MoveOverlayStyle, NEVER, type NestedHitOpts, type NestedHitTester, type NestedSelectAdapter, type NodeAtPointDep, type NodeClientRect, NodeId, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, OngoingHandle, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, type PanBounds, type ParallaxOpts, Path, type PathAnchor, PathBuilder, PathDrawCommand, type PathEditingOverlayStyle, PathFillRule, type PathInWorldPose, type PenAnchor$1 as PenAnchor, PenIcon, type PenPreviewStyle, type PenScratch, type PenSubpath, PencilIcon, type PhysicsHandle, type PhysicsOptions, PickHud, type PickHudProps, type PickTopMostHitAdapter, type PinchZoomToolOpts, type PixelRenderPlan, Point2, type PointInPathOptions, type PointInTextPoseOpts, PointSnapBehavior, PointerContextProvider, type PointerContextValue, type PointerGestureBindings, type PointerGestureCallbackCtx, PointerProviderIfRoot, type PointerSample, type PointerStylusState, type PointerWorldPos, PolygonIcon, PolygonPath, type PolygonPoint, PoseComposition, PoseProjection, type PoseRotation, type PositionedRun, type PressureToWidthOptions, type Pt, RECT_ALIGN_PROJECTION, type RasterImage, type Rect, type RectBounds, RectIcon, RectPath, RectPose, type RegisterNodeShapeOptions, RegisteredOp, RenderLayer, type RenderSceneToCanvasArgs, type RenderSceneToPixelsArgs, type ReorderDirection, ResizeAdapter, ResizeAnchor, type ResizePolicy, ResizePose, type ResolveOnlyResult, ResolvedTextStyle, RotateAdapter, RotateBehavior, type RotateGeometry, RotatedPose, type RotationAffordanceOptions, type RotationHandle, type RotationScratch, type Rule, type RuleCtx, 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, type ScopedBinding, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, type Selector, SerializedScene, type SetPathFields, ShaderProgramHandle, type SharedAnchor, type Simulation, type SimulationForce, type SimulationNode, type 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, StyledRun, type StylusData, SubtractIcon, type SvgIngestOptions, type SvgUnpacker, type TextEditDep, type TextEditScreenPose, TextIcon, type TextPose, type TextRenderer, TextStyle, TextVerticalAlign, TextureHandle, type ThresholdDragHandle, type ThresholdDragOptions, type TileGridOptions, type TilePatternOpts, Tool, type ToolBundle, ToolCtx, 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 ToolPrefString, type ToolPrefStringControl, type ToolsApi, ToolsDispatcher, type TweenLoopOptions, type TweenOptions, type TweenPoseOptions, type TweenVertexColorsOptions, type UiOngoingControl, UnionIcon, UnitSystem, UnitValue, UnknownIcon, type UseAlignOptions, type UseAlignReturn, type UseAnimatorOptions, type UseAreaSelectOptions, type UseArrayAdapterOptions, type UseBooleansOptions, type UseBooleansReturn, type UseCanvasFocusOptions, type UseDistributeOptions, type UseDistributeReturn, type UseDragGestureOptions, type UseDragRadialOptions, type UseDragRectOptions, type UseEllipseToolOptions, type UseEyedropperToolOptions, type UseGestureDispatcherOptions, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, type UseHandToolOptions, type UseHandleDragOptions, type UseHandleDragReturn, type UseHoverTrackingArgs, type UseImageToolOptions, UseInsertOptions, type UseInsertToolOptions, type UseKeybindingsOptions, type UseLassoSelectOptions, type UseLassoToolOptions, type UseLineToolOptions, UseMoveOptions, type UseNestedSelectToolOptions, type UsePenToolOptions, type UsePenToolReturn, type UsePencilToolOptions, type UsePointerGesturesOptions, type UsePointerStylusOptions, type UsePolygonToolOptions, type UseRectToolOptions, 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 UseTextToolOptions, type UseToolsOptions, type UseZoomOptions, type UseZoomReturn, type Vec2, type VertexColorChannel, View, type ViewApi, ViewTransform, type ViewportConfig, ViewportDims, type ViewportZoomOptions, type VisibilityRules, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, applyBooleanOp, applyHitExistingGate, applyOpsTo, areaSelectAction, arrayAdapter, bezierCubic, bezierQuadratic, boundsOfPath, buildChromeCtx, buildRuleCtx, buildSceneViewCommands, canBringForward, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, composeAffordanceLayer, composePath, composeSelectionPose, computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createAnchorEditOverlayLayer, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDeleteOp, createDispatcher, createGridLayer, createGuidesLayer, createHistory, createInsertOp, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, 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, 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, enterTextEditAction, enumerateAnchors, evaluate, evaluateEnabled, findNodeShape, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getScratch, getStylusData, guideSnapStrategy, hexToRgba, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isDebugEnabled, isEditableTarget, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, makeViewportZoomAction, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, mergeAlphaFromPrev, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, 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, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerContentHandler, registerNodeShape, registerOpFactory, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scratchKey, selectFromLasso, selectFromMarquee, selectionAtLeast, selectionEmpty, selectionIs, setScratch, sliceAction, snap, snapPoint, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, starPath, startThresholdDrag, subscribeImageReady, textCommand, tileGrid, toHex8, transformPath, translatePath, translatePolygonInPlace, translatePoseViaDescriptor, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useAction, useActionsRegistry, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDepRegistry, useDepSource, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useInsertTool, useKeybindings, useLassoTool, useLineTool, useNestedSelectTool, useOptionalActiveToolContext, useOptionalDepRegistry, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerContext, usePointerGestures, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, viewportDragPanAction, viewportZoomAction, when, withAlpha01, withCoord, worldEditToStorage, zoomAt, zoomAtLeast };
+interface InsertOverlayStyle {
+    fill?: string;
+    stroke?: string;
+    dash?: number[];
+    lineWidth?: number;
+}
+
+export { 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, BooleansAdapter, Bounds, BoundsConstraint, type BuildChromeCtxArgs, type BuiltinShapeToolId, type BuiltinToolId, type BuiltinToolOptions, 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, 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_THEME, 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, DebugTheme, type DecayLoopConfig, type DecayOptions, type DefaultTextData, DepRegistryProviderIfRoot, DepSchema, type DeriveAlignmentGuidesOptions, 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, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, FillStyle, type FitTextPoseOptions, FitViewToBoundsOptions, type FreeformOptions, GHOST_STROKE, type GateLayerOptions, GeometryProjection, type GestureSource, type GridLayerOpts, type GridSlotConfig, Guide, type GuideSnapOptions, type GuidesLayerOpts, 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, 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, NodeId, type NodeInk, type NodePaintCtx, type NodeProperties, type NodePropertiesEntry, type NodeRouting, type NodeRoutingEntry, type NodeShapeEntry, type OpenFilePickerOptions, OrderedAdapter, OriginProjection, 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, 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, type ScratchKey, type ScratchStore, type SelectAdapter, type SelectFromLassoOptions, SelectIcon, SelectionApi, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type SelectionHandlesLayerOpts, type SelectionOutlineLayerOpts, type SelectionOverlayLayerOpts, type SelectionOverlaySlotConfig, SerializedScene, 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, Tool, type ToolBundle, ToolCtx, 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 ViewportZoomOptions, VisibilityRules, WeaselProvider, type WheelInput, type WheelState, ZoomBound, type ZoomBounds, type ZoomClampOpts, ZoomFactor, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyHitExistingGate, applyOpsTo, applyStyleToRange, areaSelectAction, arrayAdapter, bezierCubic, bezierQuadratic, boundsOfPath, buildChromeCtx, buildSceneViewCommands, canBringForward, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, 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, 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, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitZoom, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, focused, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getScratch, getStylusData, guideSnapStrategy, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isDebugEnabled, isEditableTarget, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linePath, linear, makeViewportZoomAction, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, 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, rainbowVertexColors, rebuildOp, rectCorners, rectPath, registerNodeShape, registerOpFactory, regularPolygonPath, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, scalePathToBounds, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scratchKey, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, 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, 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, when, withAlpha01, withCoord, worldEditToStorage, zoomAt, zoomAtLeast };