@weasel-js/routing 1.14.2 → 1.15.1

package/dist/{index-DJ7SxEKS.d.ts → index-D-XFwx8D.d.ts}

@@ -1,11 +1,12 @@
-import { ModifierKey, ClaimableGesture, GestureSpec, InputEvent, TargetSpec, IngestItem, BodyTarget, BindingOverrideInput, BodyKind, KeyHeldSpec, TargetPredicate, KeySpec, ClickSpec, DoubleClickSpec, DragSpec, ContextMenuSpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
+import { History } from '@weasel-js/history';
+import { PrefGroup, PrefLeaf, PrefNumber } from '@weasel-js/prefs';
 import { FramedBox, View, Point } from '@weasel-js/geom';
-import { CursorSpec } from '@weasel-js/cursor';
-import { MenuEntry, Rect, MenuSide, MenuShortcut } from '@weasel-js/menu';
-import { PrefGroup, PrefLeaf } from '@weasel-js/prefs';
 import { CapabilityTag, ActiveMode, ModeRegistry } from '@weasel-js/modes';
+import { ModifierKey, ClaimableGesture, GestureSpec, IngestItem, InputEvent, TargetSpec, BodyTarget, BindingOverrideInput, BodyKind, KeyHeldSpec, TargetPredicate, KeySpec, ClickSpec, DoubleClickSpec, DragSpec, ContextMenuSpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
 import * as _weasel_js_icons from '@weasel-js/icons';
 import { IconRef } from '@weasel-js/icons';
+import { CursorSpec } from '@weasel-js/cursor';
+import { MenuEntry, Rect, MenuSide, MenuShortcut } from '@weasel-js/menu';
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { Emitter, QueryMatch } from '@weasel-js/registry';
@@ -169,363 +170,429 @@ type ResizeAnchor = {
     y: 'min' | 'max' | 'free';
 };
 
-/** The chrome an in-flight gesture paints beside the scene. */
-
-/**
- * What a `polyline` overlay is, in a word — the narrowest thing an action can
- * say about how its run should look without naming a paint.
- *
- * The named roles are the kit's; a painter maps each to a style and falls back
- * to plain chrome for one it does not know, so a package outside core can coin
- * its own and still be drawn.
- */
-type OverlayRole = 
-/** Generic in-flight chrome — the marquee/lasso paint. */
-'chrome'
-/** A cut the gesture would make. */
- | 'cut'
-/** An edge the gesture would author between two points. */
- | 'connector'
-/** The stretch of a path a soft-selection drag reaches. */
- | 'falloff'
-/** What a lock holds a dragged point to — a line, a circle. */
- | 'lock'
-/** What a dragged item would be dropped on: the box it would go into. */
- | 'target'
-/** Where a dragged item would land: a reorder's insertion bar. */
- | 'insert'
-/** Where a dragged item is over and cannot land. */
- | 'refused' | (string & {});
 /**
- * What an in-flight gesture proposes to paint *beside* the scene, returned by
- * `OngoingHandle.overlay()` — a marquee rect, a lasso trail, the outline of a
- * shape being dragged out, the line a slice would cut along.
+ * 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.
  *
- * Every variant is world geometry and nothing else — no `DrawCommand`, no
- * color, no coordinate space to choose — so a surface rendering the same
- * gesture some other way can still read it. The painter owns every style
- * decision.
+ * Adding a new field is additive: existing rules don't change, new
+ * selector atoms can read it.
  */
-type OngoingOverlay = {
-    kind: 'marquee';
-    start: {
-        x: number;
-        y: number;
-    };
-    current: {
-        x: number;
-        y: number;
-    };
-    shiftHeld: boolean;
-} | {
-    kind: 'lasso';
-    vertices: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>;
-    current: {
-        x: number;
-        y: number;
+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;
     };
-    shiftHeld: boolean;
-} | {
-    /**
-     * An open run of world points the gesture is proposing — a cut line, a
-     * routed connector. `role` is the whole of what an action says about
-     * appearance.
-     */
-    kind: 'polyline';
-    /** At least two points. Anything shorter is dropped in resolution. */
-    points: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>;
-    /** What the run means. Omitted reads as {@link OverlayRole} `'chrome'`. */
-    role?: OverlayRole;
-} | {
-    /**
-     * A round brush dragged through world points: the area it has swept so
-     * far, and its footprint at the last point. The radius is in screen
-     * pixels, so the footprint keeps its size at every zoom.
-     */
-    kind: 'brush';
-    /** The brush's path so far, at least one point; the last is where it is now. */
-    points: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>;
-    radiusPx: number;
-} | {
+    readonly hover: NodeId | null;
     /**
-     * Live insert-drag preview. Pre-commit there is no scene node to ghost
-     * via `previewIds()`/`previewPose()`, so insert paints its preview
-     * through the overlay instead.
+     * How far the viewport is zoomed in, as one number — `1` at native scale.
      *
-     * `bounds` is the AABB of the current drag (start/current normalized).
-     * `extras` is the per-kind extras the action already collected; the
-     * overlay renderer narrows on `shape` and casts the field shape it
-     * expects.
-     */
-    kind: 'insertPreview';
-    /** Which preview the dispatcher's overlay draws. The kit's own shape
-     *  kinds are the ones it knows how to render; a consumer-defined kind
-     *  is legal and simply gets no live preview. */
-    shape: string;
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    extras: unknown;
-    /** World-space point to paint a small "anchor" dot at, marking the
-     *  click point — for radial shapes (polygon/star), where no vertex
-     *  sits on it, and for any shape in center mode. */
-    anchorPoint?: {
-        x: number;
-        y: number;
-    };
-    /** World affines the shape will also be drawn under once it lands, by
-     *  the container it is drawn into: the preview is painted under each. */
-    copies?: readonly (readonly [number, number, number, number, number, number])[];
-} | {
-    /**
-     * Why the gesture cannot land where it is, in words for the user: a
-     * refusal's reason. A surface shows `text` beside the pointer, which
-     * `at` is, in world coordinates.
+     * A scalar rather than the `View` this used to carry, because `zoomAtLeast`
+     * is the only selector that ever read one and a number is all it needs. A
+     * host whose viewport is a camera has no `View` to hand over and would
+     * otherwise have to invent one to use eligibility at all; it omits this
+     * instead, and `zoomAtLeast` declines rather than matching on a fiction.
      */
-    kind: 'reason';
-    at: {
-        x: number;
-        y: number;
-    };
-    text: string;
-};
-/** A handle's overlays as a list: empty when it has none. */
-declare function overlaysOf(handle: OngoingHandle): readonly OngoingOverlay[];
-
-/**
- * Modifier roles: the modifiers an ongoing action reads while it runs, named
- * by what they do rather than which key they are, so a binding or a tuning can
- * move one to another key without forking the action.
- */
-
-/** The keys that hold a role: any one of them held holds it. `'mod'` is Cmd
- *  on a Mac and Ctrl elsewhere. An empty list never holds it. */
-type RoleKeys = readonly ModifierKey[];
-/** One modifier an action reads mid-gesture. */
-interface ModifierRole {
-    label: string;
-    /** The keys that hold it unless a tuning or a binding says otherwise. */
-    keys: RoleKeys;
+    readonly zoom?: number;
+    /** 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;
+    /** Whether a path is currently in anchor-edit mode. Read by the
+     *  `editingAnchors:` selector, which gates the path-edit chrome.
+     *
+     *  This is deliberately a fact about state, not about permission: the
+     *  anchor overlay and the anchor hit-test must agree, and the thing they
+     *  must agree on is "is there an edited path right now", which no
+     *  capability or mode id answers. A mode that allows `edits-anchors`
+     *  with nothing being edited should draw no anchors. Absent is treated
+     *  as false. */
+    readonly editingAnchors?: boolean;
+    /** Device facts — pointer coarseness, hover capability, density.
+     *
+     *  Absent (legacy ctx builders) is treated as
+     *  {@link DEFAULT_DEVICE_PROFILE}: a fine pointer that can hover, at
+     *  density 1. That is what the kit assumed before this field existed, so
+     *  an absent profile is behavior-preserving by construction. */
+    readonly device?: DeviceProfile;
+    /** The view the input being dispatched landed in — a view id, or `null`
+     *  for the surface's own camera. The dispatcher fills it; absent anywhere
+     *  else a rule is evaluated. */
+    readonly viewId?: string | null;
+    /** Chrome ids the active tool hides (`ToolDef.hides`): never visible,
+     *  whatever their rules say. Absent hides nothing. */
+    readonly hiddenChrome?: ReadonlySet<string>;
 }
-/** An action's roles by id, e.g. `'handle.holdAngle'`. */
-type ModifierRoles = Readonly<Record<string, ModifierRole>>;
-/** Keys a tuning or a binding gives some of an action's roles. */
-type RoleRebinds = Readonly<Record<string, RoleKeys>>;
-/** Whether any of `keys` is held. */
-declare function keysHeld(keys: RoleKeys, modifiers: ModifierState, isMac: boolean): boolean;
-/**
- * A reader for an action's own roles. It answers from `ctx.roles`, which the
- * dispatcher resolves on every event, and falls back to the role's default
- * keys where nothing resolved them: an invoker called directly, or a context
- * a cancel-all built with no event.
- */
-declare function roleReader<R extends ModifierRoles>(roles: R): (ctx: {
-    roles?: Readonly<Record<string, boolean>>;
+/** The live state a `RuleCtx` is assembled from — the chrome context plus
+ *  what the active mode allows. */
+interface BuildRuleCtxArgs {
+    focused: boolean;
+    selection: readonly NodeId[];
+    multiActive: boolean;
     modifiers: ModifierState;
-}, id: keyof R & string) => boolean;
-
+    action: {
+        kind: string | null;
+        id: string | null;
+    };
+    hover: NodeId | null;
+    /** See {@link RuleCtx.zoom}. */
+    zoom?: number;
+    mode: string;
+    allowedCapabilities: ReadonlySet<CapabilityTag>;
+    /** Optional — omitted means "resizable" (handles show). See {@link RuleCtx}. */
+    selectionResizable?: boolean;
+    /** Optional — omitted means "no path is being anchor-edited". */
+    editingAnchors?: boolean;
+    /** Optional — omitted means {@link DEFAULT_DEVICE_PROFILE}. */
+    device?: DeviceProfile;
+    /** Optional — omitted hides nothing. See {@link RuleCtx.hiddenChrome}. */
+    hiddenChrome?: ReadonlySet<string>;
+}
 /**
- * Invoker — pluggable invocation strategy for an Action.
+ * Capability set to assume when no mode registry is wired.
  *
- * An Action's `invoker` field describes how it's run. `immediate` invokers
- * fire once (delete, align, undo). `ongoing` invokers open a phase machine
- * driven by the dispatcher (move, resize, pinch-zoom).
+ * "No modes configured" means *everything the default mode permits*, not
+ * *nothing permitted*. The empty set is the wrong default: it makes every
+ * `capability:` rule evaluate false, so a kit default written the
+ * recommended way (capability rules outlive new modes; mode rules have to
+ * be edited) would silently hide its chrome for every consumer that hasn't
+ * opted into modality. `NORMAL.allows` plus the implicit tags is what a
+ * mode-less canvas actually behaves like.
  */
+declare const DEFAULT_ALLOWED_CAPABILITIES: ReadonlySet<CapabilityTag>;
+/** Gather the current canvas and mode state into the context that action
+ *  eligibility and chrome-visibility rules are evaluated against. */
+declare function buildRuleCtx(args: BuildRuleCtxArgs): RuleCtx;
 
-/** A 2D point in either world or screen coordinates; geom's `Point`. */
-type Point2 = Point;
 /**
- * A point in the space the dispatcher's `clientToWorld` maps the pointer into:
- * the world, on a 2D canvas. A host with a camera of its own, such as a
- * `@weasel-js/kernel3d` scene, passes identity, so there it is the pane's
- * screen point and the deps reading it cast a ray through the camera they
- * close over. Every world point the dispatcher hands out, and every dep
- * payload it reaches, is one of these.
+ * 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.
  */
-type WorldPoint = Point2;
+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.editingAnchors` — true while a path is in anchor-edit
+     *  mode. Absent flag is treated as `false`. */
+    editingAnchors?: boolean;
+    /** 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;
+    /** Matches `ctx.device.coarsePointer` — the primary pointer is imprecise
+     *  (touch, most styluses). Absent device is treated as `false`. */
+    coarsePointer?: boolean;
+    /** Matches `ctx.device.canHover` — the primary pointer can hover. Absent
+     *  device is treated as `true`. */
+    canHover?: boolean;
+}
 /**
- * Which UI affordance was hit at pointerdown. Populated by the dispatcher when
- * the `affordanceAt` thunk is provided to `useGestureDispatcher`.
+ * 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;
+/** A rule that never passes. `any` of nothing is false. */
+declare const NEVER: Rule;
+/**
+ * Render a {@link Rule} as a short human-readable string, for inspectors and
+ * diagnostics that need to say WHICH rule decided something.
  *
- * `kind` is a discriminator string:
- *   - `'handle:top-left'` / `'handle:top-right'` / `'handle:bottom-left'` /
- *     `'handle:bottom-right'` — corner resize handles.
- *   - `'handle:top'` / `'handle:right'` / `'handle:bottom'` / `'handle:left'` —
- *     edge resize handles.
- *   - `'rotate-handle'` — the rotation affordance.
- *   - `'anchor:N'` — a path anchor at index N.
+ * ```
+ * { capability: 'edits-page' }               → capability:edits-page
+ * { all: [{ mode: 'normal' }, { focused: true }] } → all(mode:normal, focused:true)
+ * { not: { selection: { empty: true } } }    → not(selection:empty=true)
+ * { when: function hasPath() { … } }         → when(hasPath)
+ * ```
+ *
+ * Never throws and always terminates.
  */
-interface AffordanceHit {
-    /** Discriminator string, e.g. `'handle:bottom-right'`. */
-    kind: string;
-    /** Id of whatever produced this hit — a kit affordance's `id`, or the
-     *  registered layer's id. */
-    owner?: string;
-    /** `'exclusive'` means no binding may act on this point unless its target
-     *  consults the affordance. `'shared'` (the default) competes on scope and
-     *  specificity as bindings always have. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-    /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
-    fixedPoint?: {
-        x: number;
-        y: number;
-    };
-    /** Which nodes this affordance belongs to. */
-    targetIds?: string[];
-    /** Set only when `kind` matches `'handle:*'`: which corner or edge stays
-     *  fixed during a resize; `'free'` on the axis an edge handle leaves alone. */
-    anchor?: ResizeAnchor;
-    /** Cursor to show while the pointer hovers this affordance (no gesture in
-     *  flight). Unset falls through to action-cursor prediction, then to the
-     *  active tool's cursor. */
-    cursor?: CursorSpec;
-    /**
-     * Free-form payload from whatever produced the hit, carried through to the
-     * matching action untouched. Kit affordances leave it unset; it exists for
-     * a registered layer's own chrome, where the hit-test already resolved
-     * *which* of its pieces was hit.
-     */
-    payload?: unknown;
+declare function describeRule(rule: Rule): string;
+/** Evaluate a rule against a context. Pure, and cheap enough to run per
+ *  frame for every piece of chrome. */
+declare function evaluate(rule: Rule, ctx: RuleCtx): boolean;
+/**
+ * Composable eligibility predicate with a fluent surface. `cond(ctx)`
+ * evaluates its `Rule` tree, carried at `.rule`; 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`. 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;
 }
+
 /**
- * One accumulated point on a drag trail: world-space position plus whatever
- * stylus state the originating `PointerEvent` carried.
+ * Whether two rules can never hold at once — no `RuleCtx` passes both.
  *
- * The stylus fields are absent for mouse/touch on browsers that don't report
- * them, and for synthetic events.
+ * Conservative: `true` is a proof, `false` means "may overlap". It reasons
+ * about the selector values themselves (two different `mode`s, an empty
+ * selection against a non-empty one, `focused: true` against `false`) and
+ * through `all` / `any` / `not`; a `when` closure is opaque, so it overlaps
+ * everything. The route-conflict check uses it to stay quiet about bindings
+ * that share a tuple but are never eligible together.
  */
-interface DragSample extends WorldPoint {
-    /** 0..1. Mouse/touch report 0.5 while a button is held, per the spec. */
-    pressure?: number;
-    /** Degrees, ±90. Zero for mouse/touch. */
-    tiltX?: number;
-    /** Degrees, ±90. Zero for mouse/touch. */
-    tiltY?: number;
+declare function rulesExclusive(a: Rule, b: Rule): boolean;
+/**
+ * Whether `rule` can hold while `mode` is active. Only its `mode` and
+ * `capability` tests are settled by the mode; every other test could go either
+ * way, so `false` is a proof and `true` means "may hold".
+ */
+declare function ruleCanHoldIn(rule: Rule, mode: ActiveMode): boolean;
+
+/** The detected half of a profile — everything except the derived scale. */
+type DetectedDeviceFacts = Omit<DeviceProfile, 'targetScale'>;
+/**
+ * Handle/hit multiplier applied on a coarse pointer.
+ *
+ * 8px handle → 14px; 24px rotation distance → 42px. Counting the
+ * surrounding grab zone, that lands in the Apple HIG 44pt / Material 48dp
+ * minimum-touch-target band. One constant so it is tunable in one place.
+ */
+declare const COARSE_TARGET_SCALE = 1.75;
+/**
+ * Fold consumer overrides over detected facts and derive `targetScale`.
+ *
+ * `targetScale` is re-derived AFTER the merge, so an override of
+ * `coarsePointer` alone scales the chrome as expected. An explicit
+ * `targetScale` override wins over the derivation.
+ */
+declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?: Partial<DeviceProfile>): DeviceProfile;
+/**
+ * Assumed when `matchMedia` is unavailable (SSR, jsdom) and used as the
+ * absent-means value for `RuleCtx.device`.
+ *
+ * Derived from `resolveDeviceProfile` rather than hand-written, so it can
+ * never drift from what the function would compute for the same facts. A
+ * mouse-like device is the safe default: it is what the kit has always
+ * assumed, so an absent profile changes nothing for existing consumers.
+ */
+declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
+
+/**
+ * Modifier roles: the modifiers an ongoing action reads while it runs, named
+ * by what they do rather than which key they are, so a binding or a tuning can
+ * move one to another key without forking the action.
+ */
+
+/** The keys that hold a role: any one of them held holds it. `'mod'` is Cmd
+ *  on a Mac and Ctrl elsewhere. An empty list never holds it. */
+type RoleKeys = readonly ModifierKey[];
+/** One modifier an action reads mid-gesture. */
+interface ModifierRole {
+    label: string;
+    /** The keys that hold it unless a tuning or a binding says otherwise. */
+    keys: RoleKeys;
 }
-/** Per-invocation runtime context the dispatcher hands to an Invoker.
- *  Gesture-kind-specific fields (`drag`, `wheel`, `multiTouch`, `key`) are
- *  populated only for matching gesture kinds. */
-interface InvocationCtx {
-    world: WorldPoint;
-    /**
-     * The pointer in client/screen pixels, for an action that has to place DOM
-     * at the pointer. Absent on every invocation whose event carries no client
-     * coordinates — a keystroke, a UI-driven trigger, a synthetic probe — so
-     * read it with a fallback rather than assuming a point.
-     *
-     * A view-mutating drag wants `drag.screenDelta`, not the difference of two
-     * of these: world deltas are self-referential mid-pan, and so is any delta
-     * taken across a view change.
-     */
-    screen?: Point2;
+/** An action's roles by id, e.g. `'handle.holdAngle'`. */
+type ModifierRoles = Readonly<Record<string, ModifierRole>>;
+/** Keys a tuning or a binding gives some of an action's roles. */
+type RoleRebinds = Readonly<Record<string, RoleKeys>>;
+/** Whether any of `keys` is held. */
+declare function keysHeld(keys: RoleKeys, modifiers: ModifierState, isMac: boolean): boolean;
+/**
+ * A reader for an action's own roles. It answers from `ctx.roles`, which the
+ * dispatcher resolves on every event, and falls back to the role's default
+ * keys where nothing resolved them: an invoker called directly, or a context
+ * a cancel-all built with no event.
+ */
+declare function roleReader<R extends ModifierRoles>(roles: R): (ctx: {
+    roles?: Readonly<Record<string, boolean>>;
     modifiers: ModifierState;
-    deps: ActionDeps;
-    drag?: {
-        start: WorldPoint;
-        current: WorldPoint;
-        delta: Point2;
-        /**
-         * Drag delta in the surface's own CSS pixels from the drag origin: client
-         * pixels, or through the host's `clientToLocal` where it supplies one, so
-         * a canvas under a scaled ancestor pans with the pointer. Use this — never
-         * `delta` — for any action whose effect
-         * mutates the viewport itself (pan, view-zoom), because world-space
-         * deltas become self-referential as the view shifts mid-drag.
-         *
-         * Absent when the underlying pointer events carried no
-         * `clientX`/`clientY`.
-         */
-        screenDelta?: Point2;
-        affordance?: AffordanceHit;
-        /**
-         * Full pointermove history for the current drag, in world space, with
-         * per-sample stylus state when the browser reported it.
-         * Available only during `onMove` and `onEnd` calls (not on `start`).
-         *
-         * During `onMove` this is the dispatcher's live accumulator, and it grows
-         * under you — read it, don't retain it. On `onEnd` it is a snapshot, so
-         * that is where an action that keeps the trail should take it.
-         */
-        points?: DragSample[];
-    };
-    wheel?: {
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-    };
-    /** One `pinch` sample: `scale` is a multiplier since the previous sample,
-     *  `rotation` degrees since it. See `PinchEvent`. */
-    pinch?: {
-        scale: number;
-        rotation: number;
-    };
-    multiTouch?: {
-        /** Canvas-local CSS pixels — see `MultiTouchEvent.centroid`. Neither
-         *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
-         *  it through `clientToWorld` removes the canvas origin twice. */
-        centroid: Point2;
-        /** Distance between the two primary pointers, in CSS pixels. */
-        spread: number;
-        /** Degrees the line between the two primary pointers has turned since
-         *  the gesture began, clockwise positive. It keeps counting past a half
-         *  turn. Zero where the events carry no `MultiTouchEvent.angle`. */
-        rotation: number;
-        /**
-         * Pinch-zoom geometry, populated while a multitouch handle is in flight.
-         * `startSpread` is the spread at the moment the gesture began.
-         */
-        pinch?: {
-            startSpread: number;
-            currentSpread: number;
-            /** Canvas-local, same as the enclosing `centroid`. */
-            centroid: Point2;
-        };
+}, id: keyof R & string) => boolean;
+
+/** The chrome an in-flight gesture paints beside the scene. */
+
+/**
+ * What a `polyline` overlay is, in a word — the narrowest thing an action can
+ * say about how its run should look without naming a paint.
+ *
+ * The named roles are the kit's; a painter maps each to a style and falls back
+ * to plain chrome for one it does not know, so a package outside core can coin
+ * its own and still be drawn.
+ */
+type OverlayRole = 
+/** Generic in-flight chrome — the marquee/lasso paint. */
+'chrome'
+/** A cut the gesture would make. */
+ | 'cut'
+/** An edge the gesture would author between two points. */
+ | 'connector'
+/** The stretch of a path a soft-selection drag reaches. */
+ | 'falloff'
+/** What a lock holds a dragged point to — a line, a circle. */
+ | 'lock'
+/** What a dragged item would be dropped on: the box it would go into. */
+ | 'target'
+/** Where a dragged item would land: a reorder's insertion bar. */
+ | 'insert'
+/** Where a dragged item is over and cannot land. */
+ | 'refused' | (string & {});
+/**
+ * What an in-flight gesture proposes to paint *beside* the scene, returned by
+ * `OngoingHandle.overlay()` — a marquee rect, a lasso trail, the outline of a
+ * shape being dragged out, the line a slice would cut along.
+ *
+ * Every variant is world geometry and nothing else — no `DrawCommand`, no
+ * color, no coordinate space to choose — so a surface rendering the same
+ * gesture some other way can still read it. The painter owns every style
+ * decision.
+ */
+type OngoingOverlay = {
+    kind: 'marquee';
+    start: {
+        x: number;
+        y: number;
     };
-    key?: {
-        key: string;
-        repeat: boolean;
+    current: {
+        x: number;
+        y: number;
     };
-    /** What a carry over the surface brings: its payload, as `startCarry` was
-     *  handed it. Present for every event of a `carry` binding's gesture. */
-    carry?: {
-        type: string;
-        value: unknown;
+    shiftHeld: boolean;
+} | {
+    kind: 'lasso';
+    vertices: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>;
+    current: {
+        x: number;
+        y: number;
     };
+    shiftHeld: boolean;
+} | {
     /**
-     * The view the input landed in, as the surface's view resolver assigned it:
-     * a view id, or `null` for the surface's own camera. Absent where no
-     * surface routed the input — a UI-driven trigger, a bare dispatcher.
+     * An open run of world points the gesture is proposing — a cut line, a
+     * routed connector. `role` is the whole of what an action says about
+     * appearance.
      */
-    viewId?: string | null;
+    kind: 'polyline';
+    /** At least two points. Anything shorter is dropped in resolution. */
+    points: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>;
+    /** What the run means. Omitted reads as {@link OverlayRole} `'chrome'`. */
+    role?: OverlayRole;
+} | {
     /**
-     * Per-invocation parameters. Populated by `ActionsRegistry.begin()` for
-     * UI-driven ongoing actions (color picker, opacity slider). The gesture
-     * dispatcher does not populate this field; gesture-driven actions receive
-     * params via `BindingOpts.params` on `start` (the `opts` arg).
+     * A round brush dragged through world points: the area it has swept so
+     * far, and its footprint at the last point. The radius is in screen
+     * pixels, so the footprint keeps its size at every zoom.
      */
-    params?: Record<string, unknown>;
+    kind: 'brush';
+    /** The brush's path so far, at least one point; the last is where it is now. */
+    points: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>;
+    radiusPx: number;
+} | {
     /**
-     * Which of the action's `modifierRoles` are held for this event, by role
-     * id. The dispatcher fills it on every event of a gesture whose action
-     * declares roles; absent otherwise. Read it through `roleReader`, which
-     * falls back to the roles' default keys where it is absent.
+     * Live insert-drag preview. Pre-commit there is no scene node to ghost
+     * via `previewIds()`/`previewPose()`, so insert paints its preview
+     * through the overlay instead.
+     *
+     * `bounds` is the AABB of the current drag (start/current normalized).
+     * `extras` is the per-kind extras the action already collected; the
+     * overlay renderer narrows on `shape` and casts the field shape it
+     * expects.
      */
-    roles?: Readonly<Record<string, boolean>>;
-}
+    kind: 'insertPreview';
+    /** Which preview the dispatcher's overlay draws. The kit's own shape
+     *  kinds are the ones it knows how to render; a consumer-defined kind
+     *  is legal and simply gets no live preview. */
+    shape: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    extras: unknown;
+    /** World-space point to paint a small "anchor" dot at, marking the
+     *  click point — for radial shapes (polygon/star), where no vertex
+     *  sits on it, and for any shape in center mode. */
+    anchorPoint?: {
+        x: number;
+        y: number;
+    };
+    /** World affines the shape will also be drawn under once it lands, by
+     *  the container it is drawn into: the preview is painted under each. */
+    copies?: readonly (readonly [number, number, number, number, number, number])[];
+} | {
+    /**
+     * Why the gesture cannot land where it is, in words for the user: a
+     * refusal's reason. A surface shows `text` beside the pointer, which
+     * `at` is, in world coordinates.
+     */
+    kind: 'reason';
+    at: {
+        x: number;
+        y: number;
+    };
+    text: string;
+};
+/** A handle's overlays as a list: empty when it has none. */
+declare function overlaysOf(handle: OngoingHandle): readonly OngoingOverlay[];
+
+/**
+ * The options a gesture binding hands the action it fires, and reading their params.
+ */
+
 /** Per-invocation options the dispatcher reads from a `GestureBinding`'s
  *  `opts` field and passes to `OngoingInvoker.start`. */
 interface BindingOpts {
@@ -568,6 +635,8 @@ interface BindingOpts {
      * For a key binding: live while the pointer is over the surface, whichever
      * canvas holds the keys, and only then. For a key that means "here" — a
      * magnifier's peek — on a page with more than one surface that hears it.
+     * A held key follows the pointer: one already down when it arrives presses
+     * the binding, and leaving releases it.
      */
     over?: boolean;
     /**
@@ -576,69 +645,279 @@ interface BindingOpts {
      */
     roles?: RoleRebinds;
     /** Screen travel, in CSS pixels, a drag makes before this binding's ongoing action starts, over the
-     *  action's own `dragThresholdPx`. See {@link OngoingInvoker.dragThresholdPx}. */
+     *  action's own `dragThresholdPx`. See `OngoingInvoker.dragThresholdPx`. */
     dragThresholdPx?: number;
 }
 /** Resolve `BindingOpts.params` to a concrete record (calling the thunk if
  *  needed). Returns `undefined` for absent params. */
 declare function resolveParams(params: BindingOpts['params']): Record<string, unknown> | undefined;
-/** The deps an action receives, composed per call from what it `requires`.
- *  Each name resolves to its {@link DepSchema} entry, and is absent when no
- *  source registered it; a name nothing has declared passes through as
- *  `unknown`. */
-interface ActionDeps extends Partial<DepSchema> {
-    [k: string]: unknown;
-}
 
-/** Handle returned from an `OngoingInvoker.start`. The dispatcher pumps
- *  `onMove` on subsequent input events of the same gesture and calls
- *  `onEnd` exactly once (with `'commit'` on natural completion or `'cancel'`
- *  on pointercancel / blur / escape). */
-interface OngoingHandle {
-    /**
-     * Optional logical action kind — a stable, human-readable tag the
-     * dispatcher exposes via `getActiveAction()`, e.g. `'marquee'`, `'move'`,
-     * `'resize'`, `'pan'`.
-     *
-     * When omitted, `getActiveAction().kind` reports `null` even though a
-     * handle is in flight.
-     */
-    kind?: string;
-    /**
-     * The cursor this gesture shows now, read after every move. Wins over the
-     * action's `activeCursor`, for a cursor that follows the gesture — the
-     * rotate glyph turning about its pivot. `undefined` defers to the action.
-     */
-    cursor?(): CursorSpec | undefined;
-    /**
-     * A move of the gesture. Return `'pass'` from a pointer drag's move to hand
-     * the drag off: the dispatcher ends this handle with `'cancel'`, offers the
-     * drag as it was pressed to every other candidate in rank order, and the one
-     * that takes it starts as if it had won the press, then sees this move. With
-     * no taker the drag is over. A drag never returns to an action that passed it.
-     */
-    onMove?(ctx: InvocationCtx): void | 'pass';
-    onEnd?(ctx: InvocationCtx, reason: 'commit' | 'cancel'): void;
-    /**
-     * Optional preview surface: the in-flight state the canvas's preview-ghost
-     * layer renders on top of the committed scene during the gesture.
-     *
-     * `previewIds()` enumerates the displaced node ids; `previewPose(id)`
-     * returns the interim pose for one of them (shape opaque — the canvas
-     * casts to its `TPose` parameter). `previewIds` returning `null`, or
-     * omitted, means "no preview this gesture". An id with no `previewPose`
-     * is shown at its effective pose: an action that publishes its poses to
-     * the scene's pose overrides, as move, resize and rotate do, leaves
-     * `previewPose` out rather than answering the same pose twice. `<SceneCanvas>`
-     * also shows both answers to the scene as overrides (core's
-     * `publishPreviews`), so what derives from a previewed node follows it.
-     */
-    previewIds?(): Iterable<string> | null;
-    previewPose?(id: string): unknown | null;
-    /**
-     * Subset of `previewIds()` the ghost layer paints at full opacity. The
-     * ghost alpha says "this is in flight under the pointer"; a node the
-     * gesture merely displaces — a layout sibling reflowing into its
+/**
+ * Invoker — pluggable invocation strategy for an Action.
+ *
+ * An Action's `invoker` field describes how it's run. `immediate` invokers
+ * fire once (delete, align, undo). `ongoing` invokers open a phase machine
+ * driven by the dispatcher (move, resize, pinch-zoom).
+ */
+
+/** A 2D point in either world or screen coordinates; geom's `Point`. */
+type Point2 = Point;
+/**
+ * A point in the space the dispatcher's `clientToWorld` maps the pointer into:
+ * the world, on a 2D canvas. A host with a camera of its own, such as a
+ * `@weasel-js/kernel3d` scene, passes identity, so there it is the pane's
+ * screen point and the deps reading it cast a ray through the camera they
+ * close over. Every world point the dispatcher hands out, and every dep
+ * payload it reaches, is one of these.
+ */
+type WorldPoint = Point2;
+/**
+ * Which UI affordance was hit at pointerdown. Populated by the dispatcher when
+ * the `affordanceAt` thunk is provided to `useGestureDispatcher`.
+ *
+ * `kind` is a discriminator string:
+ *   - `'handle:top-left'` / `'handle:top-right'` / `'handle:bottom-left'` /
+ *     `'handle:bottom-right'` — corner resize handles.
+ *   - `'handle:top'` / `'handle:right'` / `'handle:bottom'` / `'handle:left'` —
+ *     edge resize handles.
+ *   - `'rotate-handle'` — the rotation affordance.
+ *   - `'anchor:N'` — a path anchor at index N.
+ */
+interface AffordanceHit {
+    /** Discriminator string, e.g. `'handle:bottom-right'`. */
+    kind: string;
+    /** Id of whatever produced this hit — a kit affordance's `id`, or the
+     *  registered layer's id. */
+    owner?: string;
+    /** `'exclusive'` means no binding may act on this point unless its target
+     *  consults the affordance. `'shared'` (the default) competes on scope and
+     *  specificity as bindings always have. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+    /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
+    fixedPoint?: {
+        x: number;
+        y: number;
+    };
+    /** Which nodes this affordance belongs to. */
+    targetIds?: string[];
+    /** Set only when `kind` matches `'handle:*'`: which corner or edge stays
+     *  fixed during a resize; `'free'` on the axis an edge handle leaves alone. */
+    anchor?: ResizeAnchor;
+    /** Cursor to show while the pointer hovers this affordance (no gesture in
+     *  flight). Unset falls through to action-cursor prediction, then to the
+     *  active tool's cursor. */
+    cursor?: CursorSpec;
+    /**
+     * Free-form payload from whatever produced the hit, carried through to the
+     * matching action untouched. Kit affordances leave it unset; it exists for
+     * a registered layer's own chrome, where the hit-test already resolved
+     * *which* of its pieces was hit.
+     */
+    payload?: unknown;
+}
+/**
+ * One accumulated point on a drag trail: world-space position plus whatever
+ * stylus state the originating `PointerEvent` carried.
+ *
+ * The stylus fields are absent for mouse/touch on browsers that don't report
+ * them, and for synthetic events.
+ */
+interface DragSample extends WorldPoint {
+    /** 0..1. Mouse/touch report 0.5 while a button is held, per the spec. */
+    pressure?: number;
+    /** Degrees, ±90. Zero for mouse/touch. */
+    tiltX?: number;
+    /** Degrees, ±90. Zero for mouse/touch. */
+    tiltY?: number;
+}
+/** Per-invocation runtime context the dispatcher hands to an Invoker.
+ *  Gesture-kind-specific fields (`drag`, `wheel`, `multiTouch`, `key`) are
+ *  populated only for matching gesture kinds. */
+interface InvocationCtx {
+    world: WorldPoint;
+    /**
+     * The pointer in client/screen pixels, for an action that has to place DOM
+     * at the pointer. Absent on every invocation whose event carries no client
+     * coordinates — a keystroke, a UI-driven trigger, a synthetic probe — so
+     * read it with a fallback rather than assuming a point.
+     *
+     * A view-mutating drag wants `drag.screenDelta`, not the difference of two
+     * of these: world deltas are self-referential mid-pan, and so is any delta
+     * taken across a view change.
+     */
+    screen?: Point2;
+    modifiers: ModifierState;
+    deps: ActionDeps;
+    drag?: {
+        start: WorldPoint;
+        current: WorldPoint;
+        delta: Point2;
+        /**
+         * Drag delta in the surface's own CSS pixels from the drag origin: client
+         * pixels, or through the host's `clientToLocal` where it supplies one, so
+         * a canvas under a scaled ancestor pans with the pointer. Use this — never
+         * `delta` — for any action whose effect
+         * mutates the viewport itself (pan, view-zoom), because world-space
+         * deltas become self-referential as the view shifts mid-drag.
+         *
+         * Absent when the underlying pointer events carried no
+         * `clientX`/`clientY`.
+         */
+        screenDelta?: Point2;
+        affordance?: AffordanceHit;
+        /**
+         * Full pointermove history for the current drag, in world space, with
+         * per-sample stylus state when the browser reported it.
+         * Available only during `onMove` and `onEnd` calls (not on `start`).
+         *
+         * During `onMove` this is the dispatcher's live accumulator, and it grows
+         * under you — read it, don't retain it. On `onEnd` it is a snapshot, so
+         * that is where an action that keeps the trail should take it.
+         */
+        points?: DragSample[];
+    };
+    wheel?: {
+        deltaX: number;
+        deltaY: number;
+        deltaZ: number;
+    };
+    /** One `pinch` sample: `scale` is a multiplier since the previous sample,
+     *  `rotation` degrees since it. See `PinchEvent`. */
+    pinch?: {
+        scale: number;
+        rotation: number;
+    };
+    multiTouch?: {
+        /** Canvas-local CSS pixels — see `MultiTouchEvent.centroid`. Neither
+         *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
+         *  it through `clientToWorld` removes the canvas origin twice. */
+        centroid: Point2;
+        /** Distance between the two primary pointers, in CSS pixels. */
+        spread: number;
+        /** Degrees the line between the two primary pointers has turned since
+         *  the gesture began, clockwise positive. It keeps counting past a half
+         *  turn. Zero where the events carry no `MultiTouchEvent.angle`. */
+        rotation: number;
+        /**
+         * Pinch-zoom geometry, populated while a multitouch handle is in flight.
+         * `startSpread` is the spread at the moment the gesture began.
+         */
+        pinch?: {
+            startSpread: number;
+            currentSpread: number;
+            /** Canvas-local, same as the enclosing `centroid`. */
+            centroid: Point2;
+        };
+    };
+    key?: {
+        key: string;
+        repeat: boolean;
+    };
+    /** What a carry over the surface brings: its payload, as `startCarry` was
+     *  handed it. Present for every event of a `carry` binding's gesture. */
+    carry?: {
+        type: string;
+        value: unknown;
+    };
+    /**
+     * The view the input landed in, as the surface's view resolver assigned it:
+     * a view id, or `null` for the surface's own camera. Absent where no
+     * surface routed the input — a UI-driven trigger, a bare dispatcher.
+     */
+    viewId?: string | null;
+    /**
+     * Per-invocation parameters. Populated by `ActionsRegistry.begin()` for
+     * UI-driven ongoing actions (color picker, opacity slider). The gesture
+     * dispatcher does not populate this field; gesture-driven actions receive
+     * params via `BindingOpts.params` on `start` (the `opts` arg).
+     */
+    params?: Record<string, unknown>;
+    /**
+     * Which of the action's `modifierRoles` are held for this event, by role
+     * id. The dispatcher fills it on every event of a gesture whose action
+     * declares roles; absent otherwise. Read it through `roleReader`, which
+     * falls back to the roles' default keys where it is absent.
+     */
+    roles?: Readonly<Record<string, boolean>>;
+}
+
+/** The deps an action receives, composed per call from what it `requires`.
+ *  Each name resolves to its {@link DepSchema} entry, and is absent when no
+ *  source registered it; a name nothing has declared passes through as
+ *  `unknown`. */
+interface ActionDeps extends Partial<DepSchema> {
+    [k: string]: unknown;
+}
+
+/** Handle returned from an `OngoingInvoker.start`. The dispatcher pumps
+ *  `onMove` on subsequent input events of the same gesture and calls
+ *  `onEnd` exactly once (with `'commit'` on natural completion or `'cancel'`
+ *  on pointercancel / blur / escape). */
+interface OngoingHandle {
+    /**
+     * Optional logical action kind — a stable, human-readable tag the
+     * dispatcher exposes via `getActiveAction()`, e.g. `'marquee'`, `'move'`,
+     * `'resize'`, `'pan'`.
+     *
+     * When omitted, `getActiveAction().kind` reports `null` even though a
+     * handle is in flight.
+     */
+    kind?: string;
+    /**
+     * The cursor this gesture shows now, read after every move. Wins over the
+     * action's `activeCursor`, for a cursor that follows the gesture — the
+     * rotate glyph turning about its pivot. `undefined` defers to the action.
+     */
+    cursor?(): CursorSpec | undefined;
+    /**
+     * A move of the gesture. Return `'pass'` from a pointer drag's move to hand
+     * the drag off: the dispatcher ends this handle with `'cancel'`, offers the
+     * drag as it was pressed to every other candidate in rank order, and the one
+     * that takes it starts as if it had won the press, then sees this move. With
+     * no taker the drag is over. A drag never returns to an action that passed it.
+     */
+    onMove?(ctx: InvocationCtx): void | 'pass';
+    onEnd?(ctx: InvocationCtx, reason: 'commit' | 'cancel'): void;
+    /**
+     * Commit this gesture again, as it ended, with `params` in place of the ones it read: what lets a drag of an
+     * action declaring `params` be the tree's last operation, kept when its `onEnd('commit')` leaves one history
+     * entry. The keeper calls it after undoing that entry and putting back the selection the gesture started on.
+     * Recompute the commit from what the gesture recorded (its start state, the pointer as it ended or every move
+     * when the path taken matters, the modifiers held), never the live pointer, and commit one entry as `onEnd`
+     * did. `params` is every param the gesture resolved at its end with the panel's values laid over them; read
+     * them instead of `opts.params`. It may run any number of times. A gesture that cannot be recomputed
+     * faithfully leaves it out, and its action gets no panel.
+     */
+    replay?(params: Record<string, unknown>): void;
+    /**
+     * Params this gesture's commit took from what it edited rather than from its binding, read once it has ended:
+     * a held warp's own grid and tolerance, say, which the binding's settings do not reach. The last-operation
+     * panel shows them over the resolved params, and `replay` is handed them, so a change to one field leaves the
+     * rest as the gesture found them.
+     */
+    params?(): Readonly<Record<string, unknown>>;
+    /**
+     * Optional preview surface: the in-flight state the canvas's preview-ghost
+     * layer renders on top of the committed scene during the gesture.
+     *
+     * `previewIds()` enumerates the displaced node ids; `previewPose(id)`
+     * returns the interim pose for one of them (shape opaque — the canvas
+     * casts to its `TPose` parameter). `previewIds` returning `null`, or
+     * omitted, means "no preview this gesture". An id with no `previewPose`
+     * is shown at its effective pose: an action that publishes its poses to
+     * the scene's pose overrides, as move, resize and rotate do, leaves
+     * `previewPose` out rather than answering the same pose twice. `<SceneCanvas>`
+     * also shows both answers to the scene as overrides (core's
+     * `publishPreviews`), so what derives from a previewed node follows it.
+     */
+    previewIds?(): Iterable<string> | null;
+    previewPose?(id: string): unknown | null;
+    /**
+     * Subset of `previewIds()` the ghost layer paints at full opacity. The
+     * ghost alpha says "this is in flight under the pointer"; a node the
+     * gesture merely displaces — a layout sibling reflowing into its
      * destination slot — is not, and reads better settled. Honored at
      * subtree-root granularity.
      */
@@ -674,648 +953,33 @@ interface OngoingHandle {
 }
 /** Fire-once invocation. Runs to completion synchronously (or fires off an
  *  async side-effect; the registry doesn't wait). */
-interface ImmediateInvoker {
-    timing: 'immediate';
-    /** `params` carries the matched binding's opts.params. Invoked from the
-     *  command palette, or anywhere else with no per-binding context, `params`
-     *  is undefined; descriptors should default to a sensible variant.
-     *
-     *  Return `'pass'` when, having looked at the event, there is nothing to do
-     *  with it — a scroll already at the end of its range — and the dispatcher
-     *  walks on to the next matching binding, as for a declined `enabled()`.
-     *  Prediction cannot run the invoker, so it still names this action. */
-    run(deps: ActionDeps, params?: Record<string, unknown>): void | 'pass';
-}
-/** Phase-machine invocation. `start` opens the phase and returns the handle
- *  the dispatcher pumps. */
-interface OngoingInvoker {
-    timing: 'ongoing';
-    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle;
-    /**
-     * Screen travel, in CSS pixels, a pointer drag makes before the dispatcher calls `start`; a
-     * binding's own `dragThresholdPx` wins over it. Until then the gesture is held for this action and
-     * nothing else takes it, and a release short of it ends the gesture with `start` never called.
-     * Unset, the action starts once the press is a drag at all (`gestures.dragPx`).
-     */
-    dragThresholdPx?: number;
-}
-/** Pluggable invocation strategy for an Action. */
-type Invoker = ImmediateInvoker | OngoingInvoker;
-
-/**
- * GestureBinding — connects a GestureSpec to an Action id (with per-binding
- * options). Tools own arrays of these on their `bindings` field; ambient
- * gesture-bindings are registered globally.
- */
-
-/** An interaction: a gesture spec composed with the id of the action it
- *  invokes. Tools declare arrays of these; the dispatcher matches an incoming
- *  input event against them and runs the winner's action. */
-interface GestureBinding {
-    spec: GestureSpec;
-    actionId: string;
-    opts?: BindingOpts;
-}
-/**
- * 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;
-};
-/**
- * The whole of an action `actionBindings` reads. Routing needs this much and
- * none of `Action`'s palette fields, so it is the narrowest type the
- * dispatcher's binding walk can be written against.
- */
-interface BindingSource {
-    id: 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[];
-}
-/**
- * Flatten an action's `defaultBinding` into `GestureBinding`s. A bare
- * `GestureSpec` has `kind` at top level; the object form has `spec`.
- */
-declare function actionBindings(action: BindingSource): GestureBinding[];
-
-/** What a key no open keymap binds does: `'modal'` swallows it and leaves the
- *  keymap open; `'cascade'` closes the keymap and dispatches it as if none were. */
-type KeymapUnbound = 'modal' | 'cascade';
-/** What holds a level opened with `{ hold: true }` open: no key releases it, so it closes on Escape. */
-declare const KEYMAP_HOLD = "hold";
-/** One open level of a {@link KeymapStack}. */
-interface OpenKeymap {
-    readonly id: string;
-    readonly label: string;
-    /** The keymap's bindings as declared, for a hint to list. */
-    readonly bindings: readonly GestureBinding[];
-    /** The gesture id of the leader holding this level open, while it is held,
-     *  or {@link KEYMAP_HOLD}. */
-    readonly heldBy?: string;
-    /** Whether input arrived while the leader was held, so its release closes the level. */
-    readonly usedWhileHeld: boolean;
-}
-/** What the keymaps made of the raw input in progress: `'taken'` when one of
- *  them handled it, `'cascaded'` when it went on past them, `null` before either. */
-type KeymapVerdict = 'taken' | 'cascaded' | null;
-/** The keymaps open on one surface, innermost last; a canvas's `keymaps` dep. */
-interface KeymapStack {
-    /** Every open level, outermost first. */
-    open(): readonly OpenKeymap[];
-    innermost(): OpenKeymap | null;
-    /** Open a level. `heldBy` names what holds it open; `bindings` are what a hint lists. */
-    push(id: string, label: string, opts?: {
-        heldBy?: string;
-        bindings?: readonly GestureBinding[];
-    }): void;
-    /** Mark the levels the last raw input opened as held by `heldBy`: the key
-     *  that opened them is still down. False when it opened none. */
-    holdOpened(heldBy: string): boolean;
-    /** The leader `heldBy` came up: close its level, those above it and the
-     *  tapped ones beneath it if input arrived meanwhile, else leave it open
-     *  for one more input. */
-    release(heldBy: string): void;
-    /** Close the innermost level: Escape. */
-    closeInnermost(): void;
-    /** One of the keymaps took this input, or a pointer gesture went past them.
-     *  Marks held levels used and closes once-levels down to the innermost held one. */
-    inputSeen(): void;
-    /** A key no keymap binds was swallowed: held levels count it as input, and nothing closes. */
-    swallowed(): void;
-    /** This input went on past the keymaps: as `inputSeen`, remembered as a cascade. */
-    cascaded(): void;
-    /** What the keymaps made of the input in progress. */
-    verdict(): KeymapVerdict;
-    closeAll(): void;
-    /** Run `fn` as one raw input: closes made inside apply when it returns. Nests. */
-    batch<T>(fn: () => T): T;
-    subscribe(listener: () => void): () => void;
-    getVersion(): number;
-}
-/** An empty {@link KeymapStack}. `useGestureDispatcher` makes one per surface. */
-declare function createKeymapStack(): KeymapStack;
-
-/**
- * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
- * the actions-layer binding-scope / matchBest logic on top.
- */
-
-/** Where a binding came from, which is also its priority: a held hotkey beats
- *  the active tool, which beats bindings that are always in scope. */
-type BindingScope = 'ambient' | 'active' | 'hotkey';
-/** A binding paired with where it came from, ready to be matched against an
- *  event. */
-interface ScopedBinding {
-    binding: GestureBinding;
-    scope: BindingScope;
-    /** Id of the tool or contribution that declared this binding —
-     *  `'&'`-channel phase atoms resolve to it. `null` for a registered
-     *  action's own binding. */
-    ownerId: string | null;
-}
-/** The binding that won a match. */
-interface MatchResult {
-    binding: GestureBinding;
-    scope: BindingScope;
-    /** Id of the entry that declared the binding — propagated from
-     *  `ScopedBinding` so the dispatcher can record it as the handle owner. */
-    ownerId: string | null;
-}
-/**
- * True when a spec's target actually consults the affordance hit rather than
- * only the body classification. `kindOf` predicates are handed the hit;
- * `affordance:<k>` matches on its `kind`. The body-class strings (`'empty'`,
- * `'selected-body'`, `'unselected-body'`) and the `kind:` forms resolve from
- * `bodyTarget` / `bodyKind` and never see it.
- *
- * A predicate declares which it is with `readsAffordance`; one that declares
- * nothing, which only untyped code can write, counts as not reading the hit.
- */
-declare function targetConsultsAffordance(specTarget: TargetSpec | undefined): boolean;
-/** The first of {@link matchSorted}'s matches, or null when nothing matches. */
-declare function matchBest(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>): MatchResult | null;
-/**
- * Find every binding that matches the event, sorted by precedence
- * (best → worst). Ordering rules:
- *
- *   - Scopes by priority: hotkey > active > ambient.
- *   - Within a scope, more-specific bindings beat less-specific (see
- *     `specificity()`).
- *   - Among same-specificity bindings, first-declared wins.
- */
-declare function matchSorted(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, warn?: (message: string) => void): MatchResult[];
-/** {@link matchSorted}, plus what an exclusive claim on the event barred. */
-interface MatchOutcome {
-    matches: MatchResult[];
-    /** Bindings whose spec matched the event but which the claim barred, in
-     *  the same order `matches` uses. Filled only when `collectBarred` is set. */
-    barred: MatchResult[];
-    /** Owner of the exclusive claim, when one applied. */
-    claimOwner?: string;
-}
-/**
- * {@link matchSorted} that can also report the bindings an exclusive claim
- * kept out. Collecting them costs a spec match per barred binding, so it is
- * opt-in — the dispatcher asks only when it is recording.
- */
-declare function matchSortedWithBarred(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, opts?: {
-    collectBarred?: boolean;
-    warn?: (message: string) => void;
-}): MatchOutcome;
-
-/**
- * How one input was resolved: every binding that matched it, what each filter
- * dropped, the order the rest were ranked in and why, and what the walk down
- * that order did. The dispatcher fills one per input in dev builds, and
- * `Dispatcher.explain` fills one on request without invoking anything.
- *
- * Plain data — no functions, no live objects — so it can be kept in a trace
- * buffer, serialized, or built by hand as a fixture.
- */
-interface DispatchRecord {
-    kind: 'dispatch';
-    ts: number;
-    input: DispatchRecordInput;
-    /** Every binding whose spec matched the input, in matcher order, including
-     *  those a filter then dropped. */
-    matched: readonly RecordCandidate[];
-    dropped: readonly DroppedCandidate[];
-    /** The candidates that survived both filters, best first. */
-    ranked: readonly RankedCandidate[];
-    /** True when nothing was invoked: the record answers "what would happen". */
-    predicted: boolean;
-    /** Action id of the candidate that fired (or would), else `null`. */
-    fired: string | null;
-    outcome: 'handled' | 'unhandled';
-}
-/** The input a {@link DispatchRecord} describes, reduced to plain data. */
-interface DispatchRecordInput {
-    /** `InputEvent.kind`: `'key'`, `'pointerdown'`, `'wheel'`, … */
-    eventKind: string;
-    /** For `key` / `key-held` events, the key id (`'Escape'`, `' '`, `'a'`). */
-    key?: string;
-    modifiers: {
-        alt: boolean;
-        ctrl: boolean;
-        meta: boolean;
-        shift: boolean;
-    };
-    /** The view the input was routed to; `null` for the surface's own camera. */
-    viewId: string | null;
-    /** World point, for events that carry one. */
-    world?: {
-        x: number;
-        y: number;
-    };
-    /** Active mode id, when the host supplies a rule context. */
-    mode?: string;
-}
-/** One matched binding. */
-interface RecordCandidate {
-    actionId: string;
-    /** The binding's spec in route grammar — one per arg alternative. */
-    routes: readonly string[];
-    scope: BindingScope;
-    /** The tool or contribution that declared the binding; `null` for an action's own binding. */
-    ownerId: string | null;
-    /** Whether the binding's `views` names the routed view. */
-    namesView: boolean;
-    /** `specificity(spec)`: target, modifiers, phase, exact. */
-    specificity: readonly [number, number, number, number];
-    /** The action's `eligible` rule as text, when it declares one. */
-    eligible?: string;
-}
-/** A matched candidate a filter removed before ranking, and which filter. */
-type DroppedCandidate = 
-/** An exclusive claim on the input barred bindings that do not read the
- *  claim's affordance. */
-{
-    candidate: RecordCandidate;
-    filter: 'claim';
-    owner?: string;
-}
-/** The action's `eligible` rule does not hold. */
- | {
-    candidate: RecordCandidate;
-    filter: 'ineligible';
-    rule: string;
-};
-/** One field of the `specificity` tuple, in the order it is compared. */
-type SpecificityPart = 'target' | 'mods' | 'phase' | 'exact';
-/** The ranking step that put a candidate below the one before it. */
-type PlacedBy = {
-    step: 'first';
-}
-/** The one above names the routed view; this one does not. */
- | {
-    step: 'view';
-}
-/** The one above sits in a higher scope tier. */
- | {
-    step: 'tier';
-}
-/** Same tier; the one above is more specific in `part`. */
- | {
-    step: 'specificity';
-    part: SpecificityPart;
-}
-/** Tied; the one above is gated by an `eligible` rule that holds. */
- | {
-    step: 'context';
-}
-/** Tied on everything; registration order. */
- | {
-    step: 'order';
-};
-/** What the walk did with one ranked candidate. */
-type WalkStep = {
-    kind: 'fired';
-}
-/** Predicted records only: this candidate would fire. Nothing was started,
- *  so an ongoing action here may still bail at `start()` for real. */
- | {
-    kind: 'would-fire';
-}
-/** `enabled()` returned this reason. */
- | {
-    kind: 'declined';
-    reason: string;
-}
-/** An ongoing action's `start()` returned an empty handle, or an
- *  immediate one's `run()` returned `'pass'`. */
- | {
-    kind: 'empty-handle';
-}
-/** An ongoing action bound to a press-time `pointerDown` spec; refused. */
- | {
-    kind: 'misbound';
-}
-/** Its action was already tried higher up; each runs at most once. */
- | {
-    kind: 'duplicate';
-} | {
-    kind: 'no-such-action';
-}
-/** Below the winner; never asked. */
- | {
-    kind: 'not-asked';
-}
-/** Below the winner, asked anyway (`evaluateShadowed`), and it passed. */
- | {
-    kind: 'outranked';
-};
-/** A candidate that survived the filters: why it sits where it does, and
- *  what the walk did with it. */
-interface RankedCandidate {
-    candidate: RecordCandidate;
-    placedBy: PlacedBy;
-    walk: WalkStep;
-}
-
-/** One entry per "mode change" — a kit state transition that isn't a
- *  dispatched input event but explains why an input was (or wasn't) handled
- *  later. Pushed via {@link DispatchTrace.recordModeSwitch}. */
-interface ModeSwitchLogEntry {
-    kind: 'mode';
-    ts: number;
-    /** Logical mode name, e.g. `'editAnchors.editingId'`. */
-    mode: string;
-    from: string | null;
-    to: string | null;
-    /** Optional free-form context — `'enterPathEdit'`, `'exitPathEdit'`,
-     *  `'selection-dropped target'`, etc. */
-    detail?: string;
-}
-/** A trace entry: one {@link DispatchRecord} per resolved input, or a mode switch. */
-type TraceLogEntry = DispatchRecord | ModeSwitchLogEntry;
-/** A rolling buffer that records in a dev build, and in any build while something watches it. */
-interface TraceRing<T> {
-    /** Whether a push now keeps its entry. A caller building an entry checks first. */
-    recording(): boolean;
-    push(entry: T): void;
-    /** The entries pushed after `cursor`, oldest first, and the cursor to pass
-     *  next time. Start from 0. Entries the buffer has dropped are skipped. */
-    since(cursor: number): {
-        entries: T[];
-        cursor: number;
-    };
-    /** Turn recording on until the returned release is called. */
-    watch(): () => void;
-    /** Hear each kept push. Returns the unsubscribe. */
-    subscribe(listener: () => void): () => void;
-}
-/** A {@link TraceRing} keeping the last `limit` entries. `dev` defaults to the build's. */
-declare function createTraceRing<T>(limit?: number, dev?: boolean): TraceRing<T>;
-/** One canvas's dispatch trace. `useGestureDispatcher` makes one, puts it on
- *  every `DispatcherContext` it builds, and publishes it as the `dispatchTrace` dep. */
-interface DispatchTrace extends TraceRing<TraceLogEntry> {
-    recordModeSwitch(mode: string, from: string | null, to: string | null, detail?: string): void;
-    /** Offer the record for what a press at the pointer would do, built only
-     *  when {@link DispatchTrace.live} reads it. `null` withdraws it. */
-    setLive(explain: (() => DispatchRecord) | null): void;
-    live(): DispatchRecord | null;
-}
-/** A {@link DispatchTrace} keeping the last `limit` entries. `dev` defaults to the build's. */
-declare function createDispatchTrace(limit?: number, dev?: boolean): DispatchTrace;
-
-/**
- * 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;
-    /**
-     * How far the viewport is zoomed in, as one number — `1` at native scale.
-     *
-     * A scalar rather than the `View` this used to carry, because `zoomAtLeast`
-     * is the only selector that ever read one and a number is all it needs. A
-     * host whose viewport is a camera has no `View` to hand over and would
-     * otherwise have to invent one to use eligibility at all; it omits this
-     * instead, and `zoomAtLeast` declines rather than matching on a fiction.
-     */
-    readonly zoom?: number;
-    /** 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;
-    /** Whether a path is currently in anchor-edit mode. Read by the
-     *  `editingAnchors:` selector, which gates the path-edit chrome.
-     *
-     *  This is deliberately a fact about state, not about permission: the
-     *  anchor overlay and the anchor hit-test must agree, and the thing they
-     *  must agree on is "is there an edited path right now", which no
-     *  capability or mode id answers. A mode that allows `edits-anchors`
-     *  with nothing being edited should draw no anchors. Absent is treated
-     *  as false. */
-    readonly editingAnchors?: boolean;
-    /** Device facts — pointer coarseness, hover capability, density.
-     *
-     *  Absent (legacy ctx builders) is treated as
-     *  {@link DEFAULT_DEVICE_PROFILE}: a fine pointer that can hover, at
-     *  density 1. That is what the kit assumed before this field existed, so
-     *  an absent profile is behavior-preserving by construction. */
-    readonly device?: DeviceProfile;
-    /** The view the input being dispatched landed in — a view id, or `null`
-     *  for the surface's own camera. The dispatcher fills it; absent anywhere
-     *  else a rule is evaluated. */
-    readonly viewId?: string | null;
-}
-/** The live state a `RuleCtx` is assembled from — the chrome context plus
- *  what the active mode allows. */
-interface BuildRuleCtxArgs {
-    focused: boolean;
-    selection: readonly NodeId[];
-    multiActive: boolean;
-    modifiers: ModifierState;
-    action: {
-        kind: string | null;
-        id: string | null;
-    };
-    hover: NodeId | null;
-    /** See {@link RuleCtx.zoom}. */
-    zoom?: number;
-    mode: string;
-    allowedCapabilities: ReadonlySet<CapabilityTag>;
-    /** Optional — omitted means "resizable" (handles show). See {@link RuleCtx}. */
-    selectionResizable?: boolean;
-    /** Optional — omitted means "no path is being anchor-edited". */
-    editingAnchors?: boolean;
-    /** Optional — omitted means {@link DEFAULT_DEVICE_PROFILE}. */
-    device?: DeviceProfile;
-}
-/**
- * Capability set to assume when no mode registry is wired.
- *
- * "No modes configured" means *everything the default mode permits*, not
- * *nothing permitted*. The empty set is the wrong default: it makes every
- * `capability:` rule evaluate false, so a kit default written the
- * recommended way (capability rules outlive new modes; mode rules have to
- * be edited) would silently hide its chrome for every consumer that hasn't
- * opted into modality. `NORMAL.allows` plus the implicit tags is what a
- * mode-less canvas actually behaves like.
- */
-declare const DEFAULT_ALLOWED_CAPABILITIES: ReadonlySet<CapabilityTag>;
-/** Gather the current canvas and mode state into the context that action
- *  eligibility and chrome-visibility rules are evaluated against. */
-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.editingAnchors` — true while a path is in anchor-edit
-     *  mode. Absent flag is treated as `false`. */
-    editingAnchors?: boolean;
-    /** 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;
-    /** Matches `ctx.device.coarsePointer` — the primary pointer is imprecise
-     *  (touch, most styluses). Absent device is treated as `false`. */
-    coarsePointer?: boolean;
-    /** Matches `ctx.device.canHover` — the primary pointer can hover. Absent
-     *  device is treated as `true`. */
-    canHover?: 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;
-/** A rule that never passes. `any` of nothing is false. */
-declare const NEVER: Rule;
-/**
- * Render a {@link Rule} as a short human-readable string, for inspectors and
- * diagnostics that need to say WHICH rule decided something.
- *
- * ```
- * { capability: 'edits-page' }               → capability:edits-page
- * { all: [{ mode: 'normal' }, { focused: true }] } → all(mode:normal, focused:true)
- * { not: { selection: { empty: true } } }    → not(selection:empty=true)
- * { when: function hasPath() { … } }         → when(hasPath)
- * ```
- *
- * Never throws and always terminates.
- */
-declare function describeRule(rule: Rule): string;
-/** Evaluate a rule against a context. Pure, and cheap enough to run per
- *  frame for every piece of chrome. */
-declare function evaluate(rule: Rule, ctx: RuleCtx): boolean;
-/**
- * Composable eligibility predicate with a fluent surface. `cond(ctx)`
- * evaluates its `Rule` tree, carried at `.rule`; 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`. 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;
-}
-
-/**
- * Whether two rules can never hold at once — no `RuleCtx` passes both.
- *
- * Conservative: `true` is a proof, `false` means "may overlap". It reasons
- * about the selector values themselves (two different `mode`s, an empty
- * selection against a non-empty one, `focused: true` against `false`) and
- * through `all` / `any` / `not`; a `when` closure is opaque, so it overlaps
- * everything. The route-conflict check uses it to stay quiet about bindings
- * that share a tuple but are never eligible together.
- */
-declare function rulesExclusive(a: Rule, b: Rule): boolean;
-/**
- * Whether `rule` can hold while `mode` is active. Only its `mode` and
- * `capability` tests are settled by the mode; every other test could go either
- * way, so `false` is a proof and `true` means "may hold".
- */
-declare function ruleCanHoldIn(rule: Rule, mode: ActiveMode): boolean;
-
-/** The detected half of a profile — everything except the derived scale. */
-type DetectedDeviceFacts = Omit<DeviceProfile, 'targetScale'>;
-/**
- * Handle/hit multiplier applied on a coarse pointer.
- *
- * 8px handle → 14px; 24px rotation distance → 42px. Counting the
- * surrounding grab zone, that lands in the Apple HIG 44pt / Material 48dp
- * minimum-touch-target band. One constant so it is tunable in one place.
- */
-declare const COARSE_TARGET_SCALE = 1.75;
-/**
- * Fold consumer overrides over detected facts and derive `targetScale`.
- *
- * `targetScale` is re-derived AFTER the merge, so an override of
- * `coarsePointer` alone scales the chrome as expected. An explicit
- * `targetScale` override wins over the derivation.
- */
-declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?: Partial<DeviceProfile>): DeviceProfile;
-/**
- * Assumed when `matchMedia` is unavailable (SSR, jsdom) and used as the
- * absent-means value for `RuleCtx.device`.
- *
- * Derived from `resolveDeviceProfile` rather than hand-written, so it can
- * never drift from what the function would compute for the same facts. A
- * mouse-like device is the safe default: it is what the kit has always
- * assumed, so an absent profile changes nothing for existing consumers.
- */
-declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
+interface ImmediateInvoker {
+    timing: 'immediate';
+    /** `params` carries the matched binding's opts.params. Invoked from the
+     *  command palette, or anywhere else with no per-binding context, `params`
+     *  is undefined; descriptors should default to a sensible variant.
+     *
+     *  Return `'pass'` when, having looked at the event, there is nothing to do
+     *  with it — a scroll already at the end of its range — and the dispatcher
+     *  walks on to the next matching binding, as for a declined `enabled()`.
+     *  Prediction cannot run the invoker, so it still names this action. */
+    run(deps: ActionDeps, params?: Record<string, unknown>): void | 'pass';
+}
+/** Phase-machine invocation. `start` opens the phase and returns the handle
+ *  the dispatcher pumps. */
+interface OngoingInvoker {
+    timing: 'ongoing';
+    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle;
+    /**
+     * Screen travel, in CSS pixels, a pointer drag makes before the dispatcher calls `start`; a
+     * binding's own `dragThresholdPx` wins over it. Until then the gesture is held for this action and
+     * nothing else takes it, and a release short of it ends the gesture with `start` never called.
+     * Unset, the action starts once the press is a drag at all (`gestures.dragPx`).
+     */
+    dragThresholdPx?: number;
+}
+/** Pluggable invocation strategy for an Action. */
+type Invoker = ImmediateInvoker | OngoingInvoker;
 
 /**
  * A settings form an action carries: what a surface draws in place of a bare
@@ -1351,6 +1015,54 @@ declare function readActionSettings(action: Action, deps: ActionDeps | undefined
 /** The params a change of the field at `path` to `value` triggers the action with. */
 declare function actionSettingsParams(settings: ActionSettings, path: string, value: unknown): Record<string, unknown> | null;
 
+/**
+ * GestureBinding — connects a GestureSpec to an Action id (with per-binding
+ * options). Tools own arrays of these on their `bindings` field; ambient
+ * gesture-bindings are registered globally.
+ */
+
+/** An interaction: a gesture spec composed with the id of the action it
+ *  invokes. Tools declare arrays of these; the dispatcher matches an incoming
+ *  input event against them and runs the winner's action. */
+interface GestureBinding {
+    spec: GestureSpec;
+    actionId: string;
+    opts?: BindingOpts;
+}
+/**
+ * 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;
+};
+/**
+ * The whole of an action `actionBindings` reads. Routing needs this much and
+ * none of `Action`'s palette fields, so it is the narrowest type the
+ * dispatcher's binding walk can be written against.
+ */
+interface BindingSource {
+    id: 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[];
+}
+/**
+ * Flatten an action's `defaultBinding` into `GestureBinding`s. A bare
+ * `GestureSpec` has `kind` at top level; the object form has `spec`.
+ */
+declare function actionBindings(action: BindingSource): GestureBinding[];
+
 /** What content being routed brings to `Action.enabled`: a drop's or a
  *  paste's items, or a carry's payload with no items. */
 interface Carried {
@@ -1411,6 +1123,15 @@ interface ActionPresentation {
      *  triggers it with the params `settings.params` makes. Not combined with
      *  `variants`. */
     settings?: ActionSettings;
+    /** The params the invoker reads, as a form: one leaf per param, keyed by its name, with its label, range,
+     *  step, and default. A run that commits one history entry is kept as the tree's last operation, which a panel
+     *  draws as this form so the params can be changed after the fact: any immediate run, and a gesture whose
+     *  handle can `replay` (see `OngoingHandle.replay`). `ActionParamSchema` stays what types a tuning; this is
+     *  what a person sees.
+     *
+     *  A function answers the form for one run from the params it resolved, for an action whose params depend
+     *  on what it was asked to do (`insert`'s on the kind of shape), or `null` for a run with none to show. */
+    params?: PrefGroup | ((params: Readonly<Record<string, unknown>>) => PrefGroup | null);
 }
 /**
  * One entry a parametric action contributes to a bar, menu or palette.
@@ -1562,20 +1283,452 @@ interface ActionDispatch extends BindingSource {
 /**
  * Single registered action.
  */
-interface Action extends ActionDispatch, ActionPresentation {
-}
+interface Action extends ActionDispatch, ActionPresentation {
+}
+/**
+ * The whole of an actions registry the dispatcher reads. It walks the list
+ * once per event to build its actionId lookup and never mutates it, so the
+ * routing side depends on this rather than on `ActionsRegistry`, whose
+ * register / mute / trigger surface is the React provider's.
+ */
+interface ActionSource {
+    list(): readonly Action[];
+}
+/** `action`'s hover cursor for an invocation given `params`: its `cursor`,
+ *  asked when it is a function. */
+declare function actionCursor(action: Pick<Action, 'cursor'> | undefined, params?: Record<string, unknown>): CursorSpec | undefined;
+
+/**
+ * Tuning: what a host changes about an action it did not write — the params
+ * every invocation starts from, and bindings added beside the action's own —
+ * without restating the descriptor. `ActionsRegistry.tune` holds tunings and
+ * applies them to whatever descriptor is live for the id.
+ */
+
+/** An action's params, or a thunk read each time the action asks for them. */
+type ActionParams<P = Record<string, unknown>> = Partial<P> | (() => Partial<P>);
+/** A binding added for an action: a gesture alone, or a gesture with the
+ *  options it passes — the {@link BoundGesture} shape, its params typed. */
+type TunedBinding<P = Record<string, unknown>> = GestureSpec | {
+    spec: GestureSpec;
+    opts: Omit<BindingOpts, 'params'> & {
+        params?: ActionParams<P>;
+    };
+};
+/** What a host changes about one action. */
+interface ActionTuning<P = Record<string, unknown>> {
+    /** Params every invocation starts from. What a binding or a `trigger` call
+     *  passes is laid over them, so these fill in what it leaves out. A thunk is
+     *  read on every call, and an ongoing action resolving its `opts.params`
+     *  mid-gesture sees the value as it is then. */
+    params?: ActionParams<P>;
+    /** Bindings added after the action's own `defaultBinding`. */
+    bindings?: readonly TunedBinding<P>[];
+    /** Keys for some of the action's `modifierRoles`, by role id. A binding's
+     *  own `opts.roles` is laid over these. */
+    roles?: RoleRebinds;
+    /** Told the params the last-operation panel just set for the action, which hold for the rest of the session.
+     *  A tuning whose `params` thunk reads a host's store writes the ones it supplies back there, so the store, and
+     *  whatever draws it, says what the next run will use rather than overriding it. */
+    keep?(params: Readonly<Record<string, unknown>>): void;
+}
+/** `action` with each tuning applied in turn, a later one's params over an
+ *  earlier one's. Applying a tuning to a copy it already tuned changes nothing. */
+declare function tuneAction(action: Action, tunings: readonly ActionTuning[]): Action;
+
+/**
+ * The last operation: the latest run of an action that declares `params` and
+ * committed one history entry, kept so its params can be changed after the
+ * fact. A change undoes that entry and runs the action again in its place: an
+ * immediate action is run again with the params it was handed, and a gesture
+ * is replayed by its handle (`OngoingHandle.replay`).
+ */
+
+/** One operation that can still be adjusted. */
+interface LastOperation {
+    id: string;
+    /** What a panel titles it: the form's name, else the action's label. */
+    label: string;
+    /** The action's `params` form. */
+    schema: PrefGroup;
+    /** What it ran with, one value per leaf of `schema`, by the leaf's path. */
+    values: Readonly<Record<string, unknown>>;
+}
+/** The last operation of one actions tree, and the two things to do with it. */
+interface LastOperationStore {
+    /** The operation, or `null` once anything else reached the history, or it was dismissed. */
+    get(): LastOperation | null;
+    subscribe(listener: () => void): () => void;
+    /**
+     * Undo the operation's entry, put back the selection it ran on, and run it again with `patch` laid over its
+     * values (a gesture is replayed by its handle), keeping the entry that makes in place of the old one: the
+     * history, or the journal open on it, still holds one entry for it. The merged values become the action's
+     * params for the rest of the session, under any tuning, and each tuning that keeps them is handed them
+     * (`ActionTuning.keep`). Returns whether it ran.
+     */
+    adjust(patch: Readonly<Record<string, unknown>>): boolean;
+    /** Forget the operation; the scene and the history stay as they are. */
+    dismiss(): void;
+}
+/** Every selection a host holds, captured: calling what `take` returns puts all of it back. */
+interface SelectionSnapshotDep {
+    take(): () => void;
+}
+/** What the store reads from the scope an operation ran in. */
+interface LastOperationHost {
+    history(): History | null;
+    takeSelection(): (() => void) | null;
+    /** The params a run of `id` handed `given` starts with: every tuning's, `given` laid over them. */
+    paramsOf(id: string, given: Record<string, unknown> | undefined): Record<string, unknown>;
+    /** Run the action live for `id` here with `params`, as `trigger` would. */
+    rerun(id: string, params: Record<string, unknown>): void;
+    /** Hand `params`, which a panel change made `id`'s for the session, to each tuning of `id` that keeps them. */
+    keep(id: string, params: Readonly<Record<string, unknown>>): void;
+}
+/** The store one actions tree keeps at its root. `onSession` is told when an action's session params change. */
+declare class LastOperationKeeper implements LastOperationStore {
+    private readonly onSession;
+    private held;
+    private busy;
+    private readonly listeners;
+    private readonly session;
+    constructor(onSession: () => void);
+    readonly get: () => LastOperation | null;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly dismiss: () => void;
+    readonly adjust: (patch: Readonly<Record<string, unknown>>) => boolean;
+    /** The tuning holding `id`'s session params, laid under every other; `null` before it has any. */
+    sessionTuning(id: string): ActionTuning | null;
+    /** `action` with its run kept as the last operation when it commits one entry: an immediate action declaring
+     *  `params`, or an ongoing one declaring them whose gesture's handle can `replay`, and in either case only a
+     *  run its `params` answers a form for. Any other action comes back as it is. */
+    wrap(action: Action, host: LastOperationHost): Action;
+    /** `invoker` with each gesture whose handle can `replay` kept as the last operation when its commit leaves
+     *  one entry. The selection is taken at the press and the params at the release, as the commit read them. */
+    private ongoing;
+    private hold;
+    private remember;
+}
+
+/** What a key no open keymap binds does: `'modal'` swallows it and leaves the
+ *  keymap open; `'cascade'` closes the keymap and dispatches it as if none were. */
+type KeymapUnbound = 'modal' | 'cascade';
+/** What holds a level opened with `{ hold: true }` open: no key releases it, so it closes on Escape. */
+declare const KEYMAP_HOLD = "hold";
+/** One open level of a {@link KeymapStack}. */
+interface OpenKeymap {
+    readonly id: string;
+    readonly label: string;
+    /** The keymap's bindings as declared, for a hint to list. */
+    readonly bindings: readonly GestureBinding[];
+    /** The gesture id of the leader holding this level open, while it is held,
+     *  or {@link KEYMAP_HOLD}. */
+    readonly heldBy?: string;
+    /** Whether input arrived while the leader was held, so its release closes the level. */
+    readonly usedWhileHeld: boolean;
+}
+/** What the keymaps made of the raw input in progress: `'taken'` when one of
+ *  them handled it, `'cascaded'` when it went on past them, `null` before either. */
+type KeymapVerdict = 'taken' | 'cascaded' | null;
+/** The keymaps open on one surface, innermost last; a canvas's `keymaps` dep. */
+interface KeymapStack {
+    /** Every open level, outermost first. */
+    open(): readonly OpenKeymap[];
+    innermost(): OpenKeymap | null;
+    /** Open a level. `heldBy` names what holds it open; `bindings` are what a hint lists. */
+    push(id: string, label: string, opts?: {
+        heldBy?: string;
+        bindings?: readonly GestureBinding[];
+    }): void;
+    /** Mark the levels the last raw input opened as held by `heldBy`: the key
+     *  that opened them is still down. False when it opened none. */
+    holdOpened(heldBy: string): boolean;
+    /** The leader `heldBy` came up: close its level, those above it and the
+     *  tapped ones beneath it if input arrived meanwhile, else leave it open
+     *  for one more input. */
+    release(heldBy: string): void;
+    /** Close the innermost level: Escape. */
+    closeInnermost(): void;
+    /** One of the keymaps took this input, or a pointer gesture went past them.
+     *  Marks held levels used and closes once-levels down to the innermost held one. */
+    inputSeen(): void;
+    /** A key no keymap binds was swallowed: held levels count it as input, and nothing closes. */
+    swallowed(): void;
+    /** This input went on past the keymaps: as `inputSeen`, remembered as a cascade. */
+    cascaded(): void;
+    /** What the keymaps made of the input in progress. */
+    verdict(): KeymapVerdict;
+    closeAll(): void;
+    /** Run `fn` as one raw input: closes made inside apply when it returns. Nests. */
+    batch<T>(fn: () => T): T;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+}
+/** An empty {@link KeymapStack}. `useGestureDispatcher` makes one per surface. */
+declare function createKeymapStack(): KeymapStack;
+
+/**
+ * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
+ * the actions-layer binding-scope / matchBest logic on top.
+ */
+
+/** Where a binding came from, which is also its priority: a held hotkey beats
+ *  the active tool, which beats bindings that are always in scope. */
+type BindingScope = 'ambient' | 'active' | 'hotkey';
+/** A binding paired with where it came from, ready to be matched against an
+ *  event. */
+interface ScopedBinding {
+    binding: GestureBinding;
+    scope: BindingScope;
+    /** Id of the tool or contribution that declared this binding —
+     *  `'&'`-channel phase atoms resolve to it. `null` for a registered
+     *  action's own binding. */
+    ownerId: string | null;
+}
+/** The binding that won a match. */
+interface MatchResult {
+    binding: GestureBinding;
+    scope: BindingScope;
+    /** Id of the entry that declared the binding — propagated from
+     *  `ScopedBinding` so the dispatcher can record it as the handle owner. */
+    ownerId: string | null;
+}
+/**
+ * True when a spec's target actually consults the affordance hit rather than
+ * only the body classification. `kindOf` predicates are handed the hit;
+ * `affordance:<k>` matches on its `kind`. The body-class strings (`'empty'`,
+ * `'selected-body'`, `'unselected-body'`) and the `kind:` forms resolve from
+ * `bodyTarget` / `bodyKind` and never see it.
+ *
+ * A predicate declares which it is with `readsAffordance`; one that declares
+ * nothing, which only untyped code can write, counts as not reading the hit.
+ */
+declare function targetConsultsAffordance(specTarget: TargetSpec | undefined): boolean;
+/** The first of {@link matchSorted}'s matches, or null when nothing matches. */
+declare function matchBest(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>): MatchResult | null;
+/**
+ * Find every binding that matches the event, sorted by precedence
+ * (best → worst). Ordering rules:
+ *
+ *   - Scopes by priority: hotkey > active > ambient.
+ *   - Within a scope, more-specific bindings beat less-specific (see
+ *     `specificity()`).
+ *   - Among same-specificity bindings, first-declared wins.
+ */
+declare function matchSorted(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, warn?: (message: string) => void): MatchResult[];
+/** {@link matchSorted}, plus what an exclusive claim on the event barred. */
+interface MatchOutcome {
+    matches: MatchResult[];
+    /** Bindings whose spec matched the event but which the claim barred, in
+     *  the same order `matches` uses. Filled only when `collectBarred` is set. */
+    barred: MatchResult[];
+    /** Owner of the exclusive claim, when one applied. */
+    claimOwner?: string;
+}
+/**
+ * {@link matchSorted} that can also report the bindings an exclusive claim
+ * kept out. Collecting them costs a spec match per barred binding, so it is
+ * opt-in — the dispatcher asks only when it is recording.
+ */
+declare function matchSortedWithBarred(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, opts?: {
+    collectBarred?: boolean;
+    warn?: (message: string) => void;
+}): MatchOutcome;
+
 /**
- * The whole of an actions registry the dispatcher reads. It walks the list
- * once per event to build its actionId lookup and never mutates it, so the
- * routing side depends on this rather than on `ActionsRegistry`, whose
- * register / mute / trigger surface is the React provider's.
+ * How one input was resolved: every binding that matched it, what each filter
+ * dropped, the order the rest were ranked in and why, and what the walk down
+ * that order did. The dispatcher fills one per input in dev builds, and
+ * `Dispatcher.explain` fills one on request without invoking anything.
+ *
+ * Plain data — no functions, no live objects — so it can be kept in a trace
+ * buffer, serialized, or built by hand as a fixture.
  */
-interface ActionSource {
-    list(): readonly Action[];
+interface DispatchRecord {
+    kind: 'dispatch';
+    ts: number;
+    input: DispatchRecordInput;
+    /** Every binding whose spec matched the input, in matcher order, including
+     *  those a filter then dropped. */
+    matched: readonly RecordCandidate[];
+    dropped: readonly DroppedCandidate[];
+    /** The candidates that survived both filters, best first. */
+    ranked: readonly RankedCandidate[];
+    /** True when nothing was invoked: the record answers "what would happen". */
+    predicted: boolean;
+    /** Action id of the candidate that fired (or would), else `null`. */
+    fired: string | null;
+    outcome: 'handled' | 'unhandled';
 }
-/** `action`'s hover cursor for an invocation given `params`: its `cursor`,
- *  asked when it is a function. */
-declare function actionCursor(action: Pick<Action, 'cursor'> | undefined, params?: Record<string, unknown>): CursorSpec | undefined;
+/** The input a {@link DispatchRecord} describes, reduced to plain data. */
+interface DispatchRecordInput {
+    /** `InputEvent.kind`: `'key'`, `'pointerdown'`, `'wheel'`, … */
+    eventKind: string;
+    /** For `key` / `key-held` events, the key id (`'Escape'`, `' '`, `'a'`). */
+    key?: string;
+    modifiers: {
+        alt: boolean;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+    };
+    /** The view the input was routed to; `null` for the surface's own camera. */
+    viewId: string | null;
+    /** World point, for events that carry one. */
+    world?: {
+        x: number;
+        y: number;
+    };
+    /** Active mode id, when the host supplies a rule context. */
+    mode?: string;
+}
+/** One matched binding. */
+interface RecordCandidate {
+    actionId: string;
+    /** The binding's spec in route grammar — one per arg alternative. */
+    routes: readonly string[];
+    scope: BindingScope;
+    /** The tool or contribution that declared the binding; `null` for an action's own binding. */
+    ownerId: string | null;
+    /** Whether the binding's `views` names the routed view. */
+    namesView: boolean;
+    /** `specificity(spec)`: target, modifiers, phase, exact. */
+    specificity: readonly [number, number, number, number];
+    /** The action's `eligible` rule as text, when it declares one. */
+    eligible?: string;
+}
+/** A matched candidate a filter removed before ranking, and which filter. */
+type DroppedCandidate = 
+/** An exclusive claim on the input barred bindings that do not read the
+ *  claim's affordance. */
+{
+    candidate: RecordCandidate;
+    filter: 'claim';
+    owner?: string;
+}
+/** The action's `eligible` rule does not hold. */
+ | {
+    candidate: RecordCandidate;
+    filter: 'ineligible';
+    rule: string;
+};
+/** One field of the `specificity` tuple, in the order it is compared. */
+type SpecificityPart = 'target' | 'mods' | 'phase' | 'exact';
+/** The ranking step that put a candidate below the one before it. */
+type PlacedBy = {
+    step: 'first';
+}
+/** The one above names the routed view; this one does not. */
+ | {
+    step: 'view';
+}
+/** The one above sits in a higher scope tier. */
+ | {
+    step: 'tier';
+}
+/** Same tier; the one above is more specific in `part`. */
+ | {
+    step: 'specificity';
+    part: SpecificityPart;
+}
+/** Tied; the one above is gated by an `eligible` rule that holds. */
+ | {
+    step: 'context';
+}
+/** Tied on everything; registration order. */
+ | {
+    step: 'order';
+};
+/** What the walk did with one ranked candidate. */
+type WalkStep = {
+    kind: 'fired';
+}
+/** Predicted records only: this candidate would fire. Nothing was started,
+ *  so an ongoing action here may still bail at `start()` for real. */
+ | {
+    kind: 'would-fire';
+}
+/** `enabled()` returned this reason. */
+ | {
+    kind: 'declined';
+    reason: string;
+}
+/** An ongoing action's `start()` returned an empty handle, or an
+ *  immediate one's `run()` returned `'pass'`. */
+ | {
+    kind: 'empty-handle';
+}
+/** An ongoing action bound to a press-time `pointerDown` spec; refused. */
+ | {
+    kind: 'misbound';
+}
+/** Its action was already tried higher up; each runs at most once. */
+ | {
+    kind: 'duplicate';
+} | {
+    kind: 'no-such-action';
+}
+/** Below the winner; never asked. */
+ | {
+    kind: 'not-asked';
+}
+/** Below the winner, asked anyway (`evaluateShadowed`), and it passed. */
+ | {
+    kind: 'outranked';
+};
+/** A candidate that survived the filters: why it sits where it does, and
+ *  what the walk did with it. */
+interface RankedCandidate {
+    candidate: RecordCandidate;
+    placedBy: PlacedBy;
+    walk: WalkStep;
+}
+
+/** One entry per "mode change" — a kit state transition that isn't a
+ *  dispatched input event but explains why an input was (or wasn't) handled
+ *  later. Pushed via {@link DispatchTrace.recordModeSwitch}. */
+interface ModeSwitchLogEntry {
+    kind: 'mode';
+    ts: number;
+    /** Logical mode name, e.g. `'editAnchors.editingId'`. */
+    mode: string;
+    from: string | null;
+    to: string | null;
+    /** Optional free-form context — `'enterPathEdit'`, `'exitPathEdit'`,
+     *  `'selection-dropped target'`, etc. */
+    detail?: string;
+}
+/** A trace entry: one {@link DispatchRecord} per resolved input, or a mode switch. */
+type TraceLogEntry = DispatchRecord | ModeSwitchLogEntry;
+/** A rolling buffer that records in a dev build, and in any build while something watches it. */
+interface TraceRing<T> {
+    /** Whether a push now keeps its entry. A caller building an entry checks first. */
+    recording(): boolean;
+    push(entry: T): void;
+    /** The entries pushed after `cursor`, oldest first, and the cursor to pass
+     *  next time. Start from 0. Entries the buffer has dropped are skipped. */
+    since(cursor: number): {
+        entries: T[];
+        cursor: number;
+    };
+    /** Turn recording on until the returned release is called. */
+    watch(): () => void;
+    /** Hear each kept push. Returns the unsubscribe. */
+    subscribe(listener: () => void): () => void;
+}
+/** A {@link TraceRing} keeping the last `limit` entries. `dev` defaults to the build's. */
+declare function createTraceRing<T>(limit?: number, dev?: boolean): TraceRing<T>;
+/** One canvas's dispatch trace. `useGestureDispatcher` makes one, puts it on
+ *  every `DispatcherContext` it builds, and publishes it as the `dispatchTrace` dep. */
+interface DispatchTrace extends TraceRing<TraceLogEntry> {
+    recordModeSwitch(mode: string, from: string | null, to: string | null, detail?: string): void;
+    /** Offer the record for what a press at the pointer would do, built only
+     *  when {@link DispatchTrace.live} reads it. `null` withdraws it. */
+    setLive(explain: (() => DispatchRecord) | null): void;
+    live(): DispatchRecord | null;
+}
+/** A {@link DispatchTrace} keeping the last `limit` entries. `dev` defaults to the build's. */
+declare function createDispatchTrace(limit?: number, dev?: boolean): DispatchTrace;
 
 /** Which canvas hit a menu answers. Every field given must match. */
 interface MenuWhen {
@@ -1691,6 +1844,60 @@ declare function createMenuHost(src: MenuSources & {
     activeTool(): string | null;
 }): MenuHost;
 
+/**
+ * Tool options: the settings a tool's user adjusts while it is active, such as
+ * a brush's size and strength. A tool declares them as a prefs group whose
+ * number leaves are params of the action it binds; the host holds their values
+ * (`toolOptionValues` dep) and `<SceneCanvas>` tunes the action from them. A tool
+ * whose options name a size or a strength also gets step actions for them,
+ * bound to `[` `]` and `Shift+[` `Shift+]` while it is the active tool.
+ */
+
+/** How a step action moves one option: by a factor, or by an amount. */
+interface ToolOptionStep {
+    /** The option's key in `prefs`. */
+    option: string;
+    /** Each step multiplies (or divides) the value by this. */
+    times?: number;
+    /** Each step adds (or takes away) this. Used when `times` is absent. */
+    plus?: number;
+}
+/** What a tool declares about its options. See {@link ToolDef.options}. */
+interface ToolOptions {
+    /** The action the options are params of: each leaf of `prefs` is the param
+     *  of the same key. */
+    actionId: string;
+    /** The options, as number leaves keyed by param, with their bounds and
+     *  defaults. A host draws them from this (a group drawn `as: 'bar'` makes an
+     *  options row) and keeps their values in its prefs. */
+    prefs: PrefGroup;
+    /** The option `[` and `]` step: how large the tool acts. */
+    size?: ToolOptionStep;
+    /** The option `Shift+[` and `Shift+]` step: how hard it acts. */
+    strength?: ToolOptionStep;
+}
+/** Where a host keeps tool options' values: the `toolOptionValues` dep. */
+interface ToolOptionValues {
+    /** `toolId`'s values, sparse: an option missing from it reads its default.
+     *  The same object until one of them changes. */
+    get(toolId: string): Readonly<Record<string, number>>;
+    set(toolId: string, option: string, value: number): void;
+    subscribe(listener: () => void): () => void;
+}
+/** A {@link ToolOptionValues} held in memory, for a host that keeps no prefs. */
+declare function createToolOptionValues(): ToolOptionValues;
+/** Every option's value for `toolId`: what `values` holds, else its default. */
+declare function toolOptionParams(toolId: string, options: ToolOptions, values: ToolOptionValues | undefined): Record<string, number>;
+/** `value` moved one step up (`dir` 1) or down (-1), within the leaf's bounds
+ *  and rounded to its `step`. */
+declare function steppedOption(leaf: PrefNumber, value: number, step: ToolOptionStep, dir: 1 | -1): number;
+/** The step actions for `toolId`'s size and strength options, and the key
+ *  bindings that reach them. */
+declare function toolOptionSteps(toolId: string, toolLabel: string, options: ToolOptions): {
+    actions: Action[];
+    bindings: GestureBinding[];
+};
+
 /**
  * The tree both input registries hang on. A provider is a root; every canvas
  * mounts a scope under the registry in scope; a yoke sits between the two. A
@@ -1791,40 +1998,6 @@ declare function ActiveToolContextProviderIfRoot({ children, }: {
     children: ReactNode;
 }): react.JSX.Element;
 
-/**
- * Tuning: what a host changes about an action it did not write — the params
- * every invocation starts from, and bindings added beside the action's own —
- * without restating the descriptor. `ActionsRegistry.tune` holds tunings and
- * applies them to whatever descriptor is live for the id.
- */
-
-/** An action's params, or a thunk read each time the action asks for them. */
-type ActionParams<P = Record<string, unknown>> = Partial<P> | (() => Partial<P>);
-/** A binding added for an action: a gesture alone, or a gesture with the
- *  options it passes — the {@link BoundGesture} shape, its params typed. */
-type TunedBinding<P = Record<string, unknown>> = GestureSpec | {
-    spec: GestureSpec;
-    opts: Omit<BindingOpts, 'params'> & {
-        params?: ActionParams<P>;
-    };
-};
-/** What a host changes about one action. */
-interface ActionTuning<P = Record<string, unknown>> {
-    /** Params every invocation starts from. What a binding or a `trigger` call
-     *  passes is laid over them, so these fill in what it leaves out. A thunk is
-     *  read on every call, and an ongoing action resolving its `opts.params`
-     *  mid-gesture sees the value as it is then. */
-    params?: ActionParams<P>;
-    /** Bindings added after the action's own `defaultBinding`. */
-    bindings?: readonly TunedBinding<P>[];
-    /** Keys for some of the action's `modifierRoles`, by role id. A binding's
-     *  own `opts.roles` is laid over these. */
-    roles?: RoleRebinds;
-}
-/** `action` with each tuning applied in turn, a later one's params over an
- *  earlier one's. Applying a tuning to a copy it already tuned changes nothing. */
-declare function tuneAction(action: Action, tunings: readonly ActionTuning[]): Action;
-
 /**
  * The entries an action contributes to a bar, menu or palette — one per
  * variant, or the action itself when it declares none.
@@ -3045,7 +3218,9 @@ declare function modeShortcutSpec(shortcut: string): KeySpec;
  * The bindings ride the hotkey tier, so leaving a mode outranks what the same
  * key does otherwise (Escape clearing the selection), and they yield while a
  * gesture is in flight, so Escape mid-drag still cancels the drag first. Keys
- * typed into an editable element never reach them.
+ * typed into an editable element never reach them. A mode's `exit` and
+ * `cancel`, pressed while a tool other than its `defaultTool` is active,
+ * return to that tool instead (`returnToModeDefault`), so the next press leaves.
  */
 declare function modeShortcuts(registry: ModeRegistry, handlers: ModeShortcutHandlers): Contribution<never>;
 
@@ -3203,6 +3378,10 @@ interface Tool<TOverlay = KernelOverlay> extends Contribution<TOverlay> {
      *  `opts.params.toolId` set so the invoker knows which tool to switch to).
      *  A tool with none has no activation key. */
     keybinding?: ToolKeybinding;
+    /** The settings its user adjusts while it is active; see `ToolDef.options`. */
+    options?: ToolOptions;
+    /** Chrome hidden while this is the active tool; see `ToolDef.hides`. */
+    hides?: readonly string[];
     cursor?: CursorSpec | (() => CursorSpec);
     /** The tool became live: it took the active slot, or its `hotkey` went
      *  down, while it held neither. A lifecycle moment has no pointer, hit or
@@ -3250,6 +3429,17 @@ interface ToolDef<TOverlay = KernelOverlay> {
     actions?: Action[];
     /** Menus this tool adds while it is active. */
     menus?: MenuDef[];
+    /**
+     * The settings its user adjusts while it is active, as params of the action
+     * it binds: a brush's size and strength. `<SceneCanvas>` tunes that action
+     * from the `toolOptionValues` dep, and `defineTool` adds step actions for the
+     * size and strength, keyed to `[` `]` and `Shift+[` `Shift+]` while this is
+     * the active tool. See {@link import('./toolOptions').ToolOptions}.
+     */
+    options?: ToolOptions;
+    /** Chrome ids (`'selection.resize-handles'`) hidden, and not hit-tested,
+     *  while this is the active tool: chrome its own controls stand in for. */
+    hides?: readonly string[];
     /** Hook name as exported from the kit barrel (e.g. `'useHandTool'`).
      *  Set by built-in hooks for inspector / debugging. Consumer-authored
      *  tools may set this to surface their hook name; omitted is fine.
@@ -3306,6 +3496,15 @@ interface ToolDef<TOverlay = KernelOverlay> {
  */
 declare function defineTool<TOverlay = KernelOverlay>(def: ToolDef<TOverlay>): Tool<TOverlay>;
 
+/**
+ * Make the active mode's default tool active when another tool holds the
+ * slot, and say whether it did. A key that leaves a mode calls this first, so
+ * one press returns to the mode's tool and the next leaves: the mode shortcuts'
+ * `exit` and `cancel`, and core's `exitPathEdit`. Reads the `activeTool` and
+ * `modeDefaultTool` deps, which the caller must require.
+ */
+declare function returnToModeDefault(deps: ActionDeps | undefined): boolean;
+
 /**
  * Tool sets: a named group of tool ids, the unit a consumer opts into whole.
  * A set names ids, never tools, because a tool is built by a hook that holds
@@ -3754,12 +3953,20 @@ declare function pickMenu(defs: readonly MenuDef[], hit: MenuHit): MenuDef | und
 interface DepSchema {
     /** Currently active tool id + hotkey-hold stack. */
     activeTool: ActiveToolContextValue;
+    /** Where the host keeps its tools' option values (`ToolDef.options`).
+     *  Absent: every option is its default, and the step actions do nothing. */
+    toolOptionValues?: ToolOptionValues;
     /** The menu host of the `ActionsProvider` in scope. */
     menuHost?: MenuHost;
     /** The canvas's dispatch trace, for a dep to record a mode switch into. */
     dispatchTrace?: DispatchTrace;
     /** The keymaps open on the canvas: what a leader opens and a hint reads. */
     keymaps?: KeymapStack;
+    /** Every selection the host holds, captured so the last operation can put it back before it reruns. */
+    selectionSnapshot?: SelectionSnapshotDep;
+    /** The tool the active mode starts on (`ModeDefinition.defaultTool`), when the canvas mounts it;
+     *  else null. `<SceneCanvas>` sources it. */
+    modeDefaultTool?: () => string | null;
 }
 /** Every dep name declared by anything that has merged into {@link DepSchema}. */
 type DepName = keyof DepSchema;
@@ -3807,4 +4014,4 @@ type KernelOverlay = OverlaySchema extends {
     overlay: infer O;
 } ? O : unknown;
 
-export { type BindingOverrides as $, type Action as A, type BoundGesture as B, type Contribution as C, type DepRegistry as D, type ActionParams as E, type ActionPresentation as F, type ActionSettings as G, type ActionSettingsState as H, type ActionShortcut as I, type ActionSource as J, type KeymapDescription as K, type LongPressOptions as L, type MenuHost as M, type NodeId as N, type OverlayPosition as O, type ActionTuning as P, type ActionTunings as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type ActionUnavailable as U, type ActionsProp as V, type WorldPoint as W, type AnyTool as X, type AssemblyInputs as Y, BROWSER_RESERVED_CHORDS as Z, type BindingOpts as _, type DepName as a, type ModeSwitchLogEntry as a$, type BindingScope as a0, type BindingSource as a1, type BodyPredicate as a2, type Bounds as a3, type BuildRuleCtxArgs as a4, COARSE_TARGET_SCALE as a5, type CaptureGestureOptions as a6, type CaptureKeyOptions as a7, type CaptureKind as a8, type CapturedSpec as a9, type HandleKind as aA, type HitShape as aB, type HotkeyTrigger as aC, INGEST_STRING_MIMES as aD, type ImmediateInvoker as aE, type ImmediateParams as aF, type InvocationCtx as aG, type Invoker as aH, KEYMAP_HOLD as aI, type KeyBinding as aJ, type KeyReach as aK, type KeymapDef as aL, type KeymapRow as aM, type KeymapStack as aN, type KeymapUnbound as aO, type KeymapVerdict as aP, type LongPressState as aQ, type LongPressStore as aR, type MatchOutcome as aS, type MatchResult as aT, type MenuAccess as aU, type MenuCustomAt as aV, type MenuHit as aW, type MenuOpenRequest as aX, type MenuSources as aY, type MenuWhen as aZ, type ModeShortcutHandlers as a_, type Carried as aa, type Carry as ab, type CarryCallbacks as ac, type CarryPayload as ad, type CarryPointer as ae, type CarryStage as af, type Condition as ag, type Conflict as ah, type ContributionChrome as ai, type ContributionDeps as aj, type ContributionRouting as ak, DEFAULT_ALLOWED_CAPABILITIES as al, DEFAULT_DEVICE_PROFILE as am, type DebugSink as an, type DepListing as ao, type DetectedDeviceFacts as ap, type DeviceProfile as aq, type DispatchRecord as ar, type DispatchRecordInput as as, type DispatcherContext as at, type DragSample as au, type DroppedCandidate as av, type Eligibility as aw, type EligibilityState as ax, type GestureBinding as ay, type GestureKitSettings as az, type DepSource as b, assembleEntries as b$, type ModifierRole as b0, type ModifierRoles as b1, type ModifierState as b2, NEVER as b3, type OngoingHandle as b4, type OngoingInvoker as b5, type OngoingOverlay as b6, type OpenKeymap as b7, type OpenMenu as b8, type OverlayRole as b9, type SelectionApi as bA, type Selector as bB, type SpecificityPart as bC, TOOL_OFFHAND_ID as bD, type ToolDef as bE, type ToolEntry as bF, type ToolKeybinding as bG, type ToolModifiers as bH, type ToolOffhandBindingSpec as bI, type ToolPresentation as bJ, type ToolScopes as bK, type ToolSet as bL, type ToolSlot as bM, type TraceLogEntry as bN, type TraceRing as bO, type TunedBinding as bP, type UiOngoingControl as bQ, type ViewportGestureKind as bR, type WalkStep as bS, actionBindings as bT, actionCursor as bU, actionItemTitle as bV, actionItems as bW, actionSettingsParams as bX, actionShortcuts as bY, actionsTagged as bZ, admitIngestMime as b_, type OverlaySchema as ba, type OwnedMenuDef as bb, PREDICATE_TARGET as bc, type PendingIngestItem as bd, type PendingLongPress as be, type PlacedBy as bf, type Point2 as bg, type PointerSession as bh, type PointerSessionCallbacks as bi, type PointerSessionCancelReason as bj, type PointerSessionOptions as bk, type RankedCandidate as bl, type RecordCandidate as bm, type RegistryEntry as bn, type ReservedChord as bo, type ResizeAnchor as bp, type ResolveAllOptions as bq, type ResolveOnlyResult as br, type ResolvedBindingOverrides as bs, type ResolvedCandidate as bt, type RoleKeys as bu, type RoleRebinds as bv, type Rule as bw, type ScopedBinding as bx, type ScratchKey as by, type ScratchStore as bz, type ActionDeps as c, matchSortedWithBarred as c$, bindingId as c0, browserReservedChord as c1, buildDepsFromRequires as c2, buildRouteRegistry as c3, buildRuleCtx as c4, buildToolOffhandBindings as c5, captureGesture as c6, captureKey as c7, clientToCanvas as c8, clientToCanvasRect as c9, isControlHandle as cA, isCornerWidget as cB, isDebugEnabled as cC, isEmpty as cD, isPathEditPart as cE, isResizeHandle as cF, isRotateHandle as cG, isSegment as cH, isSelectedBody as cI, isTool as cJ, isToolSet as cK, isUnselectedBody as cL, itemTypesFromDataTransfer as cM, itemsFromClipboardData as cN, itemsFromDataTransfer as cO, itemsFromFiles as cP, keySpecShortcut as cQ, keymapContribution as cR, keymapLeaderBindingId as cS, keymapLeaderId as cT, keymapShortcuts as cU, keysHeld as cV, liveScope as cW, makeToolOffhandAction as cX, matchActionItem as cY, matchBest as cZ, matchSorted as c_, createDepRegistry as ca, createDispatchTrace as cb, createDispatcher as cc, createKeymapStack as cd, createLongPressStore as ce, createMenuHost as cf, createTraceRing as cg, defineTool as ch, deleteScratch as ci, describeKeymap as cj, describeRule as ck, dlog as cl, dwarn as cm, evaluate as cn, evaluateActive as co, evaluateEnabled as cp, findConflicts as cq, getScratch as cr, heldKeySpec as cs, historyKey as ct, holdPreview as cu, holdPreviewId as cv, isAnchor as cw, isAnchorOrControl as cx, isBalanceGrip as cy, isBody as cz, type ActionsRegistry as d, matchesKeyBinding as d0, mergeContributions as d1, mergeMenuDefs as d2, modeShortcutSpec as d3, modeShortcuts as d4, modifierStateOf as d5, multiTouchGestureId as d6, offhandKeyFor as d7, openPointerSession as d8, overlaysOf as d9, validateActionDefaultBinding as dA, validateActionId as dB, withoutTools as dC, overriddenBindings as da, pendingKindOf as db, pickMenu as dc, pointerGestureId as dd, readActionSettings as de, reportRouteConflicts as df, resolveBindingOverrides as dg, resolveDeviceProfile as dh, resolveMenu as di, resolveParams as dj, resolveSchemaMenu as dk, roleReader as dl, routesForSpec as dm, ruleCanHoldIn as dn, rulesExclusive as dp, scopeBindings as dq, scratchKey as dr, setScratch as ds, startCarry as dt, taggedActionItems as du, targetConsultsAffordance as dv, toolIdsOf as dw, toolSet as dx, toolSetHas as dy, tuneAction as dz, ActionDisabledReason as e, type ActionVariant as f, type MenuDef as g, DepNode as h, type KernelOverlay as i, type Tool as j, ActiveToolContextProvider as k, ActiveToolContextProviderIfRoot as l, type ActiveToolContextProviderProps as m, type ActiveToolContextValue as n, useOptionalActiveToolContext as o, type Dispatcher as p, type AffordanceHit as q, type DispatchTrace as r, type DepSchema as s, ALWAYS as t, useActiveToolContext as u, type ActionDispatch as v, type ActionEnabledResult as w, type ActionEntry as x, type ActionItem as y, type ActionParamSchema as z };
+export { type AssemblyInputs as $, type Action as A, type BoundGesture as B, type Contribution as C, type DepRegistry as D, type ActionEntry as E, type ActionItem as F, type ActionParamSchema as G, type ActionParams as H, type ActionPresentation as I, type ActionSettings as J, type KeymapDescription as K, LastOperationKeeper as L, type MenuHost as M, type NodeId as N, type OverlayPosition as O, type ActionSettingsState as P, type ActionShortcut as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type ActionSource as U, type ActionTuning as V, type WorldPoint as W, type ActionTunings as X, type ActionUnavailable as Y, type ActionsProp as Z, type AnyTool as _, type DepName as a, type MenuSources as a$, BROWSER_RESERVED_CHORDS as a0, type BindingOpts as a1, type BindingOverrides as a2, type BindingScope as a3, type BindingSource as a4, type BodyPredicate as a5, type Bounds as a6, type BuildRuleCtxArgs as a7, COARSE_TARGET_SCALE as a8, type CaptureGestureOptions as a9, type EligibilityState as aA, type GestureBinding as aB, type GestureKitSettings as aC, type HandleKind as aD, type HitShape as aE, type HotkeyTrigger as aF, INGEST_STRING_MIMES as aG, type ImmediateInvoker as aH, type ImmediateParams as aI, type InvocationCtx as aJ, type Invoker as aK, KEYMAP_HOLD as aL, type KeyBinding as aM, type KeyReach as aN, type KeymapDef as aO, type KeymapRow as aP, type KeymapStack as aQ, type KeymapUnbound as aR, type KeymapVerdict as aS, type LongPressState as aT, type LongPressStore as aU, type MatchOutcome as aV, type MatchResult as aW, type MenuAccess as aX, type MenuCustomAt as aY, type MenuHit as aZ, type MenuOpenRequest as a_, type CaptureKeyOptions as aa, type CaptureKind as ab, type CapturedSpec as ac, type Carried as ad, type Carry as ae, type CarryCallbacks as af, type CarryPayload as ag, type CarryPointer as ah, type CarryStage as ai, type Condition as aj, type Conflict as ak, type ContributionChrome as al, type ContributionDeps as am, type ContributionRouting as an, DEFAULT_ALLOWED_CAPABILITIES as ao, DEFAULT_DEVICE_PROFILE as ap, type DebugSink as aq, type DepListing as ar, type DetectedDeviceFacts as as, type DeviceProfile as at, type DispatchRecord as au, type DispatchRecordInput as av, type DispatcherContext as aw, type DragSample as ax, type DroppedCandidate as ay, type Eligibility as az, type DepSource as b, actionCursor as b$, type MenuWhen as b0, type ModeShortcutHandlers as b1, type ModeSwitchLogEntry as b2, type ModifierRole as b3, type ModifierRoles as b4, type ModifierState as b5, NEVER as b6, type OngoingHandle as b7, type OngoingInvoker as b8, type OngoingOverlay as b9, type ScopedBinding as bA, type ScratchKey as bB, type ScratchStore as bC, type SelectionApi as bD, type SelectionSnapshotDep as bE, type Selector as bF, type SpecificityPart as bG, TOOL_OFFHAND_ID as bH, type ToolDef as bI, type ToolEntry as bJ, type ToolKeybinding as bK, type ToolModifiers as bL, type ToolOffhandBindingSpec as bM, type ToolOptionStep as bN, type ToolOptionValues as bO, type ToolOptions as bP, type ToolPresentation as bQ, type ToolScopes as bR, type ToolSet as bS, type ToolSlot as bT, type TraceLogEntry as bU, type TraceRing as bV, type TunedBinding as bW, type UiOngoingControl as bX, type ViewportGestureKind as bY, type WalkStep as bZ, actionBindings as b_, type OpenKeymap as ba, type OpenMenu as bb, type OverlayRole as bc, type OverlaySchema as bd, type OwnedMenuDef as be, PREDICATE_TARGET as bf, type PendingIngestItem as bg, type PendingLongPress as bh, type PlacedBy as bi, type Point2 as bj, type PointerSession as bk, type PointerSessionCallbacks as bl, type PointerSessionCancelReason as bm, type PointerSessionOptions as bn, type RankedCandidate as bo, type RecordCandidate as bp, type RegistryEntry as bq, type ReservedChord as br, type ResizeAnchor as bs, type ResolveAllOptions as bt, type ResolveOnlyResult as bu, type ResolvedBindingOverrides as bv, type ResolvedCandidate as bw, type RoleKeys as bx, type RoleRebinds as by, type Rule as bz, type ActionDeps as c, keymapLeaderId as c$, actionItemTitle as c0, actionItems as c1, actionSettingsParams as c2, actionShortcuts as c3, actionsTagged as c4, admitIngestMime as c5, assembleEntries as c6, bindingId as c7, browserReservedChord as c8, buildDepsFromRequires as c9, heldKeySpec as cA, historyKey as cB, holdPreview as cC, holdPreviewId as cD, isAnchor as cE, isAnchorOrControl as cF, isBalanceGrip as cG, isBody as cH, isControlHandle as cI, isCornerWidget as cJ, isDebugEnabled as cK, isEmpty as cL, isPathEditPart as cM, isResizeHandle as cN, isRotateHandle as cO, isSegment as cP, isSelectedBody as cQ, isTool as cR, isToolSet as cS, isUnselectedBody as cT, itemTypesFromDataTransfer as cU, itemsFromClipboardData as cV, itemsFromDataTransfer as cW, itemsFromFiles as cX, keySpecShortcut as cY, keymapContribution as cZ, keymapLeaderBindingId as c_, buildRouteRegistry as ca, buildRuleCtx as cb, buildToolOffhandBindings as cc, captureGesture as cd, captureKey as ce, clientToCanvas as cf, clientToCanvasRect as cg, createDepRegistry as ch, createDispatchTrace as ci, createDispatcher as cj, createKeymapStack as ck, createLongPressStore as cl, createMenuHost as cm, createToolOptionValues as cn, createTraceRing as co, defineTool as cp, deleteScratch as cq, describeKeymap as cr, describeRule as cs, dlog as ct, dwarn as cu, evaluate as cv, evaluateActive as cw, evaluateEnabled as cx, findConflicts as cy, getScratch as cz, type ActionsRegistry as d, keymapShortcuts as d0, keysHeld as d1, liveScope as d2, makeToolOffhandAction as d3, matchActionItem as d4, matchBest as d5, matchSorted as d6, matchSortedWithBarred as d7, matchesKeyBinding as d8, mergeContributions as d9, scratchKey as dA, setScratch as dB, startCarry as dC, steppedOption as dD, taggedActionItems as dE, targetConsultsAffordance as dF, toolIdsOf as dG, toolOptionParams as dH, toolOptionSteps as dI, toolSet as dJ, toolSetHas as dK, tuneAction as dL, validateActionDefaultBinding as dM, validateActionId as dN, withoutTools as dO, mergeMenuDefs as da, modeShortcutSpec as db, modeShortcuts as dc, modifierStateOf as dd, multiTouchGestureId as de, offhandKeyFor as df, openPointerSession as dg, overlaysOf as dh, overriddenBindings as di, pendingKindOf as dj, pickMenu as dk, pointerGestureId as dl, readActionSettings as dm, reportRouteConflicts as dn, resolveBindingOverrides as dp, resolveDeviceProfile as dq, resolveMenu as dr, resolveParams as ds, resolveSchemaMenu as dt, returnToModeDefault as du, roleReader as dv, routesForSpec as dw, ruleCanHoldIn as dx, rulesExclusive as dy, scopeBindings as dz, ActionDisabledReason as e, type ActionVariant as f, type LastOperationStore as g, type LastOperation as h, type MenuDef as i, DepNode as j, type KernelOverlay as k, type Tool as l, ActiveToolContextProvider as m, ActiveToolContextProviderIfRoot as n, type ActiveToolContextProviderProps as o, type ActiveToolContextValue as p, useOptionalActiveToolContext as q, type Dispatcher as r, type AffordanceHit as s, type DispatchTrace as t, useActiveToolContext as u, type LongPressOptions as v, type DepSchema as w, ALWAYS as x, type ActionDispatch as y, type ActionEnabledResult as z };