@weasel-js/routing 1.10.1 → 1.11.1

package/dist/{index-DkOqUxow.d.ts → index-Cb7ehEks.d.ts}

@@ -1,10 +1,14 @@
-import { PoseLinear, View } from '@weasel-js/geom';
+import { ModifierKey, ClaimableGesture, GestureSpec, InputEvent, TargetSpec, IngestItem, BodyTarget, KeyHeldSpec, TargetPredicate, KeySpec, 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 { CapabilityTag, ActiveMode, ModeRegistry } from '@weasel-js/modes';
+import * as _weasel_js_icons from '@weasel-js/icons';
+import { IconRef } from '@weasel-js/icons';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { Emitter } from '@weasel-js/registry';
-import { ClaimableGesture, GestureSpec, IngestItem, InputEvent, TargetSpec, KeyHeldSpec, TargetPredicate, KeySpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
-import { CapabilityTag, ActiveMode, ModeRegistry } from '@weasel-js/modes';
-import { CursorSpec } from '@weasel-js/cursor';
+import { Emitter, QueryMatch } from '@weasel-js/registry';
 import '@weasel-js/select';
 
 /**
@@ -22,20 +26,9 @@ type NodeId = string & {
     readonly __brand: 'NodeId';
 };
 
-/**
- * Axis-aligned rectangle in world space. The optional `rotation` (radians,
- * around the AABB center) and `transform` (inside it, about the same center)
- * let chrome carry the frame a box is drawn in without a parallel type;
- * `poseFrameOf` composes the two.
- */
-interface Bounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation?: number;
-    transform?: PoseLinear;
-}
+/** Axis-aligned rectangle in world space, with the frame it is drawn in;
+ *  geom's `FramedBox`. */
+type Bounds = FramedBox;
 /** The selection as routing reads and writes it. */
 interface SelectionApi {
     /** Current selection. Re-renders trigger when this reference changes. */
@@ -176,126 +169,815 @@ type ResizeAnchor = {
     y: 'min' | 'max' | 'free';
 };
 
+/** The chrome an in-flight gesture paints beside the scene. */
+
 /**
- * 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.
+ * 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.
  */
-
-/** 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>;
-}
-
-/** 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;
-}
+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 & {});
 /**
- * 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.
+ * 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.
  */
-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;
+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[];
+
 /**
- * Like `useActiveToolContext`, but returns `null` when no
- * `<ActiveToolContextProvider>` is in scope instead of throwing.
+ * 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.
  */
-declare function useOptionalActiveToolContext(): ActiveToolContextValue | null;
+
+/** 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;
+
 /**
- * Mounts an `<ActiveToolContextProvider>` only when no parent provider is in
- * scope; otherwise renders children unwrapped.
+ * 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).
  */
-declare function ActiveToolContextProviderIfRoot({ children, }: {
-    children: ReactNode;
-}): react.JSX.Element;
 
+/** A 2D point in either world or screen coordinates; geom's `Point`. */
+type Point2 = Point;
 /**
- * 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.
+ * Which UI affordance was hit at pointerdown. Populated by the dispatcher when
+ * the `affordanceAt` thunk is provided to `useGestureDispatcher`.
  *
- * Adding a new field is additive: existing rules don't change, new
- * selector atoms can read it.
+ * `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 RuleCtx {
-    readonly focused: boolean;
-    readonly selection: readonly NodeId[];
-    readonly multiActive: boolean;
-    readonly modifiers: ModifierState;
-    readonly action: {
-        readonly kind: string | null;
-        readonly id: string | null;
+interface AffordanceHit {
+    /** Discriminator string, e.g. `'handle:bottom-right'`. */
+    kind: string;
+    /** Id of whatever produced this hit — a kit affordance's `id`, or the
+     *  registered layer's id. */
+    owner?: string;
+    /** `'exclusive'` means no binding may act on this point unless its target
+     *  consults the affordance. `'shared'` (the default) competes on scope and
+     *  specificity as bindings always have. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+    /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
+    fixedPoint?: {
+        x: number;
+        y: number;
     };
-    readonly hover: NodeId | null;
+    /** Which nodes this affordance belongs to. */
+    targetIds?: string[];
+    /** Set only when `kind` matches `'handle:*'`: which corner or edge stays
+     *  fixed during a resize; `'free'` on the axis an edge handle leaves alone. */
+    anchor?: ResizeAnchor;
+    /** Cursor to show while the pointer hovers this affordance (no gesture in
+     *  flight). Unset falls through to action-cursor prediction, then to the
+     *  active tool's cursor. */
+    cursor?: CursorSpec;
     /**
-     * How far the viewport is zoomed in, as one number — `1` at native scale.
+     * Free-form payload from whatever produced the hit, carried through to the
+     * matching action untouched. Kit affordances leave it unset; it exists for
+     * a registered layer's own chrome, where the hit-test already resolved
+     * *which* of its pieces was hit.
+     */
+    payload?: unknown;
+}
+/**
+ * One accumulated point on a drag trail: world-space position plus whatever
+ * stylus state the originating `PointerEvent` carried.
+ *
+ * The stylus fields are absent for mouse/touch on browsers that don't report
+ * them, and for synthetic events.
+ */
+interface DragSample extends Point2 {
+    /** 0..1. Mouse/touch report 0.5 while a button is held, per the spec. */
+    pressure?: number;
+    /** Degrees, ±90. Zero for mouse/touch. */
+    tiltX?: number;
+    /** Degrees, ±90. Zero for mouse/touch. */
+    tiltY?: number;
+}
+/** Per-invocation runtime context the dispatcher hands to an Invoker.
+ *  Gesture-kind-specific fields (`drag`, `wheel`, `multiTouch`, `key`) are
+ *  populated only for matching gesture kinds. */
+interface InvocationCtx {
+    world: Point2;
+    /**
+     * The pointer in client/screen pixels, for an action that has to place DOM
+     * at the pointer. Absent on every invocation whose event carries no client
+     * coordinates — a keystroke, a UI-driven trigger, a synthetic probe — so
+     * read it with a fallback rather than assuming a point.
+     *
+     * A view-mutating drag wants `drag.screenDelta`, not the difference of two
+     * of these: world deltas are self-referential mid-pan, and so is any delta
+     * taken across a view change.
+     */
+    screen?: Point2;
+    modifiers: ModifierState;
+    deps: ActionDeps;
+    drag?: {
+        start: Point2;
+        current: Point2;
+        delta: Point2;
+        /**
+         * Drag delta in client/screen coordinates (CSS pixels from the drag
+         * origin). Use this — never `delta` — for any action whose effect
+         * mutates the viewport itself (pan, view-zoom), because world-space
+         * deltas become self-referential as the view shifts mid-drag.
+         *
+         * Absent when the underlying pointer events carried no
+         * `clientX`/`clientY`.
+         */
+        screenDelta?: Point2;
+        affordance?: AffordanceHit;
+        /**
+         * Full pointermove history for the current drag, in world space, with
+         * per-sample stylus state when the browser reported it.
+         * Available only during `onMove` and `onEnd` calls (not on `start`).
+         *
+         * During `onMove` this is the dispatcher's live accumulator, and it grows
+         * under you — read it, don't retain it. On `onEnd` it is a snapshot, so
+         * that is where an action that keeps the trail should take it.
+         */
+        points?: DragSample[];
+    };
+    wheel?: {
+        deltaX: number;
+        deltaY: number;
+        deltaZ: number;
+    };
+    /** One `pinch` sample: `scale` is a multiplier since the previous sample,
+     *  `rotation` degrees since it. See `PinchEvent`. */
+    pinch?: {
+        scale: number;
+        rotation: number;
+    };
+    multiTouch?: {
+        /** Canvas-local CSS pixels — see `MultiTouchEvent.centroid`. Neither
+         *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
+         *  it through `clientToWorld` removes the canvas origin twice. */
+        centroid: Point2;
+        /** Distance between the two primary pointers, in CSS pixels. */
+        spread: number;
+        /** Degrees the line between the two primary pointers has turned since
+         *  the gesture began, clockwise positive. It keeps counting past a half
+         *  turn. Zero where the events carry no `MultiTouchEvent.angle`. */
+        rotation: number;
+        /**
+         * Pinch-zoom geometry, populated while a multitouch handle is in flight.
+         * `startSpread` is the spread at the moment the gesture began.
+         */
+        pinch?: {
+            startSpread: number;
+            currentSpread: number;
+            /** Canvas-local, same as the enclosing `centroid`. */
+            centroid: Point2;
+        };
+    };
+    key?: {
+        key: string;
+        repeat: boolean;
+    };
+    /** What a carry over the surface brings: its payload, as `startCarry` was
+     *  handed it. Present for every event of a `carry` binding's gesture. */
+    carry?: {
+        type: string;
+        value: unknown;
+    };
+    /**
+     * The view the input landed in, as the surface's view resolver assigned it:
+     * a view id, or `null` for the surface's own camera. Absent where no
+     * surface routed the input — a UI-driven trigger, a bare dispatcher.
+     */
+    viewId?: string | null;
+    /**
+     * Per-invocation parameters. Populated by `ActionsRegistry.begin()` for
+     * UI-driven ongoing actions (color picker, opacity slider). The gesture
+     * dispatcher does not populate this field; gesture-driven actions receive
+     * params via `BindingOpts.params` on `start` (the `opts` arg).
+     */
+    params?: Record<string, unknown>;
+    /**
+     * Which of the action's `modifierRoles` are held for this event, by role
+     * id. The dispatcher fills it on every event of a gesture whose action
+     * declares roles; absent otherwise. Read it through `roleReader`, which
+     * falls back to the roles' default keys where it is absent.
+     */
+    roles?: Readonly<Record<string, boolean>>;
+}
+/** Per-invocation options the dispatcher reads from a `GestureBinding`'s
+ *  `opts` field and passes to `OngoingInvoker.start`. */
+interface BindingOpts {
+    /** 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. */
+    behaviors?: unknown[];
+    /** Per-binding action parameters, which an immediate invoker reads via the
+     *  second arg to `run`.
+     *
+     *  May also be a thunk evaluated each time the value is needed, so a tool
+     *  can close over refs that mutate during a gesture (e.g. polygon `sides`
+     *  adjusted mid-drag via ArrowUp). An ongoing invoker that wants the latest
+     *  values at commit re-calls it inside `onEnd` via
+     *  `resolveParams(opts?.params)`. */
+    params?: Record<string, unknown> | (() => Record<string, unknown>);
+    /**
+     * The views this binding is live in, by id, where `null` is the surface's
+     * own camera. Omitted means every view.
+     *
+     * A binding that names the view an input landed in outranks every binding
+     * that does not, whatever their scope tiers: naming a view is the most
+     * specific thing a binding can say about where it applies. Without that, a
+     * drag bound inside a minimap view loses to the active tool's marquee.
+     */
+    views?: readonly (string | null)[];
+    /**
+     * Says this binding is declared ahead of another on the same input on
+     * purpose: its action declines through `enabled()` when the input is not its
+     * to take, and the next binding fires. The dispatcher does that for any
+     * 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.
+     */
+    roles?: RoleRebinds;
+}
+/** Resolve `BindingOpts.params` to a concrete record (calling the thunk if
+ *  needed). Returns `undefined` for absent params. */
+declare function resolveParams(params: BindingOpts['params']): Record<string, unknown> | undefined;
+/** The deps an action receives, composed per call from what it `requires`.
+ *  Each name resolves to its {@link DepSchema} entry, and is absent when no
+ *  source registered it; a name nothing has declared passes through as
+ *  `unknown`. */
+interface ActionDeps extends Partial<DepSchema> {
+    [k: string]: unknown;
+}
+
+/** Handle returned from an `OngoingInvoker.start`. The dispatcher pumps
+ *  `onMove` on subsequent input events of the same gesture and calls
+ *  `onEnd` exactly once (with `'commit'` on natural completion or `'cancel'`
+ *  on pointercancel / blur / escape). */
+interface OngoingHandle {
+    /**
+     * Optional logical action kind — a stable, human-readable tag the
+     * dispatcher exposes via `getActiveAction()`, e.g. `'marquee'`, `'move'`,
+     * `'resize'`, `'pan'`.
+     *
+     * When omitted, `getActiveAction().kind` reports `null` even though a
+     * handle is in flight.
+     */
+    kind?: string;
+    /**
+     * The cursor this gesture shows now, read after every move. Wins over the
+     * action's `activeCursor`, for a cursor that follows the gesture — the
+     * rotate glyph turning about its pivot. `undefined` defers to the action.
+     */
+    cursor?(): CursorSpec | undefined;
+    onMove?(ctx: InvocationCtx): void;
+    onEnd?(ctx: InvocationCtx, reason: 'commit' | 'cancel'): void;
+    /**
+     * Optional preview surface: the in-flight state the canvas's preview-ghost
+     * layer renders on top of the committed scene during the gesture.
+     *
+     * `previewIds()` enumerates the displaced node ids; `previewPose(id)`
+     * returns the interim pose for one of them (shape opaque — the canvas
+     * casts to its `TPose` parameter). `previewIds` returning `null`, or
+     * omitted, means "no preview this gesture". An id with no `previewPose`
+     * is shown at its effective pose: an action that publishes its poses to
+     * the scene's pose overrides, as move, resize and rotate do, leaves
+     * `previewPose` out rather than answering the same pose twice.
+     */
+    previewIds?(): Iterable<string> | null;
+    previewPose?(id: string): unknown | null;
+    /**
+     * Subset of `previewIds()` the ghost layer paints at full opacity. The
+     * ghost alpha says "this is in flight under the pointer"; a node the
+     * gesture merely displaces — a layout sibling reflowing into its
+     * destination slot — is not, and reads better settled. Honored at
+     * subtree-root granularity.
+     */
+    previewOpaqueIds?(): Iterable<string> | null;
+    /**
+     * When `false`, the preview-ghost layer paints the ghost AND the source
+     * node stays visible at its committed pose, as a clone wants. Defaults to
+     * `true`: the ghost replaces the source during the gesture.
+     */
+    previewHidesSource?: boolean;
+    /**
+     * Optional per-id preview *data*, for a gesture that mutates `node.data`
+     * (e.g. anchor-edit on nodes that store the polygon on `data.path`) rather
+     * than, or in addition to, the pose. Falls back to the committed
+     * `node.data` when null/absent.
+     */
+    previewData?(id: string): unknown | null;
+    /**
+     * Optional chrome surface: a non-ghost visual (marquee rectangle, lasso
+     * polyline) painted while the gesture is in flight — one, or a list for a
+     * gesture showing several runs at once. Returning `null`, or omitting the
+     * method, means "no overlay this gesture". Read it through
+     * {@link overlaysOf}, which answers a list either way.
+     */
+    overlay?(): OngoingOverlay | readonly OngoingOverlay[] | null;
+    /**
+     * A wheel turned while this gesture is in flight — scrubbing a value the
+     * drag is using, say. Return `true` to claim the wheel, so no wheel binding
+     * (the viewport's zoom or pan) sees it; anything else lets it through.
+     * Omit it and the wheel goes to the bindings as usual.
+     */
+    onWheel?(ctx: InvocationCtx): boolean | void;
+}
+/** Fire-once invocation. Runs to completion synchronously (or fires off an
+ *  async side-effect; the registry doesn't wait). */
+interface ImmediateInvoker {
+    timing: 'immediate';
+    /** `params` carries the matched binding's opts.params. Invoked from the
+     *  command palette, or anywhere else with no per-binding context, `params`
+     *  is undefined; descriptors should default to a sensible variant. */
+    run(deps: ActionDeps, params?: Record<string, unknown>): void;
+}
+/** Phase-machine invocation. `start` opens the phase and returns the handle
+ *  the dispatcher pumps. */
+interface OngoingInvoker {
+    timing: 'ongoing';
+    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle;
+}
+/** Pluggable invocation strategy for an Action. */
+type Invoker = ImmediateInvoker | OngoingInvoker;
+
+/**
+ * GestureBinding — connects a GestureSpec to an Action id (with per-binding
+ * options). Tools own arrays of these on their `bindings` field; ambient
+ * gesture-bindings are registered globally.
+ */
+
+/** An interaction: a gesture spec composed with the id of the action it
+ *  invokes. Tools declare arrays of these; the dispatcher matches an incoming
+ *  input event against them and runs the winner's action. */
+interface GestureBinding {
+    spec: GestureSpec;
+    actionId: string;
+    opts?: BindingOpts;
+}
+/**
+ * A single entry in `Action.defaultBinding[]`. Either a bare `GestureSpec`
+ * (no per-binding opts) or an object form that pairs a spec with
+ * `BindingOpts` for parametric actions (e.g. `{ params: { axis: 'x' } }`).
+ * Use the object form when two bindings for the same action differ only in
+ * a runtime parameter — the dispatcher extracts `opts.params` and passes
+ * them to `ImmediateInvoker.run` as its second argument.
+ */
+type BoundGesture = GestureSpec | {
+    spec: GestureSpec;
+    opts: BindingOpts;
+};
+/**
+ * The whole of an action `actionBindings` reads. Routing needs this much and
+ * none of `Action`'s palette fields, so it is the narrowest type the
+ * dispatcher's binding walk can be written against.
+ */
+interface BindingSource {
+    id: string;
+    /** The gesture-spec form of the binding, read by the gesture dispatcher.
+     *  May be a single `GestureSpec`, a bare `GestureSpec[]` (any-of semantics),
+     *  or a `BoundGesture[]` where each entry is either a bare `GestureSpec` or
+     *  `{ spec, opts }` — use the object form for parametric actions where two
+     *  bindings for the same action differ only by `opts.params` (e.g. `flip`
+     *  with `axis: 'x'` vs `'y'`). The dispatcher extracts `opts.params` and
+     *  passes them to `ImmediateInvoker.run` as its second argument. */
+    defaultBinding?: GestureSpec | BoundGesture[];
+}
+/**
+ * Flatten an action's `defaultBinding` into `GestureBinding`s. A bare
+ * `GestureSpec` has `kind` at top level; the object form has `spec`.
+ */
+declare function actionBindings(action: BindingSource): GestureBinding[];
+
+/**
+ * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
+ * the actions-layer binding-scope / matchBest logic on top.
+ */
+
+/** Where a binding came from, which is also its priority: a held hotkey beats
+ *  the active tool, which beats bindings that are always in scope. */
+type BindingScope = 'ambient' | 'active' | 'hotkey';
+/** A binding paired with where it came from, ready to be matched against an
+ *  event. */
+interface ScopedBinding {
+    binding: GestureBinding;
+    scope: BindingScope;
+    /** Id of the tool or contribution that declared this binding —
+     *  `'&'`-channel phase atoms resolve to it. `null` for a registered
+     *  action's own binding. */
+    ownerId: string | null;
+}
+/** The binding that won a match. */
+interface MatchResult {
+    binding: GestureBinding;
+    scope: BindingScope;
+    /** Id of the entry that declared the binding — propagated from
+     *  `ScopedBinding` so the dispatcher can record it as the handle owner. */
+    ownerId: string | null;
+}
+/**
+ * True when a spec's target actually consults the affordance hit rather than
+ * only the body classification. `kindOf` predicates are handed the hit;
+ * `affordance:<k>` matches on its `kind`. The body-class strings (`'empty'`,
+ * `'selected-body'`, `'unselected-body'`) and the `kind:` forms resolve from
+ * `bodyTarget` / `bodyKind` and never see it.
+ *
+ * A predicate declares which it is with `readsAffordance`; one that declares
+ * nothing, which only untyped code can write, counts as not reading the hit.
+ */
+declare function targetConsultsAffordance(specTarget: TargetSpec | undefined): boolean;
+/** The first of {@link matchSorted}'s matches, or null when nothing matches. */
+declare function matchBest(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>): MatchResult | null;
+/**
+ * Find every binding that matches the event, sorted by precedence
+ * (best → worst). Ordering rules:
+ *
+ *   - Scopes by priority: hotkey > active > ambient.
+ *   - Within a scope, more-specific bindings beat less-specific (see
+ *     `specificity()`).
+ *   - Among same-specificity bindings, first-declared wins.
+ */
+declare function matchSorted(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, warn?: (message: string) => void): MatchResult[];
+/** {@link matchSorted}, plus what an exclusive claim on the event barred. */
+interface MatchOutcome {
+    matches: MatchResult[];
+    /** Bindings whose spec matched the event but which the claim barred, in
+     *  the same order `matches` uses. Filled only when `collectBarred` is set. */
+    barred: MatchResult[];
+    /** Owner of the exclusive claim, when one applied. */
+    claimOwner?: string;
+}
+/**
+ * {@link matchSorted} that can also report the bindings an exclusive claim
+ * kept out. Collecting them costs a spec match per barred binding, so it is
+ * opt-in — the dispatcher asks only when it is recording.
+ */
+declare function matchSortedWithBarred(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, opts?: {
+    collectBarred?: boolean;
+    warn?: (message: string) => void;
+}): MatchOutcome;
+
+/**
+ * How one input was resolved: every binding that matched it, what each filter
+ * dropped, the order the rest were ranked in and why, and what the walk down
+ * that order did. The dispatcher fills one per input in dev builds, and
+ * `Dispatcher.explain` fills one on request without invoking anything.
+ *
+ * Plain data — no functions, no live objects — so it can be kept in a trace
+ * buffer, serialized, or built by hand as a fixture.
+ */
+interface DispatchRecord {
+    kind: 'dispatch';
+    ts: number;
+    input: DispatchRecordInput;
+    /** Every binding whose spec matched the input, in matcher order, including
+     *  those a filter then dropped. */
+    matched: readonly RecordCandidate[];
+    dropped: readonly DroppedCandidate[];
+    /** The candidates that survived both filters, best first. */
+    ranked: readonly RankedCandidate[];
+    /** True when nothing was invoked: the record answers "what would happen". */
+    predicted: boolean;
+    /** Action id of the candidate that fired (or would), else `null`. */
+    fired: string | null;
+    outcome: 'handled' | 'unhandled';
+}
+/** The input a {@link DispatchRecord} describes, reduced to plain data. */
+interface DispatchRecordInput {
+    /** `InputEvent.kind`: `'key'`, `'pointerdown'`, `'wheel'`, … */
+    eventKind: string;
+    /** For `key` / `key-held` events, the key id (`'Escape'`, `' '`, `'a'`). */
+    key?: string;
+    modifiers: {
+        alt: boolean;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+    };
+    /** The view the input was routed to; `null` for the surface's own camera. */
+    viewId: string | null;
+    /** World point, for events that carry one. */
+    world?: {
+        x: number;
+        y: number;
+    };
+    /** Active mode id, when the host supplies a rule context. */
+    mode?: string;
+}
+/** One matched binding. */
+interface RecordCandidate {
+    actionId: string;
+    /** The binding's spec in route grammar — one per arg alternative. */
+    routes: readonly string[];
+    scope: BindingScope;
+    /** The tool or contribution that declared the binding; `null` for an action's own binding. */
+    ownerId: string | null;
+    /** Whether the binding's `views` names the routed view. */
+    namesView: boolean;
+    /** `specificity(spec)`: target, modifiers, phase, exact. */
+    specificity: readonly [number, number, number, number];
+    /** The action's `eligible` rule as text, when it declares one. */
+    eligible?: string;
+}
+/** A matched candidate a filter removed before ranking, and which filter. */
+type DroppedCandidate = 
+/** An exclusive claim on the input barred bindings that do not read the
+ *  claim's affordance. */
+{
+    candidate: RecordCandidate;
+    filter: 'claim';
+    owner?: string;
+}
+/** The action's `eligible` rule does not hold. */
+ | {
+    candidate: RecordCandidate;
+    filter: 'ineligible';
+    rule: string;
+};
+/** One field of the `specificity` tuple, in the order it is compared. */
+type SpecificityPart = 'target' | 'mods' | 'phase' | 'exact';
+/** The ranking step that put a candidate below the one before it. */
+type PlacedBy = {
+    step: 'first';
+}
+/** The one above names the routed view; this one does not. */
+ | {
+    step: 'view';
+}
+/** The one above sits in a higher scope tier. */
+ | {
+    step: 'tier';
+}
+/** Same tier; the one above is more specific in `part`. */
+ | {
+    step: 'specificity';
+    part: SpecificityPart;
+}
+/** Tied; the one above is gated by an `eligible` rule that holds. */
+ | {
+    step: 'context';
+}
+/** Tied on everything; registration order. */
+ | {
+    step: 'order';
+};
+/** What the walk did with one ranked candidate. */
+type WalkStep = {
+    kind: 'fired';
+}
+/** Predicted records only: this candidate would fire. Nothing was started,
+ *  so an ongoing action here may still bail at `start()` for real. */
+ | {
+    kind: 'would-fire';
+}
+/** `enabled()` returned this reason. */
+ | {
+    kind: 'declined';
+    reason: string;
+}
+/** An ongoing action's `start()` returned an empty handle. */
+ | {
+    kind: 'empty-handle';
+}
+/** An ongoing action bound to a press-time `pointerDown` spec; refused. */
+ | {
+    kind: 'misbound';
+}
+/** Its action was already tried higher up; each runs at most once. */
+ | {
+    kind: 'duplicate';
+} | {
+    kind: 'no-such-action';
+}
+/** Below the winner; never asked. */
+ | {
+    kind: 'not-asked';
+}
+/** Below the winner, asked anyway (`evaluateShadowed`), and it passed. */
+ | {
+    kind: 'outranked';
+};
+/** A candidate that survived the filters: why it sits where it does, and
+ *  what the walk did with it. */
+interface RankedCandidate {
+    candidate: RecordCandidate;
+    placedBy: PlacedBy;
+    walk: WalkStep;
+}
+
+/** One entry per "mode change" — a kit state transition that isn't a
+ *  dispatched input event but explains why an input was (or wasn't) handled
+ *  later. Pushed via {@link DispatchTrace.recordModeSwitch}. */
+interface ModeSwitchLogEntry {
+    kind: 'mode';
+    ts: number;
+    /** Logical mode name, e.g. `'editAnchors.editingId'`. */
+    mode: string;
+    from: string | null;
+    to: string | null;
+    /** Optional free-form context — `'enterPathEdit'`, `'exitPathEdit'`,
+     *  `'selection-dropped target'`, etc. */
+    detail?: string;
+}
+/** A trace entry: one {@link DispatchRecord} per resolved input, or a mode switch. */
+type TraceLogEntry = DispatchRecord | ModeSwitchLogEntry;
+/** A rolling buffer that records in a dev build, and in any build while something watches it. */
+interface TraceRing<T> {
+    /** Whether a push now keeps its entry. A caller building an entry checks first. */
+    recording(): boolean;
+    push(entry: T): void;
+    /** The entries pushed after `cursor`, oldest first, and the cursor to pass
+     *  next time. Start from 0. Entries the buffer has dropped are skipped. */
+    since(cursor: number): {
+        entries: T[];
+        cursor: number;
+    };
+    /** Turn recording on until the returned release is called. */
+    watch(): () => void;
+    /** Hear each kept push. Returns the unsubscribe. */
+    subscribe(listener: () => void): () => void;
+}
+/** A {@link TraceRing} keeping the last `limit` entries. `dev` defaults to the build's. */
+declare function createTraceRing<T>(limit?: number, dev?: boolean): TraceRing<T>;
+/** One canvas's dispatch trace. `useGestureDispatcher` makes one, puts it on
+ *  every `DispatcherContext` it builds, and publishes it as the `dispatchTrace` dep. */
+interface DispatchTrace extends TraceRing<TraceLogEntry> {
+    recordModeSwitch(mode: string, from: string | null, to: string | null, detail?: string): void;
+    /** Offer the record for what a press at the pointer would do, built only
+     *  when {@link DispatchTrace.live} reads it. `null` withdraws it. */
+    setLive(explain: (() => DispatchRecord) | null): void;
+    live(): DispatchRecord | null;
+}
+/** A {@link DispatchTrace} keeping the last `limit` entries. `dev` defaults to the build's. */
+declare function createDispatchTrace(limit?: number, dev?: boolean): DispatchTrace;
+
+/**
+ * Live state read by rule evaluation. Built once per frame on the consuming
+ * surface — chrome-caps, the affordance pipeline, the dispatcher's
+ * eligibility filter — and discarded.
+ *
+ * Adding a new field is additive: existing rules don't change, new
+ * selector atoms can read it.
+ */
+interface RuleCtx {
+    readonly focused: boolean;
+    readonly selection: readonly NodeId[];
+    readonly multiActive: boolean;
+    readonly modifiers: ModifierState;
+    readonly action: {
+        readonly kind: string | null;
+        readonly id: string | null;
+    };
+    readonly hover: NodeId | null;
+    /**
+     * How far the viewport is zoomed in, as one number — `1` at native scale.
      *
      * A scalar rather than the `View` this used to carry, because `zoomAtLeast`
      * is the only selector that ever read one and a number is all it needs. A
@@ -354,612 +1036,219 @@ interface BuildRuleCtxArgs {
     zoom?: number;
     mode: string;
     allowedCapabilities: ReadonlySet<CapabilityTag>;
-    /** Optional — omitted means "resizable" (handles show). See {@link RuleCtx}. */
-    selectionResizable?: boolean;
-    /** Optional — omitted means "no path is being anchor-edited". */
-    editingAnchors?: boolean;
-    /** Optional — omitted means {@link DEFAULT_DEVICE_PROFILE}. */
-    device?: DeviceProfile;
-}
-/**
- * Capability set to assume when no mode registry is wired.
- *
- * "No modes configured" means *everything the default mode permits*, not
- * *nothing permitted*. The empty set is the wrong default: it makes every
- * `capability:` rule evaluate false, so a kit default written the
- * recommended way (capability rules outlive new modes; mode rules have to
- * be edited) would silently hide its chrome for every consumer that hasn't
- * opted into modality. `NORMAL.allows` plus the implicit tags is what a
- * mode-less canvas actually behaves like.
- */
-declare const DEFAULT_ALLOWED_CAPABILITIES: ReadonlySet<CapabilityTag>;
-/** Gather the current canvas and mode state into the context that action
- *  eligibility and chrome-visibility rules are evaluated against. */
-declare function buildRuleCtx(args: BuildRuleCtxArgs): RuleCtx;
-
-/**
- * A selector is a conjunction of key/value tests. Multiple keys at the same
- * level AND together. Each key maps to a selector primitive in the evaluator.
- */
-interface Selector {
-    selection?: {
-        is?: number;
-        atLeast?: number;
-        empty?: boolean;
-    };
-    mode?: string | {
-        not: string;
-    } | {
-        in: readonly string[];
-    };
-    capability?: CapabilityTag | readonly CapabilityTag[] | {
-        in: readonly CapabilityTag[];
-    } | {
-        not: CapabilityTag;
-    };
-    gesturing?: boolean;
-    actionIs?: string;
-    modifierHeld?: keyof ModifierState;
-    focused?: boolean;
-    hovering?: boolean;
-    hoveringSelected?: boolean;
-    zoomAtLeast?: number;
-    /** Matches `ctx.editingAnchors` — true while a path is in anchor-edit
-     *  mode. Absent flag is treated as `false`. */
-    editingAnchors?: boolean;
-    /** Matches `ctx.selectionResizable`. Absent flag is treated as `true`
-     *  (resizable), so `{ resizable: true }` passes for legacy ctx builders
-     *  that don't compute it. */
-    resizable?: boolean;
-    /** Matches `ctx.device.coarsePointer` — the primary pointer is imprecise
-     *  (touch, most styluses). Absent device is treated as `false`. */
-    coarsePointer?: boolean;
-    /** Matches `ctx.device.canHover` — the primary pointer can hover. Absent
-     *  device is treated as `true`. */
-    canHover?: boolean;
-}
-/**
- * Composable visibility/eligibility rule. Trees of `all`/`any`/`not` nodes
- * over `Selector` leaves. `when` is the escape hatch — its closure is
- * opaque to introspection and should be avoided when a declarative form
- * exists. Empty `all` is true; empty `any` is false.
- */
-type Rule = Selector | {
-    all: readonly Rule[];
-} | {
-    any: readonly Rule[];
-} | {
-    not: Rule;
-} | {
-    when: (ctx: RuleCtx) => boolean;
-};
-/** Constant rules. Kept here so they have a single source. */
-declare const ALWAYS: Rule;
-/** A rule that never passes. `any` of nothing is false. */
-declare const NEVER: Rule;
-/**
- * Render a {@link Rule} as a short human-readable string, for inspectors and
- * diagnostics that need to say WHICH rule decided something.
- *
- * ```
- * { capability: 'edits-page' }               → capability:edits-page
- * { all: [{ mode: 'normal' }, { focused: true }] } → all(mode:normal, focused:true)
- * { not: { selection: { empty: true } } }    → not(selection:empty=true)
- * { when: function hasPath() { … } }         → when(hasPath)
- * ```
- *
- * Never throws and always terminates.
- */
-declare function describeRule(rule: Rule): string;
-/** Evaluate a rule against a context. Pure, and cheap enough to run per
- *  frame for every piece of chrome. */
-declare function evaluate(rule: Rule, ctx: RuleCtx): boolean;
-/**
- * Composable eligibility predicate with a fluent surface. `cond(ctx)`
- * evaluates its `Rule` tree, carried at `.rule`; the fluent methods return new
- * Conditions wrapping new trees.
- *
- * **Chain semantics: strict left-to-right, no precedence.** `a.and(b).or(c)` is
- * `(a && b) || c`; `a.or(b).and(c)` is `(a || b) && c`. For grouped
- * disjunction, name the subexpression or use the top-level `or(...)`.
- */
-interface Condition {
-    (ctx: RuleCtx): boolean;
-    readonly rule: Rule;
-    /** `this && other` */
-    and(other: Condition | Rule): Condition;
-    /** `this || other` */
-    or(other: Condition | Rule): Condition;
-    /** `this && !other` */
-    andNot(other: Condition | Rule): Condition;
-    /** `this || !other` */
-    orNot(other: Condition | Rule): Condition;
-}
-
-/**
- * Whether two rules can never hold at once — no `RuleCtx` passes both.
- *
- * Conservative: `true` is a proof, `false` means "may overlap". It reasons
- * about the selector values themselves (two different `mode`s, an empty
- * selection against a non-empty one, `focused: true` against `false`) and
- * through `all` / `any` / `not`; a `when` closure is opaque, so it overlaps
- * everything. The route-conflict check uses it to stay quiet about bindings
- * that share a tuple but are never eligible together.
- */
-declare function rulesExclusive(a: Rule, b: Rule): boolean;
-/**
- * Whether `rule` can hold while `mode` is active. Only its `mode` and
- * `capability` tests are settled by the mode; every other test could go either
- * way, so `false` is a proof and `true` means "may hold".
- */
-declare function ruleCanHoldIn(rule: Rule, mode: ActiveMode): boolean;
-
-/** The detected half of a profile — everything except the derived scale. */
-type DetectedDeviceFacts = Omit<DeviceProfile, 'targetScale'>;
-/**
- * Handle/hit multiplier applied on a coarse pointer.
- *
- * 8px handle → 14px; 24px rotation distance → 42px. Counting the
- * surrounding grab zone, that lands in the Apple HIG 44pt / Material 48dp
- * minimum-touch-target band. One constant so it is tunable in one place.
- */
-declare const COARSE_TARGET_SCALE = 1.75;
-/**
- * Fold consumer overrides over detected facts and derive `targetScale`.
- *
- * `targetScale` is re-derived AFTER the merge, so an override of
- * `coarsePointer` alone scales the chrome as expected. An explicit
- * `targetScale` override wins over the derivation.
- */
-declare function resolveDeviceProfile(detected: DetectedDeviceFacts, overrides?: Partial<DeviceProfile>): DeviceProfile;
-/**
- * Assumed when `matchMedia` is unavailable (SSR, jsdom) and used as the
- * absent-means value for `RuleCtx.device`.
- *
- * Derived from `resolveDeviceProfile` rather than hand-written, so it can
- * never drift from what the function would compute for the same facts. A
- * mouse-like device is the safe default: it is what the kit has always
- * assumed, so an absent profile changes nothing for existing consumers.
- */
-declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
-
-/**
- * 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. */
-interface Point2 {
-    x: number;
-    y: number;
+    /** 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;
 }
 /**
- * Which UI affordance was hit at pointerdown. Populated by the dispatcher when
- * the `affordanceAt` thunk is provided to `useGestureDispatcher`.
+ * Capability set to assume when no mode registry is wired.
  *
- * `kind` is a discriminator string:
- *   - `'handle:top-left'` / `'handle:top-right'` / `'handle:bottom-left'` /
- *     `'handle:bottom-right'` — corner resize handles.
- *   - `'rotate-handle'` — the rotation affordance.
- *   - `'anchor:N'` — a path anchor at index N.
+ * "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.
  */
-interface AffordanceHit {
-    /** Discriminator string, e.g. `'handle:bottom-right'`. */
-    kind: string;
-    /** Id of whatever produced this hit — a kit affordance's `id`, or the
-     *  registered layer's id. */
-    owner?: string;
-    /** `'exclusive'` means no binding may act on this point unless its target
-     *  consults the affordance. `'shared'` (the default) competes on scope and
-     *  specificity as bindings always have. */
-    strength?: 'exclusive' | 'shared';
-    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
-    claimedKinds?: readonly ClaimableGesture[];
-    /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
-    fixedPoint?: {
-        x: number;
-        y: number;
-    };
-    /** Which nodes this affordance belongs to. */
-    targetIds?: string[];
-    /** Set only when `kind` matches `'handle:*'`: which corner stays fixed
-     *  during a resize. */
-    anchor?: ResizeAnchor;
-    /** Cursor to show while the pointer hovers this affordance (no gesture in
-     *  flight). Unset falls through to action-cursor prediction, then to the
-     *  active tool's cursor. */
-    cursor?: CursorSpec;
-    /**
-     * Free-form payload from whatever produced the hit, carried through to the
-     * matching action untouched. Kit affordances leave it unset; it exists for
-     * a registered layer's own chrome, where the hit-test already resolved
-     * *which* of its pieces was hit.
-     */
-    payload?: unknown;
-}
+declare 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;
+
 /**
- * One accumulated point on a drag trail: world-space position plus whatever
- * stylus state the originating `PointerEvent` carried.
- *
- * The stylus fields are absent for mouse/touch on browsers that don't report
- * them, and for synthetic events.
+ * 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 DragSample extends Point2 {
-    /** 0..1. Mouse/touch report 0.5 while a button is held, per the spec. */
-    pressure?: number;
-    /** Degrees, ±90. Zero for mouse/touch. */
-    tiltX?: number;
-    /** Degrees, ±90. Zero for mouse/touch. */
-    tiltY?: number;
-}
-/** Per-invocation runtime context the dispatcher hands to an Invoker.
- *  Gesture-kind-specific fields (`drag`, `wheel`, `multiTouch`, `key`) are
- *  populated only for matching gesture kinds. */
-interface InvocationCtx {
-    world: Point2;
-    /**
-     * The pointer in client/screen pixels, for an action that has to place DOM
-     * at the pointer. Absent on every invocation whose event carries no client
-     * coordinates — a keystroke, a UI-driven trigger, a synthetic probe — so
-     * read it with a fallback rather than assuming a point.
-     *
-     * A view-mutating drag wants `drag.screenDelta`, not the difference of two
-     * of these: world deltas are self-referential mid-pan, and so is any delta
-     * taken across a view change.
-     */
-    screen?: Point2;
-    modifiers: ModifierState;
-    deps: ActionDeps;
-    drag?: {
-        start: Point2;
-        current: Point2;
-        delta: Point2;
-        /**
-         * Drag delta in client/screen coordinates (CSS pixels from the drag
-         * origin). Use this — never `delta` — for any action whose effect
-         * mutates the viewport itself (pan, view-zoom), because world-space
-         * deltas become self-referential as the view shifts mid-drag.
-         *
-         * Absent when the underlying pointer events carried no
-         * `clientX`/`clientY`.
-         */
-        screenDelta?: Point2;
-        affordance?: AffordanceHit;
-        /**
-         * Full pointermove history for the current drag, in world space, with
-         * per-sample stylus state when the browser reported it.
-         * Available only during `onMove` and `onEnd` calls (not on `start`).
-         *
-         * During `onMove` this is the dispatcher's live accumulator, and it grows
-         * under you — read it, don't retain it. On `onEnd` it is a snapshot, so
-         * that is where an action that keeps the trail should take it.
-         */
-        points?: DragSample[];
-    };
-    wheel?: {
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-    };
-    /** One `pinch` sample: `scale` is a multiplier since the previous sample,
-     *  `rotation` degrees since it. See `PinchEvent`. */
-    pinch?: {
-        scale: number;
-        rotation: number;
+interface Selector {
+    selection?: {
+        is?: number;
+        atLeast?: number;
+        empty?: boolean;
     };
-    multiTouch?: {
-        /** Canvas-local CSS pixels — see `MultiTouchEvent.centroid`. Neither
-         *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
-         *  it through `clientToWorld` removes the canvas origin twice. */
-        centroid: Point2;
-        /** Distance between the two primary pointers, in CSS pixels. */
-        spread: number;
-        /** Degrees the line between the two primary pointers has turned since
-         *  the gesture began, clockwise positive. It keeps counting past a half
-         *  turn. Zero where the events carry no `MultiTouchEvent.angle`. */
-        rotation: number;
-        /**
-         * Pinch-zoom geometry, populated while a multitouch handle is in flight.
-         * `startSpread` is the spread at the moment the gesture began.
-         */
-        pinch?: {
-            startSpread: number;
-            currentSpread: number;
-            /** Canvas-local, same as the enclosing `centroid`. */
-            centroid: Point2;
-        };
+    mode?: string | {
+        not: string;
+    } | {
+        in: readonly string[];
     };
-    key?: {
-        key: string;
-        repeat: boolean;
+    capability?: CapabilityTag | readonly CapabilityTag[] | {
+        in: readonly CapabilityTag[];
+    } | {
+        not: CapabilityTag;
     };
-    /**
-     * The view the input landed in, as the surface's view resolver assigned it:
-     * a view id, or `null` for the surface's own camera. Absent where no
-     * surface routed the input — a UI-driven trigger, a bare dispatcher.
-     */
-    viewId?: string | null;
-    /**
-     * Per-invocation parameters. Populated by `ActionsRegistry.begin()` for
-     * UI-driven ongoing actions (color picker, opacity slider). The gesture
-     * dispatcher does not populate this field; gesture-driven actions receive
-     * params via `BindingOpts.params` on `start` (the `opts` arg).
-     */
-    params?: Record<string, unknown>;
-}
-/** Per-invocation options the dispatcher reads from a `GestureBinding`'s
- *  `opts` field and passes to `OngoingInvoker.start`. */
-interface BindingOpts {
-    /** 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. */
-    behaviors?: unknown[];
-    /** Per-binding action parameters, which an immediate invoker reads via the
-     *  second arg to `run`.
-     *
-     *  May also be a thunk evaluated each time the value is needed, so a tool
-     *  can close over refs that mutate during a gesture (e.g. polygon `sides`
-     *  adjusted mid-drag via ArrowUp). An ongoing invoker that wants the latest
-     *  values at commit re-calls it inside `onEnd` via
-     *  `resolveParams(opts?.params)`. */
-    params?: Record<string, unknown> | (() => Record<string, unknown>);
-    /**
-     * The views this binding is live in, by id, where `null` is the surface's
-     * own camera. Omitted means every view.
-     *
-     * A binding that names the view an input landed in outranks every binding
-     * that does not, whatever their scope tiers: naming a view is the most
-     * specific thing a binding can say about where it applies. Without that, a
-     * drag bound inside a minimap view loses to the active tool's marquee.
-     */
-    views?: readonly (string | null)[];
-    /**
-     * Says this binding is declared ahead of another on the same input on
-     * purpose: its action declines through `enabled()` when the input is not its
-     * to take, and the next binding fires. The dispatcher does that for any
-     * binding; this tells the route-conflict check the order is the design.
-     */
-    yields?: boolean;
-}
-/** Resolve `BindingOpts.params` to a concrete record (calling the thunk if
- *  needed). Returns `undefined` for absent params. */
-declare function resolveParams(params: BindingOpts['params']): Record<string, unknown> | undefined;
-/** The deps an action receives, composed per call from what it `requires`.
- *  Each name resolves to its {@link DepSchema} entry, and is absent when no
- *  source registered it; a name nothing has declared passes through as
- *  `unknown`. */
-interface ActionDeps extends Partial<DepSchema> {
-    [k: string]: unknown;
+    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;
 }
 /**
- * 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.
+ * 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.
  *
- * 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.
+ * ```
+ * { 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.
  */
-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' | (string & {});
+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;
 /**
- * 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.
+ * 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.
  *
- * 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.
+ * **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(...)`.
  */
-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;
-} | {
-    /**
-     * 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])[];
-};
-/** Handle returned from an `OngoingInvoker.start`. The dispatcher pumps
- *  `onMove` on subsequent input events of the same gesture and calls
- *  `onEnd` exactly once (with `'commit'` on natural completion or `'cancel'`
- *  on pointercancel / blur / escape). */
-interface OngoingHandle {
-    /**
-     * Optional logical action kind — a stable, human-readable tag the
-     * dispatcher exposes via `getActiveAction()`, e.g. `'marquee'`, `'move'`,
-     * `'resize'`, `'pan'`.
-     *
-     * When omitted, `getActiveAction().kind` reports `null` even though a
-     * handle is in flight.
-     */
-    kind?: string;
-    /**
-     * The cursor this gesture shows now, read after every move. Wins over the
-     * action's `activeCursor`, for a cursor that follows the gesture — the
-     * rotate glyph turning about its pivot. `undefined` defers to the action.
-     */
-    cursor?(): CursorSpec | undefined;
-    onMove?(ctx: InvocationCtx): void;
-    onEnd?(ctx: InvocationCtx, reason: 'commit' | 'cancel'): void;
-    /**
-     * Optional preview surface: the in-flight state the canvas's preview-ghost
-     * layer renders on top of the committed scene during the gesture.
-     *
-     * `previewIds()` enumerates the displaced node ids; `previewPose(id)`
-     * returns the interim pose for one of them (shape opaque — the canvas
-     * casts to its `TPose` parameter). Returning `null`, or omitting the
-     * method, means "no preview this gesture".
-     */
-    previewIds?(): Iterable<string> | null;
-    previewPose?(id: string): unknown | null;
-    /**
-     * Subset of `previewIds()` the ghost layer paints at full opacity. The
-     * ghost alpha says "this is in flight under the pointer"; a node the
-     * gesture merely displaces — a layout sibling reflowing into its
-     * destination slot — is not, and reads better settled. Honored at
-     * subtree-root granularity.
-     */
-    previewOpaqueIds?(): Iterable<string> | null;
-    /**
-     * When `false`, the preview-ghost layer paints the ghost AND the source
-     * node stays visible at its committed pose, as a clone wants. Defaults to
-     * `true`: the ghost replaces the source during the gesture.
-     */
-    previewHidesSource?: boolean;
-    /**
-     * Optional per-id preview *data*, for a gesture that mutates `node.data`
-     * (e.g. anchor-edit on nodes that store the polygon on `data.path`) rather
-     * than, or in addition to, the pose. Falls back to the committed
-     * `node.data` when null/absent.
-     */
-    previewData?(id: string): unknown | null;
-    /**
-     * Optional chrome surface: a non-ghost visual (marquee rectangle, lasso
-     * polyline) painted while the gesture is in flight. Returning `null`, or
-     * omitting the method, means "no overlay this gesture".
-     */
-    overlay?(): OngoingOverlay | null;
-}
-/** Fire-once invocation. Runs to completion synchronously (or fires off an
- *  async side-effect; the registry doesn't wait). */
-interface ImmediateInvoker {
-    timing: 'immediate';
-    /** `params` carries the matched binding's opts.params. Invoked from the
-     *  command palette, or anywhere else with no per-binding context, `params`
-     *  is undefined; descriptors should default to a sensible variant. */
-    run(deps: ActionDeps, params?: Record<string, unknown>): void;
-}
-/** Phase-machine invocation. `start` opens the phase and returns the handle
- *  the dispatcher pumps. */
-interface OngoingInvoker {
-    timing: 'ongoing';
-    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle;
+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;
 }
-/** Pluggable invocation strategy for an Action. */
-type Invoker = ImmediateInvoker | OngoingInvoker;
 
 /**
- * GestureBinding — connects a GestureSpec to an Action id (with per-binding
- * options). Tools own arrays of these on their `bindings` field; ambient
- * gesture-bindings are registered globally.
+ * 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;
 
-/** An interaction: a gesture spec composed with the id of the action it
- *  invokes. Tools declare arrays of these; the dispatcher matches an incoming
- *  input event against them and runs the winner's action. */
-interface GestureBinding {
-    spec: GestureSpec;
-    actionId: string;
-    opts?: BindingOpts;
-}
+/** The detected half of a profile — everything except the derived scale. */
+type DetectedDeviceFacts = Omit<DeviceProfile, 'targetScale'>;
 /**
- * A single entry in `Action.defaultBinding[]`. Either a bare `GestureSpec`
- * (no per-binding opts) or an object form that pairs a spec with
- * `BindingOpts` for parametric actions (e.g. `{ params: { axis: 'x' } }`).
- * Use the object form when two bindings for the same action differ only in
- * a runtime parameter — the dispatcher extracts `opts.params` and passes
- * them to `ImmediateInvoker.run` as its second argument.
+ * 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.
  */
-type BoundGesture = GestureSpec | {
-    spec: GestureSpec;
-    opts: BindingOpts;
-};
+declare const COARSE_TARGET_SCALE = 1.75;
 /**
- * @experimental
- * The whole of an action `actionBindings` reads. Routing needs this much and
- * none of `Action`'s palette fields, so it is the narrowest type the
- * dispatcher's binding walk can be written against.
+ * 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.
  */
-interface BindingSource {
-    id: string;
-    /** The gesture-spec form of the binding, read by the gesture dispatcher.
-     *  May be a single `GestureSpec`, a bare `GestureSpec[]` (any-of semantics),
-     *  or a `BoundGesture[]` where each entry is either a bare `GestureSpec` or
-     *  `{ spec, opts }` — use the object form for parametric actions where two
-     *  bindings for the same action differ only by `opts.params` (e.g. `flip`
-     *  with `axis: 'x'` vs `'y'`). The dispatcher extracts `opts.params` and
-     *  passes them to `ImmediateInvoker.run` as its second argument. */
-    defaultBinding?: GestureSpec | BoundGesture[];
-}
+declare const DEFAULT_DEVICE_PROFILE: DeviceProfile;
+
 /**
- * @experimental
- * Flatten an action's `defaultBinding` into `GestureBinding`s. A bare
- * `GestureSpec` has `kind` at top level; the object form has `spec`.
+ * 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.
  */
-declare function actionBindings(action: BindingSource): GestureBinding[];
 
+/** 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[];
+}
+/**
+ * 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;
+    };
+}
 /**
- * @experimental
  * Closed enum of reasons an action might report itself as disabled. The
  * consumer (palette, menu, etc.) maps these symbolic values to display
  * strings via its own label map.
@@ -974,20 +1263,23 @@ declare const ActionDisabledReason: {
 /** Why an action is unavailable right now. */
 type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
 /**
- * @experimental
  * What a palette, menu or toolbar renders for an action. No part of this is
  * read during dispatch.
  */
 interface ActionPresentation {
     label: string;
-    /** Inline-SVG icon for palette / toolbar surfaces. May be a static
-     *  `ReactNode` or a function (rare; useful for state-aware icons like a
-     *  "lock" toggle). */
-    icon?: ReactNode | (() => ReactNode);
+    /** 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. */
@@ -998,9 +1290,13 @@ interface ActionPresentation {
      *  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;
 }
 /**
- * @experimental
  * One entry a parametric action contributes to a bar, menu or palette.
  */
 interface ActionVariant {
@@ -1008,13 +1304,14 @@ interface ActionVariant {
     key: string;
     label: string;
     /** Falls back to the action's own `icon`. */
-    icon?: ReactNode | (() => ReactNode);
+    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>>;
 }
 /**
- * @experimental
  * What routing consults: the bindings that reach the action, the deps its
  * invoker reads, the gates it passes, and the cursors it claims.
  */
@@ -1036,14 +1333,14 @@ interface ActionDispatch extends BindingSource {
      *  shortcuts and global held-key triggers. Default: ambient. */
     scope?: 'hotkey';
     /**
-     * @experimental
      * 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` does not ask,
-     * so the action's own `run` should still self-guard.
+     * 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
@@ -1058,23 +1355,23 @@ interface ActionDispatch extends BindingSource {
      * 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. Palettes and keystrokes
-     * pass no point; treat absent as "anywhere".
+     * 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.
+     * `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?: {
-        items: readonly IngestItem[];
-    }) => true | ActionDisabledReason;
+    }, carried?: Carried) => true | ActionDisabledReason;
     /**
-     * @experimental
      * 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
@@ -1084,6 +1381,15 @@ interface ActionDispatch extends BindingSource {
      * 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 =
@@ -1106,12 +1412,14 @@ interface ActionDispatch extends BindingSource {
      * resolved earlier in the pump via `AffordanceRegion.cursor` and never
      * reach this field.
      *
-     * Static value only. Prediction runs `enabled()` but cannot run the
-     * invoker, so an action that matches yet bails at `start()` (empty
-     * handle) may still show its cursor — keep `enabled` accurate for
-     * actions that declare one.
+     * 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;
+    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`
@@ -1124,15 +1432,22 @@ interface ActionDispatch extends BindingSource {
      * 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;
 }
 /**
- * @experimental
  * Single registered action.
  */
 interface Action extends ActionDispatch, ActionPresentation {
 }
 /**
- * @experimental
  * 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
@@ -1141,450 +1456,500 @@ interface Action extends ActionDispatch, ActionPresentation {
 interface ActionSource {
     list(): readonly Action[];
 }
+/** `action`'s hover cursor for an invocation given `params`: its `cursor`,
+ *  asked when it is a function. */
+declare function actionCursor(action: Pick<Action, 'cursor'> | undefined, params?: Record<string, unknown>): CursorSpec | undefined;
 
-/**
- * Tuning: what a host changes about an action it did not write — the params
- * every invocation starts from, and bindings added beside the action's own —
- * without restating the descriptor. `ActionsRegistry.tune` holds tunings and
- * applies them to whatever descriptor is live for the id.
- */
-
-/** An action's params, or a thunk read each time the action asks for them. */
-type ActionParams<P = Record<string, unknown>> = Partial<P> | (() => Partial<P>);
-/** A binding added for an action: a gesture alone, or a gesture with the
- *  options it passes — the {@link BoundGesture} shape, its params typed. */
-type TunedBinding<P = Record<string, unknown>> = GestureSpec | {
-    spec: GestureSpec;
-    opts: Omit<BindingOpts, 'params'> & {
-        params?: ActionParams<P>;
-    };
-};
-/** What a host changes about one action. */
-interface ActionTuning<P = Record<string, unknown>> {
-    /** Params every invocation starts from. What a binding or a `trigger` call
-     *  passes is laid over them, so these fill in what it leaves out. A thunk is
-     *  read on every call, and an ongoing action resolving its `opts.params`
-     *  mid-gesture sees the value as it is then. */
-    params?: ActionParams<P>;
-    /** Bindings added after the action's own `defaultBinding`. */
-    bindings?: readonly TunedBinding<P>[];
+/** 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;
 }
-/** `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;
-
-/**
- * @experimental
- * The entries an action contributes to a bar, menu or palette — one per
- * variant, or the action itself when it declares none.
- */
-
-/** @experimental 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?: ReactNode | (() => ReactNode);
-    /** What to pass to `trigger(action.id, params)`; absent for a plain action. */
-    params?: Readonly<Record<string, unknown>>;
+/** 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;
 }
-/** @experimental 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[];
 
-/**
- * @experimental
- * 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.
- */
+/** 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;
+}
+/**
+ * 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[];
 
-/**
- * @experimental
- * Result of evaluating an Action's `enabled` predicate.
- */
-interface ActionEnabledResult {
-    enabled: boolean;
-    reason?: ActionDisabledReason;
+/** 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';
+}
+/** 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';
+}
+/** 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;
 }
-/**
- * @experimental
- * 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): ActionEnabledResult;
-/**
- * @experimental
- * 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;
+/** 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;
 
 /**
- * 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.
+ * 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.
  */
 
-/** 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;
+/** What every node of one tree shares: a version and the listeners to it. */
+interface ScopeTree {
+    version: number;
+    readonly listeners: Emitter;
 }
-/** 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);
+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>;
 }
-/**
- * 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;
 
-/** 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;
-    /** Inline-SVG icon component output: a static `ReactNode`, or a function
-     *  returning one. */
-    icon?: react.ReactNode | (() => react.ReactNode);
-    /** 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.
+ * Mounts an `<ActiveToolContextProvider>` only when no parent provider is in
+ * scope; otherwise renders children unwrapped.
  */
-interface ContributionRouting {
-    id: string;
-    eligibility: Eligibility;
-    bindings?: GestureBinding[];
-    actions?: Action[];
-    /** 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;
-}
+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.
- */
-declare function targetConsultsAffordance(specTarget: TargetSpec | undefined): boolean;
-/** The first of {@link matchSorted}'s matches, or null when nothing matches. */
-declare function matchBest(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>): MatchResult | null;
-/**
- * Find every binding that matches the event, sorted by precedence
- * (best → worst). Ordering rules:
+ * - 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.
  *
- *   - Scopes by priority: hotkey > active > ambient.
- *   - Within a scope, more-specific bindings beat less-specific (see
- *     `specificity()`).
- *   - Among same-specificity bindings, first-declared wins.
- */
-declare function matchSorted(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, warn?: (message: string) => void): MatchResult[];
-/** {@link matchSorted}, plus what an exclusive claim on the event barred. */
-interface MatchOutcome {
-    matches: MatchResult[];
-    /** Bindings whose spec matched the event but which the claim barred, in
-     *  the same order `matches` uses. Filled only when `collectBarred` is set. */
-    barred: MatchResult[];
-    /** Owner of the exclusive claim, when one applied. */
-    claimOwner?: string;
-}
-/**
- * {@link matchSorted} that can also report the bindings an exclusive claim
- * kept out. Collecting them costs a spec match per barred binding, so it is
- * opt-in — the dispatcher asks only when it is recording.
+ * 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 matchSortedWithBarred(e: InputEvent, bindings: readonly ScopedBinding[], isMac: boolean, engagedChannels?: ReadonlySet<string>, opts?: {
-    collectBarred?: boolean;
-    warn?: (message: string) => void;
-}): MatchOutcome;
-
+declare function keySpecShortcut(spec: GestureSpec): ActionShortcut | undefined;
 /**
- * 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.
+ * 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.
  *
- * Plain data — no functions, no live objects — so it can be kept in a trace
- * buffer, serialized, or built by hand as a fixture.
+ * With `params` — an `ActionItem`'s — only the bindings that pass those same
+ * values count, so each variant of `flip` gets its own key.
  */
-interface DispatchRecord {
-    kind: 'dispatch';
-    ts: number;
-    input: DispatchRecordInput;
-    /** Every binding whose spec matched the input, in matcher order, including
-     *  those a filter then dropped. */
-    matched: readonly RecordCandidate[];
-    dropped: readonly DroppedCandidate[];
-    /** The candidates that survived both filters, best first. */
-    ranked: readonly RankedCandidate[];
-    /** True when nothing was invoked: the record answers "what would happen". */
-    predicted: boolean;
-    /** Action id of the candidate that fired (or would), else `null`. */
-    fired: string | null;
-    outcome: 'handled' | 'unhandled';
-}
-/** The input a {@link DispatchRecord} describes, reduced to plain data. */
-interface DispatchRecordInput {
-    /** `InputEvent.kind`: `'key'`, `'pointerdown'`, `'wheel'`, … */
-    eventKind: string;
-    /** For `key` / `key-held` events, the key id (`'Escape'`, `' '`, `'a'`). */
-    key?: string;
-    modifiers: {
-        alt: boolean;
-        ctrl: boolean;
-        meta: boolean;
-        shift: boolean;
-    };
-    /** The view the input was routed to; `null` for the surface's own camera. */
-    viewId: string | null;
-    /** World point, for events that carry one. */
-    world?: {
-        x: number;
-        y: number;
-    };
-    /** Active mode id, when the host supplies a rule context. */
-    mode?: string;
-}
-/** One matched binding. */
-interface RecordCandidate {
-    actionId: string;
-    /** The binding's spec in route grammar — one per arg alternative. */
-    routes: readonly string[];
-    scope: BindingScope;
-    /** The tool or contribution that declared the binding; `null` for an action's own binding. */
-    ownerId: string | null;
-    /** Whether the binding's `views` names the routed view. */
-    namesView: boolean;
-    /** `specificity(spec)`: target, modifiers, phase, exact. */
-    specificity: readonly [number, number, number, number];
-    /** The action's `eligible` rule as text, when it declares one. */
-    eligible?: string;
-}
-/** A matched candidate a filter removed before ranking, and which filter. */
-type DroppedCandidate = 
-/** An exclusive claim on the input barred bindings that do not read the
- *  claim's affordance. */
-{
-    candidate: RecordCandidate;
-    filter: 'claim';
-    owner?: string;
-}
-/** The action's `eligible` rule does not hold. */
- | {
-    candidate: RecordCandidate;
-    filter: 'ineligible';
-    rule: string;
-};
-/** One field of the `specificity` tuple, in the order it is compared. */
-type SpecificityPart = 'target' | 'mods' | 'phase' | 'exact';
-/** The ranking step that put a candidate below the one before it. */
-type PlacedBy = {
-    step: 'first';
-}
-/** The one above names the routed view; this one does not. */
- | {
-    step: 'view';
-}
-/** The one above sits in a higher scope tier. */
- | {
-    step: 'tier';
-}
-/** Same tier; the one above is more specific in `part`. */
- | {
-    step: 'specificity';
-    part: SpecificityPart;
-}
-/** Tied; the one above is gated by an `eligible` rule that holds. */
- | {
-    step: 'context';
-}
-/** Tied on everything; registration order. */
- | {
-    step: 'order';
-};
-/** What the walk did with one ranked candidate. */
-type WalkStep = {
-    kind: 'fired';
+declare function actionShortcuts(action: Action, params?: Readonly<Record<string, unknown>>): readonly ActionShortcut[];
+
+/**
+ * Finding actions by tag: gathering the ones that carry it, and a person's
+ * search matching it as it matches a label.
+ */
+
+/** 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;
+
+/**
+ * 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.
+ */
+
+/**
+ * Result of evaluating an Action's `enabled` predicate.
+ */
+interface ActionEnabledResult {
+    enabled: boolean;
+    reason?: ActionDisabledReason;
 }
-/** 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';
+/**
+ * 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;
 }
-/** `enabled()` returned this reason. */
- | {
-    kind: 'declined';
-    reason: string;
+/** 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);
 }
-/** An ongoing action's `start()` returned an empty handle. */
- | {
-    kind: 'empty-handle';
+/**
+ * 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;
+
+/** 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;
 }
-/** An ongoing action bound to a press-time `pointerDown` spec; refused. */
- | {
-    kind: 'misbound';
+/**
+ * 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[];
 }
-/** Its action was already tried higher up; each runs at most once. */
- | {
-    kind: 'duplicate';
-} | {
-    kind: 'no-such-action';
+/**
+ * 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 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;
 }
 
 /**
@@ -1625,6 +1990,19 @@ 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;
+    /** 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
@@ -1654,6 +2032,8 @@ interface ResolveOnlyResult {
     scope: BindingScope;
     /** Tool id owning the winning binding; `null` for ambient action bindings. */
     ownerId: string | null;
+    /** The params the winning binding would start the action with, resolved now. */
+    params?: Record<string, unknown>;
 }
 /**
  * One candidate from `Dispatcher.resolveAll` — a binding that matched the
@@ -1830,31 +2210,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
@@ -1864,6 +2219,7 @@ declare function recordModeSwitch(mode: string, from: string | null, to: string
  *   with no `pointerId` (a synthesized probe, a programmatic drag, most tests)
  *   keys to `pointer-mouse`.
  * - `multitouch`: `multitouch-<fingers>`.
+ * - `carry`: `carry-<pointerId>`, keyed as a pointer is.
  * - any other kind that starts an ongoing invoker: `ongoing-<kind>`.
  */
 
@@ -1911,18 +2267,15 @@ declare function createDispatcher(opts?: {
 }): Dispatcher;
 
 /**
- * @experimental
  * Partial override or full descriptor passed via `<SceneCanvas actions={...}>`.
  * `null` disables a default at this id.
  */
 type ActionEntry = null | Partial<Action> | Action;
 /**
- * @experimental
  * Shape of the `actions` prop on `<SceneCanvas>`. `null` disables all defaults.
  */
 type ActionsProp = null | Record<string, ActionEntry>;
 /**
- * @experimental
  * Imperative API exposed by `useActionsRegistry()`.
  */
 interface ActionsRegistry {
@@ -1943,14 +2296,25 @@ interface ActionsRegistry {
      *  apply to whichever descriptor is live for it, registered before the
      *  tuning or after. Returns a release. See {@link ActionTuning}. */
     tune(id: string, tuning: ActionTuning): () => void;
+    /** The params an invocation of `id` from this scope starts with when it
+     *  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>;
     list(): readonly Action[];
     /** Fire an immediate-invoker action by id. The optional `params` arg is
      *  forwarded to `ImmediateInvoker.run` as its second argument — use it for
      *  parametric actions (e.g. `trigger('tool.activate', { toolId: 'rect' })`).
      *  Returns whether it ran one: `false` for an unknown id, for an action
      *  whose `enabled` refuses, and for an ongoing-invoker action, which
-     *  `trigger` cannot reach (see `begin`). `enabled` is asked with no point. */
+     *  `trigger` cannot reach (see `begin`). `enabled` is asked at
+     *  `{ x: params.worldX, y: params.worldY }` when both are numbers, and with
+     *  no point otherwise. */
     trigger(id: string, params?: Record<string, unknown>): boolean;
+    /** Show what firing `id` with `params` would do, by its `Action.preview`,
+     *  and return what takes it down; calling that twice is harmless. Shows
+     *  nothing for an unknown id, one with no preview, and one whose `enabled`
+     *  refuses, asked as `trigger` asks it. */
+    preview(id: string, params?: Record<string, unknown>): () => void;
     /**
      * Subscribe to registry mutations. The callback fires after any
      * `register`/`unregister` that changes the version. Returns an
@@ -2062,7 +2426,7 @@ declare const isSelectedBody: BodyPredicate;
 declare const isUnselectedBody: BodyPredicate;
 /** Empty-canvas hit — no node beneath cursor. */
 declare const isEmpty: BodyPredicate;
-/** Any corner resize handle — top-left/top-right/bottom-left/bottom-right. */
+/** Any resize handle: a corner (`handle:top-left`, …) or an edge (`handle:top`, …). */
 declare const isResizeHandle: TargetPredicate & {
     readsAffordance: true;
 };
@@ -2078,6 +2442,10 @@ declare const isAnchor: TargetPredicate & {
 declare const isControlHandle: TargetPredicate & {
     readsAffordance: true;
 };
+/** A corner-shape widget, set inside a corner anchor of the edited path. */
+declare const isCornerWidget: TargetPredicate & {
+    readsAffordance: true;
+};
 /** Any of the three anchor-editing affordances (anchor + both controls). */
 declare const isAnchorOrControl: TargetPredicate & {
     readsAffordance: true;
@@ -2086,7 +2454,13 @@ declare const isAnchorOrControl: TargetPredicate & {
 declare const isSegment: TargetPredicate & {
     readsAffordance: true;
 };
-/** Anything path edit puts on the path: an anchor, a control, or a segment. */
+/** The grip midway along a curved segment's balance line, `balance:N`, where
+ *  N is the flat index of the anchor the segment starts at. */
+declare const isBalanceGrip: TargetPredicate & {
+    readsAffordance: true;
+};
+/** Anything path edit puts on the path: an anchor, a control, a segment, a
+ *  segment's balance grip, or a corner widget. */
 declare const isPathEditPart: TargetPredicate & {
     readsAffordance: true;
 };
@@ -2164,6 +2538,29 @@ interface LongPressOptions {
 /** A store holding the press currently being held, or none. Pass it as `LongPressOptions.state`. */
 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. */
+    doubleClickMs: number;
+    /** Farthest apart the clicks of a double click may land, in CSS px. */
+    doubleClickPx: number;
+    /** How long a touch or pen press is held to fire a long-press, in ms. */
+    longPressMs: number;
+    /** Farthest a multitouch tap's fingers may travel, in CSS px. */
+    tapPx: number;
+    /** Travel that makes a press a drag, in CSS px. */
+    dragPx: number;
+}
+declare module '@weasel-js/react' {
+    interface KitSettings {
+        gestures: GestureKitSettings;
+    }
+}
+
 /**
  * The DOM half of a drag: one pointer, held down, from press to release.
  *
@@ -2221,6 +2618,60 @@ interface PointerSession {
  */
 declare function openPointerSession(origin: Element, down: PointerEvent | React.PointerEvent, cb: PointerSessionCallbacks, opts?: PointerSessionOptions): PointerSession;
 
+/**
+ * A press that begins on one element and is carried over another: the in-app
+ * sibling of an OS drag. The source opens the carry; every dispatcher with a
+ * `carry` channel registers its element as a surface, and the one under the
+ * pointer dispatches the carry as `carry` events through its bindings.
+ */
+
+/** What a carry brings. `type` is what a `carry` spec's `types` globs filter. */
+interface CarryPayload {
+    type: string;
+    value: unknown;
+}
+/** The pointer facts a surface reads off each step of a carry. */
+interface CarryPointer {
+    clientX: number;
+    clientY: number;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+}
+/** What a carry did on a surface: came over it, moved on it, was released on
+ *  it, or left it — off it, or canceled while over it. */
+type CarryStage = 'enter' | 'move' | 'drop' | 'leave';
+/** What {@link startCarry} reports to its source. Exactly one of `onEnd` /
+ *  `onCancel` fires. */
+interface CarryCallbacks {
+    /** Every move of the carrying pointer. */
+    onMove?: (e: PointerEvent) => void;
+    /** The pointer was released. `taken` is whether a binding on the surface
+     *  under it took the carry. */
+    onEnd?: (result: {
+        taken: boolean;
+        event: PointerEvent;
+    }) => void;
+    /** The carry ended without a release. Any surface it was over has had its leave. */
+    onCancel?: (reason: PointerSessionCancelReason) => void;
+}
+/** A live carry, opened by {@link startCarry}. */
+interface Carry {
+    readonly pointerId: number;
+    readonly active: boolean;
+    /** End the carry now, as a cancel. Idempotent. */
+    cancel(): void;
+}
+/**
+ * Carry `payload` from the press `down` on `origin` until the pointer is
+ * released or the press is canceled. While it moves, the surface under it
+ * hears the carry come over, move, and leave; a release over one is a drop
+ * there. The press is captured to `origin` as any drag is, so nothing the
+ * pointer passes over sees it as a press of its own.
+ */
+declare function startCarry(origin: Element, down: PointerEvent | React.PointerEvent, payload: CarryPayload, cb?: CarryCallbacks): Carry;
+
 /** What the registry knows at dispatch time. */
 interface EligibilityState {
     focusedId: string | null;
@@ -2401,6 +2852,8 @@ interface ToolDef<TOverlay = KernelOverlay> {
      * binding that points at an action id nothing registered.
      */
     actions?: Action[];
+    /** Menus this tool adds while it is active. */
+    menus?: MenuDef[];
     /** Hook name as exported from the kit barrel (e.g. `'useHandTool'`).
      *  Set by built-in hooks for inspector / debugging. Consumer-authored
      *  tools may set this to surface their hook name; omitted is fine.
@@ -2457,6 +2910,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
@@ -2607,8 +3083,7 @@ interface ToolScopes {
 /**
  * Detect reachable route conflicts in an assembled tool set and report each one.
  *
- * Call it once wherever a tool set is assembled, behind a
- * `process.env.NODE_ENV !== 'production'` guard.
+ * Call it once wherever a tool set is assembled, behind an `isDev()` guard.
  *
  * **Warn, never throw.** A conflict between a consumer's tool and a kit tool
  * is sometimes deliberate, since the loser can still take the gesture when
@@ -2673,6 +3148,30 @@ declare function matchesKeyBinding(e: KeyboardEvent, b: KeyBinding): boolean;
  *  React keyboard event as readily as a DOM one. */
 declare function historyKey(e: Pick<KeyboardEvent, 'key' | 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey'>): 'undo' | 'redo' | null;
 
+/**
+ * Key chords a major browser or the desktop under it takes before a page can:
+ * reload, devtools, tab and window commands, menu accelerators. A binding on
+ * one never fires for some users, so kit defaults steer clear of them.
+ *
+ * `mod` is Cmd on macOS and Ctrl elsewhere, as in a `KeySpec`. The list is
+ * the union across Chrome, Safari, Firefox and Edge on macOS, Windows and
+ * Linux, and errs toward listing a chord.
+ */
+
+/** One reserved chord, and what takes it. */
+interface ReservedChord {
+    key: string;
+    mod?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    /** Who takes it, for a message. */
+    use: string;
+}
+/** Every chord the module's header describes, one entry per key. */
+declare const BROWSER_RESERVED_CHORDS: readonly ReservedChord[];
+/** The first reserved chord `spec` can fire on, or `null` when none. */
+declare function browserReservedChord(spec: KeySpec): ReservedChord | null;
+
 /**
  * Typed keys for the gesture/behavior scratch store, `ctx.scratch`.
  * `ScratchKey<T>` carries its payload type at the typing layer; at runtime
@@ -2728,12 +3227,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. */
@@ -2805,15 +3313,15 @@ declare function dlog(namespace: string, ...args: unknown[]): void;
  *  (e.g. no-op op batches suppressed). */
 declare function dwarn(namespace: string, ...args: unknown[]): void;
 
-/**
- * @weasel-js/routing — binding-to-action routing.
- *
- * The pure half: no React, no DOM. The React seam that pumps browser events
- * into the dispatcher, and the providers that feed it, live behind
- * `@weasel-js/routing/react`.
- *
- * @packageDocumentation
- */
+/** The menus live now: ambient defs, then the active tool's. Defs that share
+ *  an id become one menu: each contribution's children in turn, with a
+ *  separator between contributions. Children stay at their own keys, so the
+ *  paths their values are read at do not move; a key a previous contribution
+ *  took gets `~n` appended. The first def of an id supplies the schema's
+ *  name and the def's `when`. */
+declare function mergeMenuDefs(defs: readonly OwnedMenuDef[], activeTool: string | null): MenuDef[];
+/** The first def whose `when` matches `hit`. */
+declare function pickMenu(defs: readonly MenuDef[], hit: MenuHit): MenuDef | undefined;
 
 /**
  * The dependency schema — the map of dep name → value type that
@@ -2836,6 +3344,10 @@ declare function dwarn(namespace: string, ...args: unknown[]): void;
 interface DepSchema {
     /** Currently active tool id + hotkey-hold stack. */
     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;
 }
 /** Every dep name declared by anything that has merged into {@link DepSchema}. */
 type DepName = keyof DepSchema;
@@ -2846,7 +3358,7 @@ type DepName = keyof DepSchema;
  *
  * ```ts
  * declare module '@weasel-js/core' {
- *   interface ActionParamSchema { brushDeleteAnchors: { radiusPx: number } }
+ *   interface ActionParamSchema { simplifyBrush: { radiusPx: number } }
  * }
  * ```
  *
@@ -2883,4 +3395,4 @@ type KernelOverlay = OverlaySchema extends {
     overlay: infer O;
 } ? O : unknown;
 
-export { DEFAULT_ALLOWED_CAPABILITIES as $, type ActionsRegistry as A, type ActionVariant as B, type Contribution as C, type DepRegistry as D, type ActionsProp as E, type AnyTool as F, type AssemblyInputs as G, type BindingOpts as H, type BindingScope as I, type BindingSource as J, type KernelOverlay as K, type LongPressOptions as L, type BodyPredicate as M, type NodeId as N, type OverlayPosition as O, type BoundGesture as P, type Bounds as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type BuildRuleCtxArgs as U, COARSE_TARGET_SCALE as V, type Condition as W, type Conflict as X, type ContributionChrome as Y, type ContributionDeps as Z, type ContributionRouting as _, type DepName as a, type TraceLogEntry as a$, DEFAULT_DEVICE_PROFILE as a0, type DebugSink as a1, type DetectedDeviceFacts as a2, type DeviceProfile as a3, type DispatchRecord as a4, type DispatchRecordInput as a5, type DispatcherContext as a6, type DragSample as a7, type DroppedCandidate as a8, type Eligibility as a9, type Point2 as aA, type PointerSession as aB, type PointerSessionCallbacks as aC, type PointerSessionCancelReason as aD, type PointerSessionOptions as aE, type RankedCandidate as aF, type RecordCandidate as aG, type RegistryEntry as aH, type ResizeAnchor as aI, type ResolveAllOptions as aJ, type ResolveOnlyResult as aK, type ResolvedCandidate as aL, type Rule as aM, type ScopedBinding as aN, type ScratchKey as aO, type ScratchStore as aP, type SelectionApi as aQ, type Selector as aR, type SpecificityPart as aS, TOOL_OFFHAND_ID as aT, type ToolDef as aU, type ToolKeybinding as aV, type ToolModifiers as aW, type ToolOffhandBindingSpec as aX, type ToolPresentation as aY, type ToolScopes as aZ, type ToolSlot as a_, type EligibilityState as aa, type GestureBinding as ab, type HandleKind as ac, type HitShape as ad, type HotkeyTrigger as ae, INGEST_STRING_MIMES as af, type ImmediateInvoker as ag, type InvocationCtx as ah, type Invoker as ai, type KeyBinding as aj, type LongPressState as ak, type LongPressStore as al, type MatchOutcome as am, type MatchResult as an, type ModeShortcutHandlers as ao, type ModeSwitchLogEntry as ap, type ModifierState as aq, NEVER as ar, type OngoingHandle as as, type OngoingInvoker as at, type OngoingOverlay as au, type OverlayRole as av, type OverlaySchema as aw, PREDICATE_TARGET as ax, type PendingLongPress as ay, type PlacedBy as az, type DepSchema as b, ruleCanHoldIn as b$, type TunedBinding as b0, type UiOngoingControl as b1, type ViewportGestureKind as b2, type WalkStep as b3, actionBindings as b4, actionItems as b5, assembleEntries as b6, buildDepsFromRequires as b7, buildRouteRegistry as b8, buildRuleCtx as b9, isRotateHandle as bA, isSegment as bB, isSelectedBody as bC, isTool as bD, isUnselectedBody as bE, itemTypesFromDataTransfer as bF, itemsFromClipboardData as bG, itemsFromDataTransfer as bH, itemsFromFiles as bI, liveScope as bJ, makeToolOffhandAction as bK, matchBest as bL, matchSorted as bM, matchSortedWithBarred as bN, matchesKeyBinding as bO, mergeContributions as bP, modeShortcutSpec as bQ, modeShortcuts as bR, multiTouchGestureId as bS, offhandKeyFor as bT, openPointerSession as bU, pointerGestureId as bV, recordModeSwitch as bW, reportRouteConflicts as bX, resolveDeviceProfile as bY, resolveParams as bZ, routesForSpec as b_, buildToolOffhandBindings as ba, clientToCanvas as bb, clientToCanvasRect as bc, createDepRegistry as bd, createDispatcher as be, createLongPressStore as bf, defineTool as bg, deleteScratch as bh, describeRule as bi, dlog as bj, dwarn as bk, evaluate as bl, evaluateActive as bm, evaluateEnabled as bn, findConflicts as bo, getScratch as bp, heldKeySpec as bq, historyKey as br, isAnchor as bs, isAnchorOrControl as bt, isBody as bu, isControlHandle as bv, isDebugEnabled as bw, isEmpty as bx, isPathEditPart as by, isResizeHandle as bz, type Action as c, rulesExclusive as c0, scopeBindings as c1, scratchKey as c2, setScratch as c3, targetConsultsAffordance as c4, tuneAction as c5, validateActionDefaultBinding as c6, validateActionId as c7, DepNode as d, type Tool as e, ActiveToolContextProvider as f, ActiveToolContextProviderIfRoot as g, type ActiveToolContextProviderProps as h, type ActiveToolContextValue as i, useOptionalActiveToolContext as j, type Dispatcher as k, type AffordanceHit as l, ALWAYS as m, type ActionDeps as n, ActionDisabledReason as o, type ActionDispatch as p, type ActionEnabledResult as q, type ActionEntry as r, type ActionItem as s, type ActionParamSchema as t, useActiveToolContext as u, type ActionParams as v, type ActionPresentation as w, type ActionSource as x, type ActionTuning as y, type ActionTunings as z };
+export { type Bounds as $, type Action as A, type BoundGesture as B, type Contribution as C, type DepRegistry as D, type ActionPresentation as E, type ActionSettings as F, type ActionSettingsState as G, type ActionShortcut as H, type ActionSource as I, type ActionTuning as J, type KernelOverlay as K, type LongPressOptions as L, type MenuHost as M, type NodeId as N, type OverlayPosition as O, type ActionTunings as P, type ActionsProp as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type AnyTool as U, type AssemblyInputs as V, BROWSER_RESERVED_CHORDS as W, type BindingOpts as X, type BindingScope as Y, type BindingSource as Z, type BodyPredicate as _, type DepName as a, type PointerSessionCallbacks as a$, type BuildRuleCtxArgs as a0, COARSE_TARGET_SCALE as a1, type Carried as a2, type Carry as a3, type CarryCallbacks as a4, type CarryPayload as a5, type CarryPointer as a6, type CarryStage as a7, type Condition as a8, type Conflict as a9, type KeyReach as aA, type LongPressState as aB, type LongPressStore as aC, type MatchOutcome as aD, type MatchResult as aE, type MenuHit as aF, type MenuOpenRequest as aG, type MenuSources as aH, type MenuWhen as aI, type ModeShortcutHandlers as aJ, type ModeSwitchLogEntry as aK, type ModifierRole as aL, type ModifierRoles as aM, type ModifierState as aN, NEVER as aO, type OngoingHandle as aP, type OngoingInvoker as aQ, type OngoingOverlay as aR, type OpenMenu as aS, type OverlayRole as aT, type OverlaySchema as aU, type OwnedMenuDef as aV, PREDICATE_TARGET as aW, type PendingLongPress as aX, type PlacedBy as aY, type Point2 as aZ, type PointerSession as a_, type ContributionChrome as aa, type ContributionDeps as ab, type ContributionRouting as ac, DEFAULT_ALLOWED_CAPABILITIES as ad, DEFAULT_DEVICE_PROFILE as ae, type DebugSink as af, type DepListing as ag, type DetectedDeviceFacts as ah, type DeviceProfile as ai, type DispatchRecord as aj, type DispatchRecordInput as ak, type DispatcherContext as al, type DragSample as am, type DroppedCandidate as an, type Eligibility as ao, type EligibilityState as ap, type GestureBinding as aq, type GestureKitSettings as ar, type HandleKind as as, type HitShape as at, type HotkeyTrigger as au, INGEST_STRING_MIMES as av, type ImmediateInvoker as aw, type InvocationCtx as ax, type Invoker as ay, type KeyBinding as az, type DepSource as b, evaluateActive as b$, type PointerSessionCancelReason as b0, type PointerSessionOptions as b1, type RankedCandidate as b2, type RecordCandidate as b3, type RegistryEntry as b4, type ReservedChord as b5, type ResizeAnchor as b6, type ResolveAllOptions as b7, type ResolveOnlyResult as b8, type ResolvedCandidate as b9, actionCursor as bA, actionItemTitle as bB, actionItems as bC, actionSettingsParams as bD, actionShortcuts as bE, actionsTagged as bF, admitIngestMime as bG, assembleEntries as bH, browserReservedChord as bI, buildDepsFromRequires as bJ, buildRouteRegistry as bK, buildRuleCtx as bL, buildToolOffhandBindings as bM, clientToCanvas as bN, clientToCanvasRect as bO, createDepRegistry as bP, createDispatchTrace as bQ, createDispatcher as bR, createLongPressStore as bS, createMenuHost as bT, createTraceRing as bU, defineTool as bV, deleteScratch as bW, describeRule as bX, dlog as bY, dwarn as bZ, evaluate as b_, type RoleKeys as ba, type RoleRebinds as bb, type Rule as bc, type ScopedBinding as bd, type ScratchKey as be, type ScratchStore as bf, type SelectionApi as bg, type Selector as bh, type SpecificityPart as bi, TOOL_OFFHAND_ID as bj, type ToolDef as bk, type ToolEntry as bl, type ToolKeybinding as bm, type ToolModifiers as bn, type ToolOffhandBindingSpec as bo, type ToolPresentation as bp, type ToolScopes as bq, type ToolSet as br, type ToolSlot as bs, type TraceLogEntry as bt, type TraceRing as bu, type TunedBinding as bv, type UiOngoingControl as bw, type ViewportGestureKind as bx, type WalkStep as by, actionBindings as bz, type ActionDeps as c, tuneAction as c$, evaluateEnabled as c0, findConflicts as c1, getScratch as c2, heldKeySpec as c3, historyKey as c4, isAnchor as c5, isAnchorOrControl as c6, isBalanceGrip as c7, isBody as c8, isControlHandle as c9, modeShortcutSpec as cA, modeShortcuts as cB, multiTouchGestureId as cC, offhandKeyFor as cD, openPointerSession as cE, overlaysOf as cF, pickMenu as cG, pointerGestureId as cH, readActionSettings as cI, reportRouteConflicts as cJ, resolveDeviceProfile as cK, resolveMenu as cL, resolveParams as cM, resolveSchemaMenu as cN, roleReader as cO, routesForSpec as cP, ruleCanHoldIn as cQ, rulesExclusive as cR, scopeBindings as cS, scratchKey as cT, setScratch as cU, startCarry as cV, taggedActionItems as cW, targetConsultsAffordance as cX, toolIdsOf as cY, toolSet as cZ, toolSetHas as c_, isCornerWidget as ca, isDebugEnabled as cb, isEmpty as cc, isPathEditPart as cd, isResizeHandle as ce, isRotateHandle as cf, isSegment as cg, isSelectedBody as ch, isTool as ci, isToolSet as cj, isUnselectedBody as ck, itemTypesFromDataTransfer as cl, itemsFromClipboardData as cm, itemsFromDataTransfer as cn, itemsFromFiles as co, keySpecShortcut as cp, keysHeld as cq, liveScope as cr, makeToolOffhandAction as cs, matchActionItem as ct, matchBest as cu, matchSorted as cv, matchSortedWithBarred as cw, matchesKeyBinding as cx, mergeContributions as cy, mergeMenuDefs as cz, type ActionsRegistry as d, validateActionDefaultBinding as d0, validateActionId as d1, withoutTools as d2, 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, type DispatchTrace as q, type DepSchema as r, ALWAYS as s, type ActionDispatch as t, useActiveToolContext as u, type ActionEnabledResult as v, type ActionEntry as w, type ActionItem as x, type ActionParamSchema as y, type ActionParams as z };