@weasel-js/routing 1.11.0 → 1.12.0

package/dist/{index-CmfVvwWD.d.ts → index-CyBCsdie.d.ts}

@@ -1,11 +1,11 @@
+import { ModifierKey, ClaimableGesture, GestureSpec, InputEvent, TargetSpec, IngestItem, BodyTarget, BindingOverrideInput, KeyHeldSpec, TargetPredicate, KeySpec, ClickSpec, DoubleClickSpec, DragSpec, ContextMenuSpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
+import { FramedBox, View, Point } from '@weasel-js/geom';
+import { CursorSpec } from '@weasel-js/cursor';
 import { MenuEntry, Rect, MenuShortcut } from '@weasel-js/menu';
 import { PrefGroup } from '@weasel-js/prefs';
-import { FramedBox, View, Point } from '@weasel-js/geom';
 import { CapabilityTag, ActiveMode, ModeRegistry } from '@weasel-js/modes';
-import { ModifierKey, ClaimableGesture, GestureSpec, IngestItem, BodyTarget, InputEvent, TargetSpec, KeyHeldSpec, TargetPredicate, KeySpec, 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 * as react from 'react';
 import { ReactNode } from 'react';
 import { Emitter, QueryMatch } from '@weasel-js/registry';
@@ -169,423 +169,180 @@ type ResizeAnchor = {
     y: 'min' | 'max' | 'free';
 };
 
+/** The chrome an in-flight gesture paints beside the scene. */
+
 /**
- * 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.
+ * 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.
  *
- * Adding a new field is additive: existing rules don't change, new
- * selector atoms can read it.
+ * 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.
  */
-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;
+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'
+/** 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;
     };
-    readonly hover: NodeId | null;
+    current: {
+        x: number;
+        y: number;
+    };
+    shiftHeld: boolean;
+} | {
+    kind: 'lasso';
+    vertices: ReadonlyArray<{
+        x: number;
+        y: number;
+    }>;
+    current: {
+        x: number;
+        y: number;
+    };
+    shiftHeld: boolean;
+} | {
     /**
-     * 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.
+     * 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.
      */
-    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.
+    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;
+} | {
+    /**
+     * 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.
      *
-     *  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;
+     * `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;
     };
-    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;
+    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])[];
+};
+/** 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;
 }
+/** 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;
 /**
- * Capability set to assume when no mode registry is wired.
+ * 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;
+}, id: keyof R & string) => boolean;
+
+/**
+ * Invoker — pluggable invocation strategy for an Action.
  *
- * "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.
+ * 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).
  */
-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 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;
-
-/**
- * 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;
-}
-/** 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;
-}, 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' | (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;
-    };
-    current: {
-        x: number;
-        y: number;
-    };
-    shiftHeld: boolean;
-} | {
-    kind: 'lasso';
-    vertices: ReadonlyArray<{
-        x: number;
-        y: number;
-    }>;
-    current: {
-        x: number;
-        y: number;
-    };
-    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;
-} | {
-    /**
-     * 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.
-     */
-    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])[];
-};
-/** A handle's overlays as a list: empty when it has none. */
-declare function overlaysOf(handle: OngoingHandle): readonly OngoingOverlay[];
-
-/**
- * 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;
-/**
- * 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.
+ * 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'`. */
@@ -747,6 +504,11 @@ interface InvocationCtx {
 /** Per-invocation options the dispatcher reads from a `GestureBinding`'s
  *  `opts` field and passes to `OngoingInvoker.start`. */
 interface BindingOpts {
+    /** The id a binding override names this binding by, `<owner>.<role>`:
+     *  `undo.key`, `rect.drag`, `nudge.left.big`. Without one it is its owner and
+     *  its position (`<entry>#<n>`, `<action>@<n>`), which moves when the defaults
+     *  are reordered, so a binding a host may persist an override for declares one. */
+    id?: string;
     /** Gesture behaviors the action's own invoker runs. Routing carries the
      *  array to the action and never reads an element, so the element type is
      *  open here; `@weasel-js/core` narrows it. */
@@ -777,6 +539,12 @@ interface BindingOpts {
      * binding; this tells the route-conflict check the order is the design.
      */
     yields?: boolean;
+    /**
+     * 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.
+     */
+    over?: boolean;
     /**
      * Keys for some of the action's `modifierRoles` on this binding, by role
      * id, over the action's defaults and any tuning's.
@@ -822,8 +590,11 @@ interface OngoingHandle {
      *
      * `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). Returning `null`, or omitting the
-     * method, means "no preview this gesture".
+     * 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.
      */
     previewIds?(): Iterable<string> | null;
     previewPose?(id: string): unknown | null;
@@ -930,902 +701,1355 @@ interface BindingSource {
  */
 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;
+
 /**
- * Closed enum of reasons an action might report itself as disabled. The
- * consumer (palette, menu, etc.) maps these symbolic values to display
- * strings via its own label map.
- */
-declare const ActionDisabledReason: {
-    readonly SelectionRequired: "selection-required";
-    readonly SceneEmpty: "scene-empty";
-    readonly NotApplicable: "not-applicable";
-    /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
-    readonly PredicateThrew: "predicate-threw";
-};
-/** Why an action is unavailable right now. */
-type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
-/**
- * What a palette, menu or toolbar renders for an action. No part of this is
- * read during dispatch.
+ * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
+ * the actions-layer binding-scope / matchBest logic on top.
  */
-interface ActionPresentation {
-    label: string;
-    /** The action's icon, by qualified name: `icon('group')` in the package that draws it. */
-    icon?: IconRef;
-    /** Grouping key for palette/menu surfaces. Free-form string; the kit
-     *  ships defaults for `'align'` (six edges/centers), `'distribute'`
-     *  (two axes), and recommends `'pathfinder'` for boolean ops. */
-    group?: string;
-    /** Words the action is also found by and gathered under. Where `group` is
-     *  the one place an action sits, an action carries any number of tags: a
-     *  palette search matches them as it matches the label, and
-     *  `actionsTagged` / `taggedActionItems` gather every action or entry
-     *  carrying one, for a bar or a menu built from a tag. */
-    tags?: readonly string[];
-    /** Display override for the keyboard shortcut. When omitted, palette
-     *  surfaces derive a label from `defaultBinding` via their own
-     *  formatter. */
-    shortcut?: string;
-    /** The distinct things a parametric action does, one per set of params —
-     *  `flip` flips horizontally or vertically, `reorder.forward` moves one step
-     *  or all the way. A bar, menu or palette shows one entry per variant and
-     *  triggers the action with that variant's `params`. Omitted = the action
-     *  is one entry. See `actionItems`. */
-    variants?: readonly ActionVariant[];
+
+/** 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;
 /**
- * One entry a parametric action contributes to a bar, menu or palette.
+ * 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.
  */
-interface ActionVariant {
-    /** Unique within the action; joined to its id to make the entry's key. */
-    key: string;
-    label: string;
-    /** Falls back to the action's own `icon`. */
-    icon?: IconRef;
-    /** Tags this variant carries besides its action's, which it carries too. */
-    tags?: readonly string[];
-    /** Passed to `trigger`, and matched against each binding's
-     *  `opts.params` to find the variant's shortcuts. */
-    params: Readonly<Record<string, unknown>>;
+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;
 }
 /**
- * What routing consults: the bindings that reach the action, the deps its
- * invoker reads, the gates it passes, and the cursors it claims.
+ * {@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.
  */
-interface ActionDispatch extends BindingSource {
-    /** Names of the deps this action's invoker reads (keys of `DepSchema`).
-     *  The dispatcher (and `trigger`, when `requires` is present) resolves
-     *  each name against the `DepRegistry` at invocation time and passes the
-     *  resulting bag to the invoker. Dev builds warn when the invoker reads a
-     *  dep it didn't declare here — see `buildDepsFromRequires`. */
-    requires?: readonly DepName[];
-    /** Pluggable invocation strategy. The gesture dispatcher routes matched
-     *  bindings through `invoker.start` / `invoker.run` depending on timing.
-     *  All kit-standard descriptors ship one; consumer-supplied actions
-     *  without an invoker can still register but won't be triggered. */
-    invoker?: Invoker;
-    /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey
-     *  `BindingScope` instead of the ambient scope — meaning it beats any
-     *  active-tool binding on the same input shape. Use for tool-switch
-     *  shortcuts and global held-key triggers. Default: ambient. */
-    scope?: 'hotkey';
-    /**
-     * Optional predicate saying whether the action can run right now. Return
-     * `true` when it can, or an `ActionDisabledReason` when it cannot. The
-     * command palette greys out a disabled row, skips it in keyboard nav,
-     * ignores clicks, and shows the reason next to the label. The dispatcher
-     * skips a disabled action too, on a key as on a pointer, and falls through
-     * to the next binding that matches. `ActionsRegistry.trigger` asks too, but
-     * with no point, so a `run` whose answer depends on `at` should still
-     * self-guard.
-     *
-     * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and
-     * must not throw. A throw is caught and treated as disabled with reason
-     * `ActionDisabledReason.PredicateThrew`.
-     *
-     * The palette evaluates `enabled` once when opened and does NOT re-evaluate
-     * on selection changes while open.
-     *
-     * `deps` is the same bag passed to `ImmediateInvoker.run`.
-     *
-     * `at` is the world point of the event being routed, when it has one — a
-     * click, a press, a long-press. An action that only applies somewhere
-     * (on a path segment, say) refuses other points here, so the dispatcher
-     * falls through to the next binding and hover prediction shows the
-     * action's `cursor` only where it would act. `trigger` passes the
-     * `worldX`/`worldY` its params carry, so a menu row is run under the
-     * question it was shown enabled for. Palettes and keystrokes pass no
-     * point; treat absent as "anywhere".
-     *
-     * `carried` is what a drop or a paste being routed brings: its items. For
-     * a drag still in flight they hold a MIME and nothing else, since a
-     * browser withholds contents until the drop. An action that takes only
-     * some content refuses the rest here, so a drag it would not take is not
-     * accepted and a paste it would not take stays the page's.
-     */
-    enabled?: (deps?: ActionDeps, at?: {
+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;
-    }, carried?: {
-        items: readonly IngestItem[];
-    }) => true | ActionDisabledReason;
-    /**
-     * Whether the action reads as held down right now: bold on the selected
-     * text, snapping switched on. A toolbar button draws it as pressed.
-     * Omitted = the action has no pressed state, which is not the same as
-     * one that is off. Never read during dispatch.
-     *
-     * Under the same contract as `enabled`: pure, fast, and it must not
-     * throw. `deps` is the bag `enabled` is given.
-     */
-    active?: (deps?: ActionDeps) => boolean;
-    /**
-     * Show what running the action now would do, and change nothing: the
-     * result an operation would make, drawn over the canvas. A toolbar asks
-     * while its button is hovered or focused, through
-     * `ActionsRegistry.preview`, and calls what this returns when that ends.
-     * Asked only while `enabled` says yes, with the deps and params `run`
-     * would get. Omitted = the action has nothing to show.
-     */
-    preview?: (deps: ActionDeps, params?: Record<string, unknown>) => (() => void) | void;
-    /**
-     * Declarative eligibility rule, evaluated against the current
-     * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =
-     * always eligible.
-     *
-     * Accepts either a fluent `Condition` (callable with `.rule`) or a
-     * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.
-     *
-     * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)
-     * over `mode:` rules — capability rules survive new modes being added
-     * that allow the same capability.
-     */
-    eligible?: Rule | Condition;
-    /**
-     * CSS cursor shown while the pointer hovers a spot where this action
-     * would win the drag — or, when the drag's winner declares no cursor,
-     * the click. The hover-cursor pump runs the same match walk a real press
-     * takes, so the hint and the actual target stay in sync. Omitted = no
-     * override (the active tool's `Tool.cursor` shows). Affordance hits are
-     * resolved earlier in the pump via `AffordanceRegion.cursor` and never
-     * reach this field.
-     *
-     * A function is asked each time with the params the winning binding would
-     * start the action with, tunings included, so a cursor can follow them — a
-     * brush ring as wide as the brush. Read it through {@link actionCursor}.
-     * Prediction runs `enabled()` but cannot run the invoker, so an action that
-     * matches yet bails at `start()` (empty handle) may still show its cursor —
-     * keep `enabled` accurate for actions that declare one.
-     */
-    cursor?: CursorSpec | ((params: Record<string, unknown> | undefined) => CursorSpec | undefined);
-    /**
-     * CSS cursor shown while THIS action's ongoing handle is in flight —
-     * grabbing while panning, `move` while dragging a selection, `crosshair`
-     * while pulling a marquee.
-     *
-     * Separate from `cursor` because the two answer different questions:
-     * `cursor` is a prediction ("a drag from here would pan"), this is a state
-     * ("you are panning"). An action can declare either, both, or neither;
-     * with only `cursor` set, the hover hint holds for the duration of the
-     * gesture.
-     */
-    activeCursor?: CursorSpec;
-    /**
-     * The modifiers an ongoing action reads while it runs, by role: Shift
-     * holding a handle's angle, Alt breaking its mirror. The dispatcher resolves
-     * each into `InvocationCtx.roles` on the press, every move, and the release,
-     * so a binding's `opts.roles` or a tuning's `roles` can move one to another
-     * key. Read them with {@link roleReader}. A binding's own `mods` are matched
-     * once, at the press; these are read throughout.
-     */
-    modifierRoles?: ModifierRoles;
+    };
+    /** 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';
 }
-/**
- * Single registered action.
- */
-interface Action extends ActionDispatch, ActionPresentation {
+/** 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';
 }
-/**
- * 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[];
+/** `enabled()` returned this reason. */
+ | {
+    kind: 'declined';
+    reason: string;
 }
-/** `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;
-
-/** Which canvas hit a menu answers. Every field given must match. */
-interface MenuWhen {
-    bodyTarget?: BodyTarget | readonly BodyTarget[];
-    bodyKind?: string | readonly string[];
+/** An ongoing action's `start()` returned an empty handle. */
+ | {
+    kind: 'empty-handle';
 }
-/** A menu as data: a prefs schema drawn as a menu (`resolveSchemaMenu`).
- *  A def without `when` is opened only by id, from chrome. */
-interface MenuDef {
-    id: string;
-    when?: MenuWhen;
-    menu: PrefGroup;
+/** An ongoing action bound to a press-time `pointerDown` spec; refused. */
+ | {
+    kind: 'misbound';
 }
-/** What a right-click landed on. */
-interface MenuHit {
-    bodyTarget?: BodyTarget;
-    bodyKind?: string;
+/** Its action was already tried higher up; each runs at most once. */
+ | {
+    kind: 'duplicate';
+} | {
+    kind: 'no-such-action';
 }
-/** A def with who contributed it: a tool id, or `null` for ambient. */
-interface OwnedMenuDef {
-    def: MenuDef;
-    owner: string | null;
+/** Below the winner; never asked. */
+ | {
+    kind: 'not-asked';
 }
-
-/** What resolving reads: the registered actions, each one's deps, how to run
- *  one, and the values behind the schema's value leaves. */
-interface MenuSources {
-    actions(): readonly Action[];
-    depsFor(action: Action): ActionDeps | undefined;
-    trigger(id: string, params?: Record<string, unknown>): boolean;
-    /** The value at a leaf's dotted path. Booleans, enums, and numbers are left
-     *  out of a menu without both this and `onChange`, colors and strings without
-     *  this, and `showIf`/`enableIf` are checked only with it. */
-    values?(path: string): unknown;
-    onChange?(path: string, value: unknown): void;
-    /** The schema an `alias` leaf's `of` is read in. Default: the menu's own. */
-    over?: PrefGroup;
+/** 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;
 }
-/**
- * Draw a prefs schema as menu entries. Action leaves become items from the
- * registry (one per variant for a parametric action), an `actions` leaf one
- * item per action in its group, a boolean a checked item, an enum radio
- * rows, and a number a row edited in place (all through `src.values`/`src.onChange`);
- * a color shows as a swatch and a string as a disabled row, both read-only. A group drawn `as` a
- * `menu`, `page`, `tab`, or `panel` is a submenu, and any other group's rows
- * sit inline between separators. Paint, field, compound, and app-defined leaves are left out.
- * `at` is the world point the menu was opened at and reaches `enabled` and
- * every action's params; `params` go to every action, under its own.
- */
-declare function resolveSchemaMenu(schema: PrefGroup, src: MenuSources, at?: Point, params?: Record<string, unknown>): MenuEntry[];
-/** Turn a declared menu into model entries; see {@link resolveSchemaMenu}. */
-declare function resolveMenu(def: MenuDef, src: MenuSources, at?: Point, params?: Record<string, unknown>): MenuEntry[];
 
-/** Ask to open a menu: by id (chrome) or by what was hit (canvas). */
-interface MenuOpenRequest {
-    menu?: string;
-    hit?: MenuHit;
-    /** Viewport point the menu is placed at, unless `under` is set. */
-    client: Point;
-    /** Viewport rect of the button the menu hangs from: placed below it, or above when below does not fit. */
-    under?: Rect;
-    /** World point, passed to `enabled` and to every item. */
-    world?: Point;
-    params?: Record<string, unknown>;
-    source?: 'pointer' | 'keyboard';
+/** 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;
 }
-/** The menu on screen. `seq` changes on every open, so a renderer remounts. */
-interface OpenMenu {
-    seq: number;
-    entries: readonly MenuEntry[];
-    client: Point;
-    under?: Rect;
-    world?: Point;
-    source: 'pointer' | 'keyboard';
+/** 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;
 }
-/** Holds the declared menus and the one open menu. */
-interface MenuHost {
-    /** Declare a menu; `owner` is a tool id, or `null` for always. Returns a release. */
-    define(def: MenuDef, owner?: string | null): () => void;
-    /** Pick, resolve and show. False when nothing matched or nothing resolved. */
-    open(req: MenuOpenRequest): boolean;
-    /** Whether `open(req)` would show anything. Changes no state and notifies no one. */
-    has(req: MenuOpenRequest): boolean;
-    close(): void;
-    current(): OpenMenu | null;
-    subscribe(fn: () => 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;
 }
-/** Creates the host that decides which context menu is open, from the menus registered to it. */
-declare function createMenuHost(src: MenuSources & {
-    activeTool(): string | null;
-}): MenuHost;
+/** A {@link DispatchTrace} keeping the last `limit` entries. `dev` defaults to the build's. */
+declare function createDispatchTrace(limit?: number, dev?: boolean): DispatchTrace;
 
 /**
- * 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
- * registration lives in the node it was made in, and a lookup starts at a leaf
- * and walks up, so one canvas never answers for another.
+ * 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.
  */
-
-/** What every node of one tree shares: a version and the listeners to it. */
-interface ScopeTree {
-    version: number;
-    readonly listeners: Emitter;
+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;
 }
-declare class ScopeNode<N extends ScopeNode<N>> {
-    readonly parent: N | null;
-    readonly descends: boolean;
-    readonly tree: ScopeTree;
-    private readonly children;
-    private activeChild;
-    /** `descends`: whether reads made here answer from the active child down —
-     *  true for a root or a yoke, which chrome reads through; false for a scope,
-     *  which answers for itself even with a scope nested inside it. */
-    constructor(parent: N | null, descends: boolean);
-    /** Bump the tree's version and tell every listener in it. */
-    changed(): void;
-    /** Join the parent's children, newest last; returns the leave. */
-    mount(): () => void;
-    /** Make this node the one its ancestors resolve through. */
-    activate(): void;
-    /** The node a lookup made here starts from: down the active children, or the
-     *  newest where nothing has been activated yet. A yoke with no members yet
-     *  is passed over — there is no canvas behind it to answer. */
-    leaf(): N;
-    private newestMember;
-    /** Where a read made through this node starts. */
-    start(): N;
-    /** Whether this node is on the path a read from the root takes. */
-    isActive(): boolean;
-    /** This node, then each ancestor up to the root. */
-    chain(): Generator<N>;
+/** 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;
 
-/** Which tool is active, plus the stack of tools temporarily held active by a
- *  hotkey (space-for-hand and the like). The dispatcher reads this to decide
- *  whose bindings are in scope. */
-interface ActiveToolContextValue {
-    /** The focused tool's id, or `null` when no tool holds the active slot —
-     *  a canvas can run on ambient bindings alone. */
-    active: string | null;
-    hotkeyStack: string[];
-    setActive(id: string | null): void;
-    pushHotkey(id: string): void;
-    /**
-     * Disengage a hotkey-held tool. With `id`, removes that tool's own entry
-     * wherever it now sits — holds do not have to come up in the order they went
-     * down, and popping the top would disengage a tool whose key is still held.
-     * With no id, pops the top.
-     */
-    popHotkey(id?: string): void;
-}
 /**
- * One node of the tool tree. A node that `owns` a tool holds its state; one
- * that does not — a scope inside a yoke — reads and writes its yoke's.
+ * 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.
  */
-declare class ToolNode extends ScopeNode<ToolNode> {
-    private state;
-    private value;
-    constructor(parent: ToolNode | null, descends: boolean, owns: boolean, initialActive: string | null);
-    /** The node whose tool a read here resolves to. */
-    owner(): ToolNode;
-    private update;
-    /** A stable value per owner and state, for `useSyncExternalStore`. */
-    snapshot(): ActiveToolContextValue;
-    subscribe: (listener: () => void) => (() => void);
-}
-/** Props for `<ActiveToolContextProvider>`. */
-interface ActiveToolContextProviderProps {
-    children: ReactNode;
-    /** Seeds the active slot, and wins over the first `useTools` call's
-     *  `active`. Omitted, the slot starts empty and that call seeds it. */
-    initialActive?: string | null;
+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;
 }
-/** Provides root active-tool state. Every canvas below has a tool of its own;
- *  reads and writes here reach the one last used. */
-declare function ActiveToolContextProvider({ children, initialActive, }: ActiveToolContextProviderProps): react.JSX.Element;
-/** The active-tool state in scope. Throws outside a provider; use
- *  `useOptionalActiveToolContext` where one is not guaranteed. */
-declare function useActiveToolContext(): ActiveToolContextValue;
 /**
- * Like `useActiveToolContext`, but returns `null` when no
- * `<ActiveToolContextProvider>` is in scope instead of throwing.
+ * 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.
  */
-declare function useOptionalActiveToolContext(): ActiveToolContextValue | null;
+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;
 /**
- * Mounts an `<ActiveToolContextProvider>` only when no parent provider is in
- * scope; otherwise renders children unwrapped.
+ * 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 ActiveToolContextProviderIfRoot({ children, }: {
-    children: ReactNode;
-}): react.JSX.Element;
-
+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;
 /**
- * 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.
+ * 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(...)`.
  */
-
-/** 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;
+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;
 }
-/** `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.
+ * 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.
  */
-
-/** One renderable entry: an action, optionally with params. */
-interface ActionItem {
-    /** `action.id`, or `action.id:variant.key` — unique across a registry. */
-    key: string;
-    action: Action;
-    label: string;
-    icon?: IconRef;
-    /** The action's tags, then the variant's own. */
-    tags: readonly string[];
-    /** What to pass to `trigger(action.id, params)`; absent for a plain action. */
-    params?: Readonly<Record<string, unknown>>;
-}
-/** Expand `action` into the entries a surface renders. An
- *  action without an immediate invoker has none: `trigger` cannot start a
- *  drag, so a button for one would do nothing. */
-declare function actionItems(action: Action): ActionItem[];
-/** How a palette titles `item`: a variant reads as its action's
- *  label and its own ("New: A4"), unless its label already holds the action's
- *  as whole words ("Zoom In", "Reset Zoom"). */
-declare function actionItemTitle(item: ActionItem): string;
-
+declare function rulesExclusive(a: Rule, b: Rule): boolean;
 /**
- * Project an action's keyboard bindings into the shape a shortcut chip
- * renders from (`formatShortcut` / `formatShortcutParts` in `@weasel-js/ui`).
+ * 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;
 
-/** One keyboard shortcut, flattened for display: the chip a menu row draws
- *  (`MenuShortcut` in `@weasel-js/menu`, `ShortcutInput` in `@weasel-js/gestures`). */
-type ActionShortcut = MenuShortcut;
+/** The detected half of a profile — everything except the derived scale. */
+type DetectedDeviceFacts = Omit<DeviceProfile, 'targetScale'>;
 /**
- * The chip form of a single gesture spec, or `undefined` when the spec has
- * none.
+ * Handle/hit multiplier applied on a coarse pointer.
  *
- * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
- *   shifted bracket reports as `'{'`). The first is the shortcut's name.
- * - A modifier declared `'optional'` matches held or unheld, so it isn't
- *   part of what the user has to press.
+ * 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`.
  *
- * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
- * *required* `ctrl` or `meta`: the display shape carries only `mod`.
+ * `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 keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
+declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?: Partial<DeviceProfile>): DeviceProfile;
 /**
- * Every keyboard shortcut an action answers to, in declaration order.
- * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
- * identical are emitted once; an action bound only to those returns empty.
+ * Assumed when `matchMedia` is unavailable (SSR, jsdom) and used as the
+ * absent-means value for `RuleCtx.device`.
  *
- * With `params` — an `ActionItem`'s — only the bindings that pass those same
- * values count, so each variant of `flip` gets its own key.
+ * 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 function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
+declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
 
 /**
- * Finding actions by tag: gathering the ones that carry it, and a person's
- * search matching it as it matches a label.
+ * A settings form an action carries: what a surface draws in place of a bare
+ * trigger for an action whose job is to change settings on the selection.
  */
 
-/** The actions carrying `tag`, themselves or on any variant, in
- *  the order given. Drags included, which have no entries to show. */
-declare function actionsTagged(actions: readonly Action[], tag: string): Action[];
-/** The entries carrying `tag`: what a bar or a menu built from
- *  a tag shows. A variant that does not carry it is left out. */
-declare function taggedActionItems(actions: readonly Action[], tag: string): ActionItem[];
-/** Whether `item` answers a search for `query`, by its palette title or
- *  by a tag, and which. */
-declare function matchActionItem(item: ActionItem, query: string): QueryMatch | null;
-
+/** What a settings form shows for the selection right now. */
+interface ActionSettingsState {
+    /** The values, nested as the schema's groups nest. */
+    values: Record<string, unknown>;
+    /** The leaf paths where the selected items disagree. */
+    mixed?: readonly string[];
+}
 /**
- * Palette-side evaluation of `Action.enabled`. The dispatcher calls the
- * predicate raw as a gate; this is the surface that also enforces the
- * contract the predicate's JSDoc states — no throwing, under 4ms in dev.
+ * The settings form an action carries. A bar or a panel draws the action as a
+ * button opening it, a menu as a submenu of its fields, and a palette as a
+ * dialog; each change triggers the action with the params it makes.
  */
+interface ActionSettings {
+    /** The form. Its `name` titles the popover, submenu or dialog. */
+    schema: PrefGroup;
+    /** The selection's current values, from the deps `enabled` is given. Under
+     *  `enabled`'s contract: pure, fast, and it must not throw. */
+    read(deps: ActionDeps): ActionSettingsState;
+    /** The params one field's change triggers the action with, or `null` for
+     *  none. Default: `{ [path]: value }`. */
+    params?(path: string, value: unknown): Record<string, unknown> | null;
+}
+/** `action`'s settings as they stand under `deps`, or `null` for an action
+ *  with no settings. A `read` that throws shows nothing rather than breaking
+ *  the surface. */
+declare function readActionSettings(action: Action, deps: ActionDeps | undefined): ActionSettingsState | null;
+/** 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;
 
+/** 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 {
+    items: readonly IngestItem[];
+    carry?: {
+        type: string;
+        value: unknown;
+    };
+}
 /**
- * Result of evaluating an Action's `enabled` predicate.
+ * The kit's symbolic reasons an action might report itself as disabled. The
+ * consumer (palette, menu, etc.) maps these to display strings via its own
+ * label map. An action may also answer with any other string, which is
+ * display text and shown as is — see {@link ActionUnavailable}.
  */
-interface ActionEnabledResult {
-    enabled: boolean;
-    reason?: ActionDisabledReason;
+declare const ActionDisabledReason: {
+    readonly SelectionRequired: "selection-required";
+    readonly SceneEmpty: "scene-empty";
+    readonly NotApplicable: "not-applicable";
+    /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
+    readonly PredicateThrew: "predicate-threw";
+};
+/** Why an action is unavailable right now. */
+type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
+/** What `enabled` answers with when the action cannot run: one of the
+ *  symbolic {@link ActionDisabledReason}s, or a sentence to show as it is. */
+type ActionUnavailable = ActionDisabledReason | (string & {});
+/**
+ * What a palette, menu or toolbar renders for an action. No part of this is
+ * read during dispatch.
+ */
+interface ActionPresentation {
+    label: string;
+    /** The action's icon, by qualified name: `icon('group')` in the package that draws it. */
+    icon?: IconRef;
+    /** Grouping key for palette/menu surfaces. Free-form string; the kit
+     *  ships defaults for `'align'` (six edges/centers), `'distribute'`
+     *  (two axes), and recommends `'pathfinder'` for boolean ops. */
+    group?: string;
+    /** Words the action is also found by and gathered under. Where `group` is
+     *  the one place an action sits, an action carries any number of tags: a
+     *  palette search matches them as it matches the label, and
+     *  `actionsTagged` / `taggedActionItems` gather every action or entry
+     *  carrying one, for a bar or a menu built from a tag. */
+    tags?: readonly string[];
+    /** Display override for the keyboard shortcut. When omitted, palette
+     *  surfaces derive a label from `defaultBinding` via their own
+     *  formatter. */
+    shortcut?: string;
+    /** The distinct things a parametric action does, one per set of params —
+     *  `flip` flips horizontally or vertically, `reorder.forward` moves one step
+     *  or all the way. A bar, menu or palette shows one entry per variant and
+     *  triggers the action with that variant's `params`. Omitted = the action
+     *  is one entry. See `actionItems`. */
+    variants?: readonly ActionVariant[];
+    /** A form of the settings the action changes on the selection. A surface
+     *  draws the action as that form instead of a bare trigger, and each change
+     *  triggers it with the params `settings.params` makes. Not combined with
+     *  `variants`. */
+    settings?: ActionSettings;
 }
 /**
- * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`
- * when no predicate is supplied. Catches throws and treats them as disabled
- * with reason `'(predicate threw)'`. In dev mode, warns once per action id
- * when a single call exceeds 4ms (single frame at 240fps — generous; real
- * predicates should be sub-millisecond).
+ * One entry a parametric action contributes to a bar, menu or palette.
  */
-declare function evaluateEnabled(action: Action, deps?: ActionDeps, at?: {
-    x: number;
-    y: number;
-}): ActionEnabledResult;
+interface ActionVariant {
+    /** Unique within the action; joined to its id to make the entry's key. */
+    key: string;
+    label: string;
+    /** Falls back to the action's own `icon`. */
+    icon?: IconRef;
+    /** Tags this variant carries besides its action's, which it carries too. */
+    tags?: readonly string[];
+    /** Passed to `trigger`, and matched against each binding's
+     *  `opts.params` to find the variant's shortcuts. */
+    params: Readonly<Record<string, unknown>>;
+}
 /**
- * Safely evaluate an action's `active` predicate. `undefined` for an action
- * with no pressed state; a predicate that throws reads as not active.
+ * What routing consults: the bindings that reach the action, the deps its
+ * invoker reads, the gates it passes, and the cursors it claims.
  */
-declare function evaluateActive(action: Action, deps?: ActionDeps): boolean | undefined;
+interface ActionDispatch extends BindingSource {
+    /** Names of the deps this action's invoker reads (keys of `DepSchema`).
+     *  The dispatcher (and `trigger`, when `requires` is present) resolves
+     *  each name against the `DepRegistry` at invocation time and passes the
+     *  resulting bag to the invoker. Dev builds warn when the invoker reads a
+     *  dep it didn't declare here — see `buildDepsFromRequires`. */
+    requires?: readonly DepName[];
+    /** Pluggable invocation strategy. The gesture dispatcher routes matched
+     *  bindings through `invoker.start` / `invoker.run` depending on timing.
+     *  All kit-standard descriptors ship one; consumer-supplied actions
+     *  without an invoker can still register but won't be triggered. */
+    invoker?: Invoker;
+    /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey
+     *  `BindingScope` instead of the ambient scope — meaning it beats any
+     *  active-tool binding on the same input shape. Use for tool-switch
+     *  shortcuts and global held-key triggers. Default: ambient. */
+    scope?: 'hotkey';
+    /**
+     * Optional predicate saying whether the action can run right now. Return
+     * `true` when it can, or an `ActionDisabledReason` or a sentence of display
+     * text when it cannot. The
+     * command palette greys out a disabled row, skips it in keyboard nav,
+     * ignores clicks, and shows the reason next to the label. The dispatcher
+     * skips a disabled action too, on a key as on a pointer, and falls through
+     * to the next binding that matches. `ActionsRegistry.trigger` asks too, but
+     * with no point, so a `run` whose answer depends on `at` should still
+     * self-guard.
+     *
+     * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and
+     * must not throw. A throw is caught and treated as disabled with reason
+     * `ActionDisabledReason.PredicateThrew`.
+     *
+     * The palette evaluates `enabled` once when opened and does NOT re-evaluate
+     * on selection changes while open.
+     *
+     * `deps` is the same bag passed to `ImmediateInvoker.run`.
+     *
+     * `at` is the world point of the event being routed, when it has one — a
+     * click, a press, a long-press. An action that only applies somewhere
+     * (on a path segment, say) refuses other points here, so the dispatcher
+     * falls through to the next binding and hover prediction shows the
+     * action's `cursor` only where it would act. `trigger` passes the
+     * `worldX`/`worldY` its params carry, so a menu row is run under the
+     * question it was shown enabled for. Palettes and keystrokes pass no
+     * point; treat absent as "anywhere".
+     *
+     * `carried` is what a drop, a paste or a carry being routed brings. For
+     * an OS drag still in flight its items hold a MIME and nothing else, since
+     * a browser withholds contents until the drop. A carry has no items and
+     * hands over its payload whole. An action that takes only some content
+     * refuses the rest here, so a drag it would not take is not accepted and a
+     * paste it would not take stays the page's.
+     */
+    enabled?: (deps?: ActionDeps, at?: {
+        x: number;
+        y: number;
+    }, carried?: Carried) => true | ActionUnavailable;
+    /**
+     * Whether the action reads as held down right now: bold on the selected
+     * text, snapping switched on. A toolbar button draws it as pressed.
+     * Omitted = the action has no pressed state, which is not the same as
+     * one that is off. Never read during dispatch.
+     *
+     * Under the same contract as `enabled`: pure, fast, and it must not
+     * throw. `deps` is the bag `enabled` is given.
+     */
+    active?: (deps?: ActionDeps) => boolean;
+    /**
+     * Show what running the action now would do, and change nothing: the
+     * result an operation would make, drawn over the canvas. A toolbar asks
+     * while its button is hovered or focused, through
+     * `ActionsRegistry.preview`, and calls what this returns when that ends.
+     * Asked only while `enabled` says yes, with the deps and params `run`
+     * would get. Omitted = the action has nothing to show.
+     */
+    preview?: (deps: ActionDeps, params?: Record<string, unknown>) => (() => void) | void;
+    /**
+     * Declarative eligibility rule, evaluated against the current
+     * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =
+     * always eligible.
+     *
+     * Accepts either a fluent `Condition` (callable with `.rule`) or a
+     * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.
+     *
+     * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)
+     * over `mode:` rules — capability rules survive new modes being added
+     * that allow the same capability.
+     */
+    eligible?: Rule | Condition;
+    /**
+     * CSS cursor shown while the pointer hovers a spot where this action
+     * would win the drag — or, when the drag's winner declares no cursor,
+     * the click. The hover-cursor pump runs the same match walk a real press
+     * takes, so the hint and the actual target stay in sync. Omitted = no
+     * override (the active tool's `Tool.cursor` shows). Affordance hits are
+     * resolved earlier in the pump via `AffordanceRegion.cursor` and never
+     * reach this field.
+     *
+     * A function is asked each time with the params the winning binding would
+     * start the action with, tunings included, so a cursor can follow them — a
+     * brush ring as wide as the brush. Read it through {@link actionCursor}.
+     * Prediction runs `enabled()` but cannot run the invoker, so an action that
+     * matches yet bails at `start()` (empty handle) may still show its cursor —
+     * keep `enabled` accurate for actions that declare one.
+     */
+    cursor?: CursorSpec | ((params: Record<string, unknown> | undefined) => CursorSpec | undefined);
+    /**
+     * CSS cursor shown while THIS action's ongoing handle is in flight —
+     * grabbing while panning, `move` while dragging a selection, `crosshair`
+     * while pulling a marquee.
+     *
+     * Separate from `cursor` because the two answer different questions:
+     * `cursor` is a prediction ("a drag from here would pan"), this is a state
+     * ("you are panning"). An action can declare either, both, or neither;
+     * with only `cursor` set, the hover hint holds for the duration of the
+     * gesture.
+     */
+    activeCursor?: CursorSpec;
+    /**
+     * The modifiers an ongoing action reads while it runs, by role: Shift
+     * holding a handle's angle, Alt breaking its mirror. The dispatcher resolves
+     * each into `InvocationCtx.roles` on the press, every move, and the release,
+     * so a binding's `opts.roles` or a tuning's `roles` can move one to another
+     * key. Read them with {@link roleReader}. A binding's own `mods` are matched
+     * once, at the press; these are read throughout.
+     */
+    modifierRoles?: ModifierRoles;
+}
+/**
+ * Single registered action.
+ */
+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;
+
+/** Which canvas hit a menu answers. Every field given must match. */
+interface MenuWhen {
+    bodyTarget?: BodyTarget | readonly BodyTarget[];
+    bodyKind?: string | readonly string[];
+}
+/** A menu as data: a prefs schema drawn as a menu (`resolveSchemaMenu`).
+ *  A def without `when` is opened only by id, from chrome. */
+interface MenuDef {
+    id: string;
+    when?: MenuWhen;
+    menu: PrefGroup;
+}
+/** What a right-click landed on. */
+interface MenuHit {
+    bodyTarget?: BodyTarget;
+    bodyKind?: string;
+}
+/** A def with who contributed it: a tool id, or `null` for ambient. */
+interface OwnedMenuDef {
+    def: MenuDef;
+    owner: string | null;
+}
 
+/** What resolving reads: the registered actions, each one's deps, how to run
+ *  one, and the values behind the schema's value leaves. */
+interface MenuSources {
+    actions(): readonly Action[];
+    depsFor(action: Action): ActionDeps | undefined;
+    trigger(id: string, params?: Record<string, unknown>): boolean;
+    /** The value at a leaf's dotted path. Booleans, enums, and numbers are left
+     *  out of a menu without both this and `onChange`, colors and strings without
+     *  this, and `showIf`/`enableIf` are checked only with it. */
+    values?(path: string): unknown;
+    onChange?(path: string, value: unknown): void;
+    /** The schema an `alias` leaf's `of` is read in. Default: the menu's own. */
+    over?: PrefGroup;
+}
 /**
- * The dep registry: named "live source" thunks. Actions declare
- * `requires: ['selection']`; the dispatcher calls `registry.get('selection')`
- * at invocation time to build a typed Deps bag.
+ * Draw a prefs schema as menu entries. Action leaves become items from the
+ * registry (one per variant for a parametric action), an `actions` leaf one
+ * item per action in its group, a boolean a checked item, an enum radio
+ * rows, and a number and a string a row edited in place (all through `src.values`/`src.onChange`);
+ * a color shows as a swatch, read-only, and so does a string as a disabled row when it is a readout
+ * or nothing writes it. A group drawn `as` a
+ * `menu`, `page`, `tab`, or `panel` is a submenu, and any other group's rows
+ * sit inline between separators. Paint, field, compound, and app-defined leaves are left out.
+ * `at` is the world point the menu was opened at and reaches `enabled` and
+ * every action's params; `params` go to every action, under its own.
  */
+declare function resolveSchemaMenu(schema: PrefGroup, src: MenuSources, at?: Point, params?: Record<string, unknown>): MenuEntry[];
+/** Turn a declared menu into model entries; see {@link resolveSchemaMenu}. */
+declare function resolveMenu(def: MenuDef, src: MenuSources, at?: Point, params?: Record<string, unknown>): MenuEntry[];
 
-/** Holds the live sources an action's declared dependencies resolve to.
- *  Sources are thunks, read at invocation time, so an action never captures
- *  stale state. */
-interface DepRegistry {
-    register<K extends DepName>(name: K, source: () => DepSchema[K]): () => void;
-    get<K extends DepName>(name: K): DepSchema[K] | undefined;
-    /** Hear that what the registry answers may have changed: a source was
-     *  registered or released anywhere in its tree, or an owner called
-     *  {@link DepRegistry.changed}. Returns the unsubscribe. A hand-built
-     *  registry whose answers never change leaves this and `changed` out. */
-    subscribe?(listener: () => void): () => void;
-    /** Say that a source's value changed. A source is a thunk read on demand,
-     *  so its owner is the only one who knows; chrome showing an action's
-     *  `enabled` or `active` state re-reads on this. */
-    changed?(): void;
+/** Ask to open a menu: by id (chrome) or by what was hit (canvas). */
+interface MenuOpenRequest {
+    menu?: string;
+    hit?: MenuHit;
+    /** Viewport point the menu is placed at, unless `under` is set. */
+    client: Point;
+    /** Viewport rect of the button the menu hangs from: placed below it, or above when below does not fit. */
+    under?: Rect;
+    /** With `under`: opens above the button when it fits there, below when it does not. The canvas HUD menu host places below only and ignores it. */
+    above?: boolean;
+    /** World point, passed to `enabled` and to every item. */
+    world?: Point;
+    params?: Record<string, unknown>;
+    source?: 'pointer' | 'keyboard';
 }
-/** One node of the dep tree: the sources registered at it, over its parent's.
- *  Each name holds a stack of sources, newest live, so a displaced source is
- *  restored when the one above it leaves. */
-declare class DepNode extends ScopeNode<DepNode> {
-    private readonly sources;
-    readonly registry: DepRegistry;
-    constructor(parent: DepNode | null, descends: boolean);
+/** The menu on screen. `seq` changes on every open, so a renderer remounts. */
+interface OpenMenu {
+    seq: number;
+    entries: readonly MenuEntry[];
+    client: Point;
+    under?: Rect;
+    /** `MenuOpenRequest.above`, carried to the renderer. */
+    above?: boolean;
+    world?: Point;
+    source: 'pointer' | 'keyboard';
 }
-/**
- * A stock dep registry with no parent: what `<DepRegistryProvider>` mounts,
- * for a dispatcher driven without React. Sources registered under one name
- * stack, newest live, and releasing one restores the one beneath it.
- */
-declare function createDepRegistry(): DepRegistry;
+/** Holds the declared menus and the one open menu. */
+interface MenuHost {
+    /** Declare a menu; `owner` is a tool id, or `null` for always. Returns a release. */
+    define(def: MenuDef, owner?: string | null): () => void;
+    /** Pick, resolve and show. False when nothing matched or nothing resolved. */
+    open(req: MenuOpenRequest): boolean;
+    /** Whether `open(req)` would show anything. Changes no state and notifies no one. */
+    has(req: MenuOpenRequest): boolean;
+    close(): void;
+    current(): OpenMenu | null;
+    subscribe(fn: () => void): () => void;
+}
+/** Creates the host that decides which context menu is open, from the menus registered to it. */
+declare function createMenuHost(src: MenuSources & {
+    activeTool(): string | null;
+}): MenuHost;
 
 /**
- * Shared dep-bag builder — the single implementation behind both the gesture
- * dispatcher's per-invocation `buildDeps` and `ActionsRegistry.trigger`'s
- * `requires` branch. Reads the action's declared `requires`, resolves each
- * name against the `DepRegistry`, and (dev builds only) wraps the bag in a
- * Proxy that warns on undeclared reads.
+ * 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
+ * registration lives in the node it was made in, and a lookup starts at a leaf
+ * and walks up, so one canvas never answers for another.
  */
 
-/** Build the deps bag for an action from its declared `requires`. */
-declare function buildDepsFromRequires(action: Action, depRegistry: DepRegistry): ActionDeps;
+/** What every node of one tree shares: a version and the listeners to it. */
+interface ScopeTree {
+    version: number;
+    readonly listeners: Emitter;
+}
+declare class ScopeNode<N extends ScopeNode<N>> {
+    readonly parent: N | null;
+    readonly descends: boolean;
+    readonly tree: ScopeTree;
+    private readonly children;
+    private activeChild;
+    /** `descends`: whether reads made here answer from the active child down —
+     *  true for a root or a yoke, which chrome reads through; false for a scope,
+     *  which answers for itself even with a scope nested inside it. */
+    constructor(parent: N | null, descends: boolean);
+    /** Bump the tree's version and tell every listener in it. */
+    changed(): void;
+    /** Join the parent's children, newest last; returns the leave. */
+    mount(): () => void;
+    /** Make this node the one its ancestors resolve through. */
+    activate(): void;
+    /** The node a lookup made here starts from: down the active children, or the
+     *  newest where nothing has been activated yet. A yoke with no members yet
+     *  is passed over — there is no canvas behind it to answer. */
+    leaf(): N;
+    private newestMember;
+    /** Where a read made through this node starts. */
+    start(): N;
+    /** Whether this node is on the path a read from the root takes. */
+    isActive(): boolean;
+    /** This node, then each ancestor up to the root. */
+    chain(): Generator<N>;
+}
 
-/** Hotkey-slot trigger key. The slot is engaged while this key is held —
- *  hence "hotkey": active as long as the key is hot. Omitted means the tool
- *  is not eligible for the hotkey slot.
- *
- *  The named keys map to their DOM names (`'space'` is `' '`, `'ctrl'` is
- *  `'Control'`). Anything else is a `KeyboardEvent.key` value, matched
- *  case-insensitively as every key spec is — so `'o'` holds on O. */
-type HotkeyTrigger = 'space' | 'alt' | 'ctrl' | 'meta' | 'shift' | (string & {});
-/** Presentation metadata for tool palettes / menus. Optional on every
- *  tool — consumers that render a palette (`<ToolPalette>`) read these
- *  fields to display the tool; consumers that don't can ignore them.
- *
- *  Note: cursor is NOT here. `Tool.cursor` (inherited from `Contribution`)
- *  is already plumbed through `<Canvas>` to `style.cursor` on the host. */
-interface ToolPresentation {
-    /** Human-readable label, distinct from the `id`. Falls back to `id`. */
-    label?: string;
-    /** The tool's icon, by qualified name: `icon('rect')` in the package that draws it. */
-    icon?: _weasel_js_icons.IconRef;
-    /** Palette grouping key. Tools sharing a group render contiguously
-     *  with separators between groups. Free-form string; the kit
-     *  recommends 'select' | 'shape' | 'draw' | 'type' | 'view'. */
-    group?: string;
-    /** Display override for the keyboard shortcut. When omitted the palette
-     *  derives one from `Tool.keybinding` via its own formatter. */
-    shortcut?: string;
-    /** Keep the tool off palettes — for a tool that is only ever held, like a
-     *  scrub engaged by its `hotkey`. It stays registered and selectable by
-     *  id; only the palette leaves it out. */
-    hide?: boolean;
+/** Which tool is active, plus the stack of tools temporarily held active by a
+ *  hotkey (space-for-hand and the like). The dispatcher reads this to decide
+ *  whose bindings are in scope. */
+interface ActiveToolContextValue {
+    /** The focused tool's id, or `null` when no tool holds the active slot —
+     *  a canvas can run on ambient bindings alone. */
+    active: string | null;
+    hotkeyStack: string[];
+    setActive(id: string | null): void;
+    pushHotkey(id: string): void;
+    /**
+     * Disengage a hotkey-held tool. With `id`, removes that tool's own entry
+     * wherever it now sits — holds do not have to come up in the order they went
+     * down, and popping the top would disengage a tool whose key is still held.
+     * With no id, pops the top.
+     */
+    popHotkey(id?: string): void;
 }
 /**
- * When an entry's bindings are live. A set, not one value: the hand tool is
- * palette-selectable AND engaged by holding space, and both hold at once.
+ * One node of the tool tree. A node that `owns` a tool holds its state; one
+ * that does not — a scope inside a yoke — reads and writes its yoke's.
  */
-interface Eligibility {
-    /** Selectable as the focused entry — exclusive, one at a time. */
-    focus?: boolean;
-    /** Also live while this key is held. */
-    offhand?: HotkeyTrigger;
-    /** Live regardless of what is focused. */
-    always?: boolean;
-    /** Live only for input this entry's own affordances produced. */
-    claimed?: boolean;
-    /** Modality filter, applied wherever it would otherwise be live. */
-    capabilities?: CapabilityTag[];
+declare class ToolNode extends ScopeNode<ToolNode> {
+    private state;
+    private value;
+    constructor(parent: ToolNode | null, descends: boolean, owns: boolean, initialActive: string | null);
+    /** The node whose tool a read here resolves to. */
+    owner(): ToolNode;
+    private update;
+    /** A stable value per owner and state, for `useSyncExternalStore`. */
+    snapshot(): ActiveToolContextValue;
+    subscribe: (listener: () => void) => (() => void);
 }
+/** Props for `<ActiveToolContextProvider>`. */
+interface ActiveToolContextProviderProps {
+    children: ReactNode;
+    /** Seeds the active slot, and wins over the first `useTools` call's
+     *  `active`. Omitted, the slot starts empty and that call seeds it. */
+    initialActive?: string | null;
+}
+/** Provides root active-tool state. Every canvas below has a tool of its own;
+ *  reads and writes here reach the one last used. */
+declare function ActiveToolContextProvider({ children, initialActive, }: ActiveToolContextProviderProps): react.JSX.Element;
+/** The active-tool state in scope. Throws outside a provider; use
+ *  `useOptionalActiveToolContext` where one is not guaranteed. */
+declare function useActiveToolContext(): ActiveToolContextValue;
 /**
- * Where an entry's overlay sits in the layer stack, relative to the
- * selection chrome. `'top'` is the default and renders above everything;
- * the other two exist for chrome that belongs under the selection handles
- * (a snap-target highlight, say). With no selection overlay in the stack,
- * all three collapse to `'top'`.
+ * Like `useActiveToolContext`, but returns `null` when no
+ * `<ActiveToolContextProvider>` is in scope instead of throwing.
  */
-type OverlayPosition = 'top' | 'before-selection' | 'after-selection';
-/** Dep sources an entry provides while it is installed, by dep name. */
-type ContributionDeps = {
-    [K in DepName]?: () => DepSchema[K];
-};
+declare function useOptionalActiveToolContext(): ActiveToolContextValue | null;
 /**
- * What routing reads off an entry: when its bindings are live, which they
- * are, the actions they name, and the deps those actions read.
- */
-interface ContributionRouting {
-    id: string;
-    eligibility: Eligibility;
-    bindings?: GestureBinding[];
-    actions?: Action[];
-    /** Menus this entry declares: always, for an ambient entry; while active, for a tool. */
-    menus?: MenuDef[];
-    /** Dep sources this entry provides while it is installed. A host installs
-     *  them for as long as the entry is registered, whatever its eligibility. */
-    deps?: ContributionDeps;
-}
+ * Mounts an `<ActiveToolContextProvider>` only when no parent provider is in
+ * scope; otherwise renders children unwrapped.
+ */
+declare function ActiveToolContextProviderIfRoot({ children, }: {
+    children: ReactNode;
+}): react.JSX.Element;
+
 /**
- * What an entry draws and how a palette shows it. None of it reaches the
- * dispatcher.
+ * 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.
  */
-interface ContributionChrome<TOverlay = KernelOverlay> {
-    /** One layer, or several composed in the given order.
-     *
-     *  Routing never reads a layer — it collects the live ones and hands them
-     *  back in scope order. `TOverlay` is what the consuming kernel draws;
-     *  `@weasel-js/core` binds it to `RenderLayer<unknown>`. */
-    overlay?: TOverlay | TOverlay[];
-    /** Defaults to `'top'`. Applies to every layer in `overlay`. */
-    overlayPosition?: OverlayPosition;
-    presentation?: ToolPresentation;
+
+/** 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;
+
 /**
- * A registry entry: what it contributes, and when it is eligible. Every role
- * is optional and independent — an entry that only routes input declares only
- * `bindings` and `actions`.
+ * The entries an action contributes to a bar, menu or palette — one per
+ * variant, or the action itself when it declares none.
  */
-interface Contribution<TOverlay = KernelOverlay> extends ContributionRouting, ContributionChrome<TOverlay> {
-    /** Reflection escape hatch — the authored form, when there was one. */
-    def?: unknown;
+
+/** One renderable entry: an action, optionally with params. */
+interface ActionItem {
+    /** `action.id`, or `action.id:variant.key` — unique across a registry. */
+    key: string;
+    action: Action;
+    label: string;
+    icon?: IconRef;
+    /** The action's tags, then the variant's own. */
+    tags: readonly string[];
+    /** What to pass to `trigger(action.id, params)`; absent for a plain action. */
+    params?: Readonly<Record<string, unknown>>;
 }
+/** Expand `action` into the entries a surface renders. An
+ *  action without an immediate invoker has none: `trigger` cannot start a
+ *  drag, so a button for one would do nothing. */
+declare function actionItems(action: Action): ActionItem[];
+/** How a palette titles `item`: a variant reads as its action's
+ *  label and its own ("New: A4"), unless its label already holds the action's
+ *  as whole words ("Zoom In", "Reset Zoom"). */
+declare function actionItemTitle(item: ActionItem): string;
 
 /**
- * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
- * the actions-layer binding-scope / matchBest logic on top.
+ * Project an action's keyboard bindings into the shape a shortcut chip
+ * renders from (`formatShortcut` / `formatShortcutParts` in `@weasel-js/ui`).
  */
 
-/** 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;
-}
+/** One keyboard shortcut, flattened for display: the chip a menu row draws
+ *  (`MenuShortcut` in `@weasel-js/menu`, `ShortcutInput` in `@weasel-js/gestures`). */
+type ActionShortcut = MenuShortcut;
 /**
- * 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.
+ * The chip form of a single gesture spec, or `undefined` when the spec has
+ * none.
  *
- * A predicate declares which it is with `readsAffordance`; one that declares
- * nothing, which only untyped code can write, counts as not reading the hit.
+ * - A spec's `key` may list spellings of one keycap (`['[', '{']` — the
+ *   shifted bracket reports as `'{'`). The first is the shortcut's name.
+ * - A modifier declared `'optional'` matches held or unheld, so it isn't
+ *   part of what the user has to press.
+ *
+ * Non-keyboard specs (drag, wheel, click) have no chip form. Neither does a
+ * *required* `ctrl` or `meta`: the display shape carries only `mod`.
  */
-declare function 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;
+declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
 /**
- * Find every binding that matches the event, sorted by precedence
- * (best → worst). Ordering rules:
+ * Every keyboard shortcut an action answers to, in declaration order.
+ * Specs `keySpecShortcut` has no chip for are skipped, and bindings it leaves
+ * identical are emitted once; an action bound only to those returns empty.
  *
- *   - Scopes by priority: hotkey > active > ambient.
- *   - Within a scope, more-specific bindings beat less-specific (see
- *     `specificity()`).
- *   - Among same-specificity bindings, first-declared wins.
+ * With `params` — an `ActionItem`'s — only the bindings that pass those same
+ * values count, so each variant of `flip` gets its own key.
  */
-declare function 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;
-}
+declare function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
+
 /**
- * {@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.
+ * Finding actions by tag: gathering the ones that carry it, and a person's
+ * search matching it as it matches a label.
  */
-declare function matchSortedWithBarred(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, opts?: {
-    collectBarred?: boolean;
-    warn?: (message: string) => void;
-}): MatchOutcome;
+
+/** The actions carrying `tag`, themselves or on any variant, in
+ *  the order given. Drags included, which have no entries to show. */
+declare function actionsTagged(actions: readonly Action[], tag: string): Action[];
+/** The entries carrying `tag`: what a bar or a menu built from
+ *  a tag shows. A variant that does not carry it is left out. */
+declare function taggedActionItems(actions: readonly Action[], tag: string): ActionItem[];
+/** Whether `item` answers a search for `query`, by its palette title or
+ *  by a tag, and which. */
+declare function matchActionItem(item: ActionItem, query: string): QueryMatch | null;
 
 /**
- * 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.
+ * Palette-side evaluation of `Action.enabled`. The dispatcher calls the
+ * predicate raw as a gate; this is the surface that also enforces the
+ * contract the predicate's JSDoc states — no throwing, under 4ms in dev.
  */
-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';
+
+/**
+ * Result of evaluating an Action's `enabled` predicate.
+ */
+interface ActionEnabledResult {
+    enabled: boolean;
+    reason?: ActionUnavailable;
 }
-/** The one above names the routed view; this one does not. */
- | {
-    step: 'view';
+/**
+ * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`
+ * when no predicate is supplied. Catches throws and treats them as disabled
+ * with reason `'(predicate threw)'`. In dev mode, warns once per action id
+ * when a single call exceeds 4ms (single frame at 240fps — generous; real
+ * predicates should be sub-millisecond).
+ */
+declare function evaluateEnabled(action: Action, deps?: ActionDeps, at?: {
+    x: number;
+    y: number;
+}): ActionEnabledResult;
+/**
+ * Safely evaluate an action's `active` predicate. `undefined` for an action
+ * with no pressed state; a predicate that throws reads as not active.
+ */
+declare function evaluateActive(action: Action, deps?: ActionDeps): boolean | undefined;
+
+/**
+ * The dep registry: named "live source" thunks. Actions declare
+ * `requires: ['selection']`; the dispatcher calls `registry.get('selection')`
+ * at invocation time to build a typed Deps bag.
+ */
+
+/** Holds the live sources an action's declared dependencies resolve to.
+ *  Sources are thunks, read at invocation time, so an action never captures
+ *  stale state. */
+interface DepRegistry {
+    /** Adds a live source for `name` over any already there. `below` answers
+     *  what the registry would without this source, so one can handle part of
+     *  a dep and hand the rest to the default it displaced. */
+    register<K extends DepName>(name: K, source: DepSource<K>): () => void;
+    get<K extends DepName>(name: K): DepSchema[K] | undefined;
+    /** Hear that what the registry answers may have changed: a source was
+     *  registered or released anywhere in its tree, or an owner called
+     *  {@link DepRegistry.changed}. Returns the unsubscribe. A hand-built
+     *  registry whose answers never change leaves this and `changed` out. */
+    subscribe?(listener: () => void): () => void;
+    /** Say that a source's value changed. A source is a thunk read on demand,
+     *  so its owner is the only one who knows; chrome showing an action's
+     *  `enabled` or `active` state re-reads on this. */
+    changed?(): void;
+    /** Every name a `get` here would answer, sorted, with where its live
+     *  source sits. For inspection; a hand-built registry may leave it out. */
+    list?(): readonly DepListing[];
+}
+/** A live source for dep `K`: a thunk read at invocation time. `below` reads
+ *  the source this one displaced, under it in its scope or in a scope above. */
+type DepSource<K extends DepName> = (below: () => DepSchema[K] | undefined) => DepSchema[K];
+/** One name a dep registry answers, as {@link DepRegistry.list} reports it. */
+interface DepListing {
+    name: string;
+    /** How many scopes above the asking one the live source was registered: 0 for its own. */
+    depth: number;
+    /** How many sources that scope holds under the name, the live one included. */
+    stacked: number;
 }
-/** The one above sits in a higher scope tier. */
- | {
-    step: 'tier';
+/** One node of the dep tree: the sources registered at it, over its parent's.
+ *  Each name holds a stack of sources, newest live, so a displaced source is
+ *  restored when the one above it leaves. */
+declare class DepNode extends ScopeNode<DepNode> {
+    private readonly sources;
+    readonly registry: DepRegistry;
+    constructor(parent: DepNode | null, descends: boolean);
 }
-/** Same tier; the one above is more specific in `part`. */
- | {
-    step: 'specificity';
-    part: SpecificityPart;
+/**
+ * A stock dep registry with no parent: what `<DepRegistryProvider>` mounts,
+ * for a dispatcher driven without React. Sources registered under one name
+ * stack, newest live, and releasing one restores the one beneath it.
+ */
+declare function createDepRegistry(): DepRegistry;
+
+/**
+ * Shared dep-bag builder — the single implementation behind both the gesture
+ * dispatcher's per-invocation `buildDeps` and `ActionsRegistry.trigger`'s
+ * `requires` branch. Reads the action's declared `requires`, resolves each
+ * name against the `DepRegistry`, and (dev builds only) wraps the bag in a
+ * Proxy that warns on undeclared reads.
+ */
+
+/** Build the deps bag for an action from its declared `requires`. */
+declare function buildDepsFromRequires(action: Action, depRegistry: DepRegistry): ActionDeps;
+
+/**
+ * Binding overrides: a host's replacements for bindings it did not write,
+ * keyed by binding id. An override replaces or removes one binding, on an
+ * action or on a contribution alike; adding a key beside the defaults is
+ * `tune`'s job.
+ */
+
+/** Overrides by binding id: a route string or spec to bind instead, or `null` to unbind. */
+type BindingOverrides = Readonly<Record<string, BindingOverrideInput>>;
+/** Overrides read into specs, one per binding id. */
+type ResolvedBindingOverrides = ReadonlyMap<string, GestureSpec | null>;
+/** A binding's id: its declared `opts.id`, else its owner and its position
+ *  there — `<entry>#<n>` for an entry's binding (`ownerId`), `<action>@<n>` for
+ *  an action's own (`ownerId` null), so an entry and an action of one id never
+ *  share a derived id. */
+declare function bindingId(b: GestureBinding, ownerId: string | null, index: number): string;
+/** Merge override maps into one, a later map winning per id. A route string
+ *  that does not parse is skipped with a warning, leaving the binding as it was. */
+declare function resolveBindingOverrides(maps: readonly BindingOverrides[]): ResolvedBindingOverrides;
+/** The bindings `ownerId` declares, each under its override, the unbound ones
+ *  left out: what dispatch routes by. A `null` owner is an action's own. */
+declare function overriddenBindings(bindings: readonly GestureBinding[], ownerId: string | null, overrides?: ResolvedBindingOverrides): GestureBinding[];
+
+/** Hotkey-slot trigger key. The slot is engaged while this key is held —
+ *  hence "hotkey": active as long as the key is hot. Omitted means the tool
+ *  is not eligible for the hotkey slot.
+ *
+ *  The named keys map to their DOM names (`'space'` is `' '`, `'ctrl'` is
+ *  `'Control'`). Anything else is a `KeyboardEvent.key` value, matched
+ *  case-insensitively as every key spec is — so `'o'` holds on O. */
+type HotkeyTrigger = 'space' | 'alt' | 'ctrl' | 'meta' | 'shift' | (string & {});
+/** Presentation metadata for tool palettes / menus. Optional on every
+ *  tool — consumers that render a palette (`<ToolPalette>`) read these
+ *  fields to display the tool; consumers that don't can ignore them.
+ *
+ *  Note: cursor is NOT here. `Tool.cursor` (inherited from `Contribution`)
+ *  is already plumbed through `<Canvas>` to `style.cursor` on the host. */
+interface ToolPresentation {
+    /** Human-readable label, distinct from the `id`. Falls back to `id`. */
+    label?: string;
+    /** The tool's icon, by qualified name: `icon('rect')` in the package that draws it. */
+    icon?: _weasel_js_icons.IconRef;
+    /** Palette grouping key. Tools sharing a group render contiguously
+     *  with separators between groups. Free-form string; the kit
+     *  recommends 'select' | 'shape' | 'draw' | 'type' | 'view'. */
+    group?: string;
+    /** Display override for the keyboard shortcut. When omitted the palette
+     *  derives one from `Tool.keybinding` via its own formatter. */
+    shortcut?: string;
+    /** Keep the tool off palettes — for a tool that is only ever held, like a
+     *  scrub engaged by its `hotkey`. It stays registered and selectable by
+     *  id; only the palette leaves it out. */
+    hide?: boolean;
 }
-/** Tied; the one above is gated by an `eligible` rule that holds. */
- | {
-    step: 'context';
+/**
+ * When an entry's bindings are live. A set, not one value: the hand tool is
+ * palette-selectable AND engaged by holding space, and both hold at once.
+ */
+interface Eligibility {
+    /** Selectable as the focused entry — exclusive, one at a time. */
+    focus?: boolean;
+    /** Also live while this key is held. */
+    offhand?: HotkeyTrigger;
+    /** Live regardless of what is focused. */
+    always?: boolean;
+    /** Live only for input this entry's own affordances produced. */
+    claimed?: boolean;
+    /** Modality filter, applied wherever it would otherwise be live. */
+    capabilities?: CapabilityTag[];
+    /** A keymap: live only while it is the innermost one open, at the hotkey
+     *  tier. `unbound` overrides the `gestures.keymapUnbound` kit setting for
+     *  this keymap. Open one with a leader (`keymapContribution`). */
+    keymap?: true | {
+        unbound?: KeymapUnbound;
+    };
 }
-/** Tied on everything; registration order. */
- | {
-    step: 'order';
+/**
+ * Where an entry's overlay sits in the layer stack, relative to the
+ * selection chrome. `'top'` is the default and renders above everything;
+ * the other two exist for chrome that belongs under the selection handles
+ * (a snap-target highlight, say). With no selection overlay in the stack,
+ * all three collapse to `'top'`.
+ */
+type OverlayPosition = 'top' | 'before-selection' | 'after-selection';
+/** Dep sources an entry provides while it is installed, by dep name. */
+type ContributionDeps = {
+    [K in DepName]?: () => DepSchema[K];
 };
-/** 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. */
- | {
-    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';
+/**
+ * What routing reads off an entry: when its bindings are live, which they
+ * are, the actions they name, and the deps those actions read.
+ */
+interface ContributionRouting {
+    id: string;
+    eligibility: Eligibility;
+    bindings?: GestureBinding[];
+    actions?: Action[];
+    /** Menus this entry declares: always, for an ambient entry; while active, for a tool. */
+    menus?: MenuDef[];
+    /** Dep sources this entry provides while it is installed. A host installs
+     *  them for as long as the entry is registered, whatever its eligibility. */
+    deps?: ContributionDeps;
 }
-/** Below the winner; never asked. */
- | {
-    kind: 'not-asked';
+/**
+ * What an entry draws and how a palette shows it. None of it reaches the
+ * dispatcher.
+ */
+interface ContributionChrome<TOverlay = KernelOverlay> {
+    /** One layer, or several composed in the given order.
+     *
+     *  Routing never reads a layer — it collects the live ones and hands them
+     *  back in scope order. `TOverlay` is what the consuming kernel draws;
+     *  `@weasel-js/core` binds it to `RenderLayer<unknown>`. */
+    overlay?: TOverlay | TOverlay[];
+    /** Defaults to `'top'`. Applies to every layer in `overlay`. */
+    overlayPosition?: OverlayPosition;
+    presentation?: ToolPresentation;
 }
-/** 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;
+/**
+ * A registry entry: what it contributes, and when it is eligible. Every role
+ * is optional and independent — an entry that only routes input declares only
+ * `bindings` and `actions`.
+ */
+interface Contribution<TOverlay = KernelOverlay> extends ContributionRouting, ContributionChrome<TOverlay> {
+    /** Reflection escape hatch — the authored form, when there was one. */
+    def?: unknown;
 }
 
 /**
@@ -1866,6 +2090,30 @@ interface DispatcherContext {
      * reads as the root.
      */
     viewId?: string | null;
+    /**
+     * For a key from the page: whether this surface holds the keys, and whether
+     * the pointer is over it. Bindings with `opts.over` are live only while it
+     * is, the rest only while it holds them. Absent, every binding is live.
+     */
+    keyReach?: KeyReach;
+    /** The keymaps open on this surface. Absent: none can open. */
+    keymaps?: KeymapStack;
+    /** Which bindings this pass of an input reaches while a keymap is open:
+     *  `'only'` the innermost keymap's, `'none'` everything but it. Absent: both. */
+    keymapPass?: 'only' | 'none';
+    /** What a key no open keymap binds does, unless the keymap says: the
+     *  `gestures.keymapUnbound` kit setting. Default `'modal'`. */
+    leaderUnbound?: KeymapUnbound;
+    /** The binding overrides in force, read per input, for contribution bindings;
+     *  the registry lays them over actions' own. Absent overrides nothing. */
+    bindingOverrides?: () => ResolvedBindingOverrides;
+    /** Where the dispatcher records how it resolved each input. Absent records nothing. */
+    trace?: DispatchTrace;
+}
+/** Which of a surface's key bindings a key from the page reaches. */
+interface KeyReach {
+    held: boolean;
+    over: boolean;
 }
 /**
  * Handle returned by `Dispatcher.beginUiOngoing()` for driving an
@@ -2073,31 +2321,6 @@ interface Dispatcher {
     beginUiOngoing(actionId: string, deps: ActionDeps, params?: Record<string, unknown>): UiOngoingControl | null;
 }
 
-/**
- * Dev-only trace of what the dispatcher did: one record per resolved input and
- * one per mode switch, in a rolling buffer the dev tools read.
- */
-
-/** 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 `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;
-/** Push a mode-switch record into the trace log. Safe to call from
- *  anywhere; no-ops outside DEV. */
-declare function recordModeSwitch(mode: string, from: string | null, to: string | null, detail?: string): void;
-
 /**
  * The slot an in-flight ongoing handle is keyed by:
  * - `key-held`: `key-held-<code>` (`key-held-Space`), so two keys that share a
@@ -2188,6 +2411,12 @@ interface ActionsRegistry {
      *  passes `given`: every tuning's params, `given` laid over them. What a
      *  tool's chrome reads to show what the action it binds will do. */
     paramsOf(id: string, given?: Record<string, unknown>): Record<string, unknown>;
+    /** Replace or remove bindings by id, here and in scopes below. Holders
+     *  merge: an inner scope's beats an outer one's, and a later one beats an
+     *  earlier one in the same scope. Returns a release. See {@link BindingOverrides}. */
+    overrideBindings(overrides: BindingOverrides): () => void;
+    /** Every override in force from this scope, read into specs. */
+    bindingOverrides(): ResolvedBindingOverrides;
     list(): readonly Action[];
     /** Fire an immediate-invoker action by id. The optional `params` arg is
      *  forwarded to `ImmediateInvoker.run` as its second argument — use it for
@@ -2269,8 +2498,8 @@ interface ToolOffhandBindingSpec {
 declare function offhandKeyFor(trigger: HotkeyTrigger): string;
 /** Build the per-tool `BoundGesture` list for the consolidated action's
  *  `defaultBinding`. Each entry pairs a `key-held` spec with
- *  `opts.params.toolId` so the invoker's `start` can pick out which tool
- *  to engage.
+ *  `opts.params.toolId`, so the invoker's `start` can pick out which tool
+ *  to engage, and is overridden as `tool.offhand.<toolId>`.
  *
  *  An offhand tool engages only between gestures. Swapping the tool out
  *  mid-drag would cancel the drag, and the key is free for the gesture's own
@@ -2430,6 +2659,7 @@ declare function createLongPressStore(): LongPressStore;
  * The `gestures` kit settings area. Declared here rather than in core because
  * the dispatcher reads it, and routing sits below core.
  */
+
 /** Pointer gesture timings and travel; each falls back to its constant in `@weasel-js/gestures`. */
 interface GestureKitSettings {
     /** Longest gap between the clicks of a double click, in ms. */
@@ -2442,6 +2672,9 @@ interface GestureKitSettings {
     tapPx: number;
     /** Travel that makes a press a drag, in CSS px. */
     dragPx: number;
+    /** What a key an open keymap does not bind does: `'modal'` swallows it,
+     *  `'cascade'` closes the keymap and lets it through. */
+    keymapUnbound: KeymapUnbound;
 }
 declare module '@weasel-js/react' {
     interface KitSettings {
@@ -2569,6 +2802,8 @@ interface EligibilityState {
     engagedIds?: ReadonlySet<string>;
     /** Whether the active mode allows these capability tags. Omitted → allow. */
     allows?: (tags: readonly CapabilityTag[]) => boolean;
+    /** The innermost open keymap's id: the one keymap entry that is live. */
+    openKeymap?: string | null;
 }
 /**
  * The scope tier an entry's bindings are live at, or null when none are.
@@ -2584,7 +2819,7 @@ declare function liveScope(id: string, eligibility: Eligibility, state: Eligibil
  * breaks ties by declaration order, so the caller's entry order decides which
  * of two same-specificity bindings in one tier wins.
  */
-declare function scopeBindings(entries: Iterable<Contribution<unknown>>, state: EligibilityState): ScopedBinding[];
+declare function scopeBindings(entries: Iterable<Contribution<unknown>>, state: EligibilityState, overrides?: ResolvedBindingOverrides): ScopedBinding[];
 /** What decides which entries are live, and in what order they are walked. */
 interface AssemblyInputs {
     focusedId: string | null;
@@ -2593,6 +2828,8 @@ interface AssemblyInputs {
     /** The capability tags the active mode allows. Omitted: no mode system, so
      *  every entry is allowed. */
     allowedCapabilities?: ReadonlySet<CapabilityTag>;
+    /** The innermost open keymap's id, if one is open. */
+    openKeymap?: string | null;
 }
 /**
  * The entry set as routing walks it, with the state that tiers it. The
@@ -2661,6 +2898,126 @@ declare function modeShortcutSpec(shortcut: string): KeySpec;
  */
 declare function modeShortcuts(registry: ModeRegistry, handlers: ModeShortcutHandlers): Contribution<never>;
 
+/**
+ * A keymap and the leader that opens it, from one definition. The keymap is an
+ * entry whose bindings are live only while it is open; the leader is an
+ * action on the hotkey tier, so it outranks what the active tool binds to the
+ * same key, and it opens the keymap mid-gesture as well as between them.
+ */
+
+/** What {@link keymapContribution} builds a keymap and its leader from. */
+interface KeymapDef<TOverlay = never> {
+    /** The keymap entry's id. Its leader action is `keymap.<id>`. */
+    id: string;
+    /** What the hint and a shortcut chip call it: `Loupe ▸ 2`. */
+    label: string;
+    /** The keystroke, or keystrokes, that open it. A `key-held` spec is read as
+     *  its `key` form: holding the key is what holds the keymap open. */
+    leader: GestureSpec | readonly GestureSpec[];
+    /** The keymap's own bindings. Escape is not one: it always closes the keymap. */
+    bindings: readonly GestureBinding[];
+    /** Actions the bindings name that are not registered elsewhere. */
+    actions?: readonly Action[];
+    /** Overrides the `gestures.keymapUnbound` kit setting for this keymap. */
+    unbound?: KeymapUnbound;
+    /** Drawn while the keymap is open. */
+    overlay?: TOverlay | TOverlay[];
+    overlayPosition?: OverlayPosition;
+}
+/** The leader action's id for keymap `id`. */
+declare const keymapLeaderId: (id: string) => string;
+/** The binding id of a keymap's leader — what a binding override rebinds it by.
+ *  A second leader key is `<id>#1`, and so on. */
+declare const keymapLeaderBindingId: (id: string, index?: number) => string;
+/** `[keymap entry, leader entry]`. Triggered without a key, the leader opens
+ *  its keymap tapped; `trigger('keymap.<id>', { hold: true })` holds it open
+ *  until Escape. Install both, with `<SceneCanvas ambient>`
+ *  or `useTools`'s `ambient`; the leader entry carries the actions. */
+declare function keymapContribution<TOverlay = never>(def: KeymapDef<TOverlay>): Contribution<TOverlay>[];
+
+/** One row of a keymap's hint: a key chip, or a pointer gesture in words, and what it does. */
+interface KeymapRow {
+    shortcut?: MenuShortcut;
+    gesture?: string;
+    label: string;
+}
+/** An open keymap as a hint shows it: {@link describeKeymap}'s result. */
+interface KeymapDescription {
+    id: string;
+    label: string;
+    /** Whether a held leader is keeping it open. */
+    held: boolean;
+    rows: readonly KeymapRow[];
+}
+/** The rows a hint lists for an open keymap, under the overrides in force. */
+declare function describeKeymap(level: OpenKeymap, actions: readonly Action[], overrides?: ResolvedBindingOverrides): KeymapDescription;
+/**
+ * Every key in `def` as a menu chip, by action id, each carrying the path
+ * through its leader (`Loupe ▸ 2`), under `overrides`. A keymap with no key
+ * leader gives its keys no path.
+ */
+declare function keymapShortcuts(def: KeymapDef, overrides?: ResolvedBindingOverrides): ReadonlyMap<string, readonly MenuShortcut[]>;
+
+/** Options for {@link captureKey}. */
+interface CaptureKeyOptions {
+    /** Capture the held form, `key-held`, rather than the keystroke. */
+    held?: boolean;
+    /** Stop listening and resolve `null`. */
+    signal?: AbortSignal;
+    /** Whether Cmd is Mod. Defaults to the detected platform. */
+    apple?: boolean;
+}
+/**
+ * The next keystroke on `target` as a key spec: {@link captureGesture} taking
+ * a keystroke alone, and leaving the pointer to the page. A bare modifier is
+ * waited past. Write the result with `keySpecRoute` to persist it as a binding
+ * override.
+ */
+declare function captureKey(target: EventTarget, opts?: CaptureKeyOptions): Promise<KeySpec | KeyHeldSpec | null>;
+
+/** A spec kind a binding editor can capture. */
+type CaptureKind = 'key' | 'key-held' | 'click' | 'doubleClick' | 'drag' | 'contextMenu';
+/** What `captureGesture` resolves to. */
+type CapturedSpec = KeySpec | KeyHeldSpec | ClickSpec | DoubleClickSpec | DragSpec | ContextMenuSpec;
+
+/** The click-and-drag thresholds a capture reads, each defaulting to its constant. */
+interface CaptureThresholds {
+    dragPx?: number;
+    doubleClickMs?: number;
+    doubleClickPx?: number;
+}
+
+/** Options for {@link captureGesture}. */
+interface CaptureGestureOptions extends CaptureThresholds {
+    /** The kinds to take; input of any other kind is waited past. A keystroke
+     *  is taken as `key` when both `key` and `key-held` are listed. Defaults to
+     *  `key`, `click`, `doubleClick`, `drag` and `contextMenu`. */
+    kinds?: readonly CaptureKind[];
+    /** Stop listening and resolve `null`. */
+    signal?: AbortSignal;
+    /** Whether Cmd is Mod. Defaults to the detected platform. */
+    apple?: boolean;
+    /** Travel that makes a press a drag, in CSS px: pass the `gestures.dragPx`
+     *  kit setting. Defaults to `DRAG_THRESHOLD_PX`. */
+    dragPx?: number;
+    /** The `gestures.doubleClickMs` kit setting. Defaults to `DOUBLE_CLICK_MAX_MS`. */
+    doubleClickMs?: number;
+    /** The `gestures.doubleClickPx` kit setting. Defaults to `DOUBLE_CLICK_MAX_PX`. */
+    doubleClickPx?: number;
+}
+/**
+ * The next input on `target` of one of `opts.kinds`, as a gesture spec, for a
+ * binding editor: its modifiers with the platform's primary one as `mod`. A
+ * press is told a click or a drag by the dispatcher's own recognizer, at its
+ * drag threshold; a click is held back for a double click only when both are
+ * asked for. A bare modifier key is waited past. Escape, or an abort, resolves
+ * `null`. What it takes is `preventDefault`ed and stopped, the click a browser
+ * follows a press with included, so nothing else acts on it. The pointer is
+ * left alone when no pointer kind is asked for, and keys other than Escape
+ * when no key kind is.
+ */
+declare function captureGesture(target: EventTarget, opts?: CaptureGestureOptions): Promise<CapturedSpec | null>;
+
 /**
  * A tool's activation key, as `ToolDef.keybinding` declares it. Captures
  * only the fields meaningful to a tool-select key —
@@ -2798,6 +3155,29 @@ interface ToolDef<TOverlay = KernelOverlay> {
  */
 declare function defineTool<TOverlay = KernelOverlay>(def: ToolDef<TOverlay>): Tool<TOverlay>;
 
+/**
+ * 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
+ * its state; whatever mounts the set supplies the tool for each id.
+ */
+/** A named group of tool ids. A member is an id or another set, whose ids it takes in order. */
+interface ToolSet<TId extends string = string> {
+    readonly id: string;
+    readonly members: readonly (TId | ToolSet<TId>)[];
+}
+/** One entry of a list of tools to mount: an id, or a set of them. */
+type ToolEntry<TId extends string = string> = TId | ToolSet<TId>;
+/** A set named `id` of `members`, in palette order. */
+declare function toolSet<TId extends string>(id: string, members: readonly ToolEntry<TId>[]): ToolSet<TId>;
+/** Whether `entry` is a set rather than a single id. */
+declare function isToolSet<TId extends string>(entry: ToolEntry<TId>): entry is ToolSet<TId>;
+/** Every id `entries` name, sets opened in place, each id once at its first place. */
+declare function toolIdsOf<TId extends string>(entries: readonly ToolEntry<TId>[]): TId[];
+/** `set` less every id `omit` names, sets opened. Keeps `set`'s id with a `-without` suffix. */
+declare function withoutTools<TId extends string>(set: ToolSet<TId>, ...omit: readonly ToolEntry<TId>[]): ToolSet<TId>;
+/** Whether `set` names `id`, directly or through a set inside it. */
+declare function toolSetHas<TId extends string>(set: ToolSet<TId>, id: string): boolean;
+
 /**
  * One row in the route registry — a single `GestureBinding` on one tool,
  * flattened into the route grammar's vocabulary so the inspector, the
@@ -2944,6 +3324,9 @@ interface ToolScopes {
      *  definition). Two gated actions conflict only when some mode lets both
      *  rules hold. Default: the kit's `DEFAULT_MODES`. */
     modes?: readonly ActiveMode[];
+    /** Binding overrides in force, applied to the entries' bindings. Actions are
+     *  read as given: an `ActionsRegistry`'s `list()` has applied them already. */
+    overrides?: ResolvedBindingOverrides;
 }
 /**
  * Detect reachable route conflicts in an assembled tool set and report each one.
@@ -3092,12 +3475,21 @@ declare function deleteScratch<T>(store: ScratchStore, key: ScratchKey<T>): bool
  *
  * Output shape: **files first (source order), then strings (item order)**.
  * For paste (`itemsFromClipboardData`) string flavors are emitted in
- * `INGEST_STRING_MIMES` order: text/plain, text/html, text/uri-list.
+ * `INGEST_STRING_MIMES` order: text/plain, text/html, text/uri-list, then
+ * the admitted ones in the order they were first admitted.
  */
 
-/** The string flavors the kit normalizes. Everything else (browser-internal
- *  custom flavors, etc.) is dropped at materialization. */
+/** The string flavors the kit always keeps. Any other is dropped at
+ *  materialization unless {@link admitIngestMime} has admitted it. */
 declare const INGEST_STRING_MIMES: ReadonlySet<string>;
+/**
+ * Keep string flavors of `mime` on drops, drags and pastes as well as the
+ * {@link INGEST_STRING_MIMES}, so content from the app's own UI can travel
+ * under a type of its own. Returns a release; the flavor is kept while any
+ * admission of it is unreleased. Core admits each exact MIME a registered
+ * content handler names.
+ */
+declare function admitIngestMime(mime: string): () => void;
 /** Wrap raw `File`s (file picker, `CanvasExtensionApi.ingest`) as
  *  `IngestItem`s, normalizing each MIME the same way the drop/paste paths
  *  do. Synchronous — `File` objects are already fully owned. */
@@ -3202,6 +3594,10 @@ interface DepSchema {
     activeTool: ActiveToolContextValue;
     /** 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 dep name declared by anything that has merged into {@link DepSchema}. */
 type DepName = keyof DepSchema;
@@ -3249,4 +3645,4 @@ type KernelOverlay = OverlaySchema extends {
     overlay: infer O;
 } ? O : unknown;
 
-export { type CarryCallbacks as $, type Action as A, type BoundGesture as B, type Contribution as C, type DepRegistry as D, type ActionSource as E, type ActionTuning as F, type ActionTunings as G, type ActionsProp as H, type AnyTool as I, type AssemblyInputs as J, type KernelOverlay as K, type LongPressOptions as L, type MenuHost as M, type NodeId as N, type OverlayPosition as O, BROWSER_RESERVED_CHORDS as P, type BindingOpts as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type BindingScope as U, type BindingSource as V, type BodyPredicate as W, type Bounds as X, type BuildRuleCtxArgs as Y, COARSE_TARGET_SCALE as Z, type Carry as _, type DepName as a, type ResizeAnchor as a$, type CarryPayload as a0, type CarryPointer as a1, type CarryStage as a2, type Condition as a3, type Conflict as a4, type ContributionChrome as a5, type ContributionDeps as a6, type ContributionRouting as a7, DEFAULT_ALLOWED_CAPABILITIES as a8, DEFAULT_DEVICE_PROFILE as a9, type MenuSources as aA, type MenuWhen as aB, type ModeShortcutHandlers as aC, type ModeSwitchLogEntry as aD, type ModifierRole as aE, type ModifierRoles as aF, type ModifierState as aG, NEVER as aH, type OngoingHandle as aI, type OngoingInvoker as aJ, type OngoingOverlay as aK, type OpenMenu as aL, type OverlayRole as aM, type OverlaySchema as aN, type OwnedMenuDef as aO, PREDICATE_TARGET as aP, type PendingLongPress as aQ, type PlacedBy as aR, type Point2 as aS, type PointerSession as aT, type PointerSessionCallbacks as aU, type PointerSessionCancelReason as aV, type PointerSessionOptions as aW, type RankedCandidate as aX, type RecordCandidate as aY, type RegistryEntry as aZ, type ReservedChord as a_, type DebugSink as aa, type DetectedDeviceFacts as ab, type DeviceProfile as ac, type DispatchRecord as ad, type DispatchRecordInput as ae, type DispatcherContext as af, type DragSample as ag, type DroppedCandidate as ah, type Eligibility as ai, type EligibilityState as aj, type GestureBinding as ak, type GestureKitSettings as al, type HandleKind as am, type HitShape as an, type HotkeyTrigger as ao, INGEST_STRING_MIMES as ap, type ImmediateInvoker as aq, type InvocationCtx as ar, type Invoker as as, type KeyBinding as at, type LongPressState as au, type LongPressStore as av, type MatchOutcome as aw, type MatchResult as ax, type MenuHit as ay, type MenuOpenRequest as az, type DepSchema as b, isPathEditPart as b$, type ResolveAllOptions as b0, type ResolveOnlyResult as b1, type ResolvedCandidate as b2, type RoleKeys as b3, type RoleRebinds as b4, type Rule as b5, type ScopedBinding as b6, type ScratchKey as b7, type ScratchStore as b8, type SelectionApi as b9, buildToolOffhandBindings as bA, clientToCanvas as bB, clientToCanvasRect as bC, createDepRegistry as bD, createDispatcher as bE, createLongPressStore as bF, createMenuHost as bG, defineTool as bH, deleteScratch as bI, describeRule as bJ, dlog as bK, dwarn as bL, evaluate as bM, evaluateActive as bN, evaluateEnabled as bO, findConflicts as bP, getScratch as bQ, heldKeySpec as bR, historyKey as bS, isAnchor as bT, isAnchorOrControl as bU, isBalanceGrip as bV, isBody as bW, isControlHandle as bX, isCornerWidget as bY, isDebugEnabled as bZ, isEmpty as b_, type Selector as ba, type SpecificityPart as bb, TOOL_OFFHAND_ID as bc, type ToolDef as bd, type ToolKeybinding as be, type ToolModifiers as bf, type ToolOffhandBindingSpec as bg, type ToolPresentation as bh, type ToolScopes as bi, type ToolSlot as bj, type TraceLogEntry as bk, type TunedBinding as bl, type UiOngoingControl as bm, type ViewportGestureKind as bn, type WalkStep as bo, actionBindings as bp, actionCursor as bq, actionItemTitle as br, actionItems as bs, actionShortcuts as bt, actionsTagged as bu, assembleEntries as bv, browserReservedChord as bw, buildDepsFromRequires as bx, buildRouteRegistry as by, buildRuleCtx as bz, type ActionDeps as c, isResizeHandle as c0, isRotateHandle as c1, isSegment as c2, isSelectedBody as c3, isTool as c4, isUnselectedBody as c5, itemTypesFromDataTransfer as c6, itemsFromClipboardData as c7, itemsFromDataTransfer as c8, itemsFromFiles as c9, routesForSpec as cA, ruleCanHoldIn as cB, rulesExclusive as cC, scopeBindings as cD, scratchKey as cE, setScratch as cF, startCarry as cG, taggedActionItems as cH, targetConsultsAffordance as cI, tuneAction as cJ, validateActionDefaultBinding as cK, validateActionId as cL, keySpecShortcut as ca, keysHeld as cb, liveScope as cc, makeToolOffhandAction as cd, matchActionItem as ce, matchBest as cf, matchSorted as cg, matchSortedWithBarred as ch, matchesKeyBinding as ci, mergeContributions as cj, mergeMenuDefs as ck, modeShortcutSpec as cl, modeShortcuts as cm, multiTouchGestureId as cn, offhandKeyFor as co, openPointerSession as cp, overlaysOf as cq, pickMenu as cr, pointerGestureId as cs, recordModeSwitch as ct, reportRouteConflicts as cu, resolveDeviceProfile as cv, resolveMenu as cw, resolveParams as cx, resolveSchemaMenu as cy, roleReader as cz, type ActionsRegistry as d, ActionDisabledReason as e, type ActionVariant as f, type MenuDef as g, DepNode as h, type Tool as i, ActiveToolContextProvider as j, ActiveToolContextProviderIfRoot as k, type ActiveToolContextProviderProps as l, type ActiveToolContextValue as m, useOptionalActiveToolContext as n, type Dispatcher as o, type AffordanceHit as p, ALWAYS as q, type ActionDispatch as r, type ActionEnabledResult as s, type ActionEntry as t, useActiveToolContext as u, type ActionItem as v, type ActionParamSchema as w, type ActionParams as x, type ActionPresentation as y, type ActionShortcut as z };
+export { type BindingScope 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 AnyTool as W, type AssemblyInputs as X, BROWSER_RESERVED_CHORDS as Y, type BindingOpts as Z, type BindingOverrides as _, type DepName as a, NEVER as a$, type BindingSource as a0, type BodyPredicate as a1, type Bounds as a2, type BuildRuleCtxArgs as a3, COARSE_TARGET_SCALE as a4, type CaptureGestureOptions as a5, type CaptureKeyOptions as a6, type CaptureKind as a7, type CapturedSpec as a8, type Carried as a9, type HitShape as aA, type HotkeyTrigger as aB, INGEST_STRING_MIMES as aC, type ImmediateInvoker as aD, type InvocationCtx as aE, type Invoker as aF, KEYMAP_HOLD as aG, type KeyBinding as aH, type KeyReach as aI, type KeymapDef as aJ, type KeymapRow as aK, type KeymapStack as aL, type KeymapUnbound as aM, type KeymapVerdict as aN, type LongPressState as aO, type LongPressStore as aP, type MatchOutcome as aQ, type MatchResult as aR, type MenuHit as aS, type MenuOpenRequest as aT, type MenuSources as aU, type MenuWhen as aV, type ModeShortcutHandlers as aW, type ModeSwitchLogEntry as aX, type ModifierRole as aY, type ModifierRoles as aZ, type ModifierState as a_, type Carry as aa, type CarryCallbacks as ab, type CarryPayload as ac, type CarryPointer as ad, type CarryStage as ae, type Condition as af, type Conflict as ag, type ContributionChrome as ah, type ContributionDeps as ai, type ContributionRouting as aj, DEFAULT_ALLOWED_CAPABILITIES as ak, DEFAULT_DEVICE_PROFILE as al, type DebugSink as am, type DepListing as an, type DetectedDeviceFacts as ao, type DeviceProfile as ap, type DispatchRecord as aq, type DispatchRecordInput as ar, type DispatcherContext as as, type DragSample as at, type DroppedCandidate as au, type Eligibility as av, type EligibilityState as aw, type GestureBinding as ax, type GestureKitSettings as ay, type HandleKind as az, type DepSource as b, buildRuleCtx as b$, type OngoingHandle as b0, type OngoingInvoker as b1, type OngoingOverlay as b2, type OpenKeymap as b3, type OpenMenu as b4, type OverlayRole as b5, type OverlaySchema as b6, type OwnedMenuDef as b7, PREDICATE_TARGET as b8, type PendingLongPress as b9, type ToolEntry as bA, type ToolKeybinding as bB, type ToolModifiers as bC, type ToolOffhandBindingSpec as bD, type ToolPresentation as bE, type ToolScopes as bF, type ToolSet as bG, type ToolSlot as bH, type TraceLogEntry as bI, type TraceRing as bJ, type TunedBinding as bK, type UiOngoingControl as bL, type ViewportGestureKind as bM, type WalkStep as bN, actionBindings as bO, actionCursor as bP, actionItemTitle as bQ, actionItems as bR, actionSettingsParams as bS, actionShortcuts as bT, actionsTagged as bU, admitIngestMime as bV, assembleEntries as bW, bindingId as bX, browserReservedChord as bY, buildDepsFromRequires as bZ, buildRouteRegistry as b_, type PlacedBy as ba, type Point2 as bb, type PointerSession as bc, type PointerSessionCallbacks as bd, type PointerSessionCancelReason as be, type PointerSessionOptions as bf, type RankedCandidate as bg, type RecordCandidate as bh, type RegistryEntry as bi, type ReservedChord as bj, type ResizeAnchor as bk, type ResolveAllOptions as bl, type ResolveOnlyResult as bm, type ResolvedBindingOverrides as bn, type ResolvedCandidate as bo, type RoleKeys as bp, type RoleRebinds as bq, type Rule as br, type ScopedBinding as bs, type ScratchKey as bt, type ScratchStore as bu, type SelectionApi as bv, type Selector as bw, type SpecificityPart as bx, TOOL_OFFHAND_ID as by, type ToolDef as bz, type ActionDeps as c, offhandKeyFor as c$, buildToolOffhandBindings as c0, captureGesture as c1, captureKey as c2, clientToCanvas as c3, clientToCanvasRect as c4, createDepRegistry as c5, createDispatchTrace as c6, createDispatcher as c7, createKeymapStack as c8, createLongPressStore as c9, isSegment as cA, isSelectedBody as cB, isTool as cC, isToolSet as cD, isUnselectedBody as cE, itemTypesFromDataTransfer as cF, itemsFromClipboardData as cG, itemsFromDataTransfer as cH, itemsFromFiles as cI, keySpecShortcut as cJ, keymapContribution as cK, keymapLeaderBindingId as cL, keymapLeaderId as cM, keymapShortcuts as cN, keysHeld as cO, liveScope as cP, makeToolOffhandAction as cQ, matchActionItem as cR, matchBest as cS, matchSorted as cT, matchSortedWithBarred as cU, matchesKeyBinding as cV, mergeContributions as cW, mergeMenuDefs as cX, modeShortcutSpec as cY, modeShortcuts as cZ, multiTouchGestureId as c_, createMenuHost as ca, createTraceRing as cb, defineTool as cc, deleteScratch as cd, describeKeymap as ce, describeRule as cf, dlog as cg, dwarn as ch, evaluate as ci, evaluateActive as cj, evaluateEnabled as ck, findConflicts as cl, getScratch as cm, heldKeySpec as cn, historyKey as co, isAnchor as cp, isAnchorOrControl as cq, isBalanceGrip as cr, isBody as cs, isControlHandle as ct, isCornerWidget as cu, isDebugEnabled as cv, isEmpty as cw, isPathEditPart as cx, isResizeHandle as cy, isRotateHandle as cz, type ActionsRegistry as d, openPointerSession as d0, overlaysOf as d1, overriddenBindings as d2, pickMenu as d3, pointerGestureId as d4, readActionSettings as d5, reportRouteConflicts as d6, resolveBindingOverrides as d7, resolveDeviceProfile as d8, resolveMenu as d9, resolveParams as da, resolveSchemaMenu as db, roleReader as dc, routesForSpec as dd, ruleCanHoldIn as de, rulesExclusive as df, scopeBindings as dg, scratchKey as dh, setScratch as di, startCarry as dj, taggedActionItems as dk, targetConsultsAffordance as dl, toolIdsOf as dm, toolSet as dn, toolSetHas as dp, tuneAction as dq, validateActionDefaultBinding as dr, validateActionId as ds, withoutTools as dt, 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 };