@weasel-js/routing 1.11.1 → 1.13.0-rc.0

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

@@ -1,7 +1,7 @@
-import { ModifierKey, ClaimableGesture, GestureSpec, InputEvent, TargetSpec, IngestItem, BodyTarget, KeyHeldSpec, TargetPredicate, KeySpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
+import { ModifierKey, ClaimableGesture, GestureSpec, InputEvent, TargetSpec, IngestItem, BodyTarget, BindingOverrideInput, KeyHeldSpec, TargetPredicate, KeySpec, ClickSpec, DoubleClickSpec, DragSpec, ContextMenuSpec, ParsedModifiers, GestureName } from '@weasel-js/gestures';
 import { FramedBox, View, Point } from '@weasel-js/geom';
 import { CursorSpec } from '@weasel-js/cursor';
-import { MenuEntry, Rect, MenuShortcut } from '@weasel-js/menu';
+import { MenuEntry, Rect, MenuSide, 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';
@@ -504,6 +504,11 @@ interface InvocationCtx {
 /** Per-invocation options the dispatcher reads from a `GestureBinding`'s
  *  `opts` field and passes to `OngoingInvoker.start`. */
 interface BindingOpts {
+    /** The id a binding override names this binding by, `<owner>.<role>`:
+     *  `undo.key`, `rect.drag`, `nudge.left.big`. Without one it is its owner and
+     *  its position (`<entry>#<n>`, `<action>@<n>`), which moves when the defaults
+     *  are reordered, so a binding a host may persist an override for declares one. */
+    id?: string;
     /** Gesture behaviors the action's own invoker runs. Routing carries the
      *  array to the action and never reads an element, so the element type is
      *  open here; `@weasel-js/core` narrows it. */
@@ -589,7 +594,9 @@ interface OngoingHandle {
      * 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.
+     * `previewPose` out rather than answering the same pose twice. `<SceneCanvas>`
+     * also shows both answers to the scene as overrides (core's
+     * `publishPreviews`), so what derives from a previewed node follows it.
      */
     previewIds?(): Iterable<string> | null;
     previewPose?(id: string): unknown | null;
@@ -696,6 +703,63 @@ interface BindingSource {
  */
 declare function actionBindings(action: BindingSource): GestureBinding[];
 
+/** What a key no open keymap binds does: `'modal'` swallows it and leaves the
+ *  keymap open; `'cascade'` closes the keymap and dispatches it as if none were. */
+type KeymapUnbound = 'modal' | 'cascade';
+/** What holds a level opened with `{ hold: true }` open: no key releases it, so it closes on Escape. */
+declare const KEYMAP_HOLD = "hold";
+/** One open level of a {@link KeymapStack}. */
+interface OpenKeymap {
+    readonly id: string;
+    readonly label: string;
+    /** The keymap's bindings as declared, for a hint to list. */
+    readonly bindings: readonly GestureBinding[];
+    /** The gesture id of the leader holding this level open, while it is held,
+     *  or {@link KEYMAP_HOLD}. */
+    readonly heldBy?: string;
+    /** Whether input arrived while the leader was held, so its release closes the level. */
+    readonly usedWhileHeld: boolean;
+}
+/** What the keymaps made of the raw input in progress: `'taken'` when one of
+ *  them handled it, `'cascaded'` when it went on past them, `null` before either. */
+type KeymapVerdict = 'taken' | 'cascaded' | null;
+/** The keymaps open on one surface, innermost last; a canvas's `keymaps` dep. */
+interface KeymapStack {
+    /** Every open level, outermost first. */
+    open(): readonly OpenKeymap[];
+    innermost(): OpenKeymap | null;
+    /** Open a level. `heldBy` names what holds it open; `bindings` are what a hint lists. */
+    push(id: string, label: string, opts?: {
+        heldBy?: string;
+        bindings?: readonly GestureBinding[];
+    }): void;
+    /** Mark the levels the last raw input opened as held by `heldBy`: the key
+     *  that opened them is still down. False when it opened none. */
+    holdOpened(heldBy: string): boolean;
+    /** The leader `heldBy` came up: close its level, those above it and the
+     *  tapped ones beneath it if input arrived meanwhile, else leave it open
+     *  for one more input. */
+    release(heldBy: string): void;
+    /** Close the innermost level: Escape. */
+    closeInnermost(): void;
+    /** One of the keymaps took this input, or a pointer gesture went past them.
+     *  Marks held levels used and closes once-levels down to the innermost held one. */
+    inputSeen(): void;
+    /** A key no keymap binds was swallowed: held levels count it as input, and nothing closes. */
+    swallowed(): void;
+    /** This input went on past the keymaps: as `inputSeen`, remembered as a cascade. */
+    cascaded(): void;
+    /** What the keymaps made of the input in progress. */
+    verdict(): KeymapVerdict;
+    closeAll(): void;
+    /** Run `fn` as one raw input: closes made inside apply when it returns. Nests. */
+    batch<T>(fn: () => T): T;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+}
+/** An empty {@link KeymapStack}. `useGestureDispatcher` makes one per surface. */
+declare function createKeymapStack(): KeymapStack;
+
 /**
  * Re-exports the pure matcher primitives from `@weasel-js/gestures` and layers
  * the actions-layer binding-scope / matchBest logic on top.
@@ -1249,9 +1313,10 @@ interface Carried {
     };
 }
 /**
- * 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.
+ * The kit's symbolic reasons an action might report itself as disabled. The
+ * consumer (palette, menu, etc.) maps these to display strings via its own
+ * label map. An action may also answer with any other string, which is
+ * display text and shown as is — see {@link ActionUnavailable}.
  */
 declare const ActionDisabledReason: {
     readonly SelectionRequired: "selection-required";
@@ -1262,6 +1327,9 @@ declare const ActionDisabledReason: {
 };
 /** Why an action is unavailable right now. */
 type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
+/** What `enabled` answers with when the action cannot run: one of the
+ *  symbolic {@link ActionDisabledReason}s, or a sentence to show as it is. */
+type ActionUnavailable = ActionDisabledReason | (string & {});
 /**
  * What a palette, menu or toolbar renders for an action. No part of this is
  * read during dispatch.
@@ -1334,7 +1402,8 @@ interface ActionDispatch extends BindingSource {
     scope?: 'hotkey';
     /**
      * Optional predicate saying whether the action can run right now. Return
-     * `true` when it can, or an `ActionDisabledReason` when it cannot. The
+     * `true` when it can, or an `ActionDisabledReason` or a sentence of display
+     * text when it cannot. The
      * command palette greys out a disabled row, skips it in keyboard nav,
      * ignores clicks, and shows the reason next to the label. The dispatcher
      * skips a disabled action too, on a key as on a pointer, and falls through
@@ -1370,7 +1439,7 @@ interface ActionDispatch extends BindingSource {
     enabled?: (deps?: ActionDeps, at?: {
         x: number;
         y: number;
-    }, carried?: Carried) => true | ActionDisabledReason;
+    }, carried?: Carried) => true | ActionUnavailable;
     /**
      * Whether the action reads as held down right now: bold on the selected
      * text, snapping switched on. A toolbar button draws it as pressed.
@@ -1521,6 +1590,9 @@ interface MenuOpenRequest {
     client: Point;
     /** Viewport rect of the button the menu hangs from: placed below it, or above when below does not fit. */
     under?: Rect;
+    /** With `under`: the side of the button it opens on when it fits there, flipping to the opposite side when it does not.
+     *  Default below. The canvas HUD menu host places below only and ignores it. */
+    side?: MenuSide;
     /** World point, passed to `enabled` and to every item. */
     world?: Point;
     params?: Record<string, unknown>;
@@ -1532,6 +1604,8 @@ interface OpenMenu {
     entries: readonly MenuEntry[];
     client: Point;
     under?: Rect;
+    /** `MenuOpenRequest.side`, carried to the renderer. */
+    side?: MenuSide;
     world?: Point;
     source: 'pointer' | 'keyboard';
 }
@@ -1769,7 +1843,7 @@ declare function matchActionItem(item: ActionItem, query: string): QueryMatch |
  */
 interface ActionEnabledResult {
     enabled: boolean;
-    reason?: ActionDisabledReason;
+    reason?: ActionUnavailable;
 }
 /**
  * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`
@@ -1853,6 +1927,29 @@ declare function createDepRegistry(): DepRegistry;
 /** Build the deps bag for an action from its declared `requires`. */
 declare function buildDepsFromRequires(action: Action, depRegistry: DepRegistry): ActionDeps;
 
+/**
+ * Binding overrides: a host's replacements for bindings it did not write,
+ * keyed by binding id. An override replaces or removes one binding, on an
+ * action or on a contribution alike; adding a key beside the defaults is
+ * `tune`'s job.
+ */
+
+/** Overrides by binding id: a route string or spec to bind instead, or `null` to unbind. */
+type BindingOverrides = Readonly<Record<string, BindingOverrideInput>>;
+/** Overrides read into specs, one per binding id. */
+type ResolvedBindingOverrides = ReadonlyMap<string, GestureSpec | null>;
+/** A binding's id: its declared `opts.id`, else its owner and its position
+ *  there — `<entry>#<n>` for an entry's binding (`ownerId`), `<action>@<n>` for
+ *  an action's own (`ownerId` null), so an entry and an action of one id never
+ *  share a derived id. */
+declare function bindingId(b: GestureBinding, ownerId: string | null, index: number): string;
+/** Merge override maps into one, a later map winning per id. A route string
+ *  that does not parse is skipped with a warning, leaving the binding as it was. */
+declare function resolveBindingOverrides(maps: readonly BindingOverrides[]): ResolvedBindingOverrides;
+/** The bindings `ownerId` declares, each under its override, the unbound ones
+ *  left out: what dispatch routes by. A `null` owner is an action's own. */
+declare function overriddenBindings(bindings: readonly GestureBinding[], ownerId: string | null, overrides?: ResolvedBindingOverrides): GestureBinding[];
+
 /** Hotkey-slot trigger key. The slot is engaged while this key is held —
  *  hence "hotkey": active as long as the key is hot. Omitted means the tool
  *  is not eligible for the hotkey slot.
@@ -1899,6 +1996,12 @@ interface Eligibility {
     claimed?: boolean;
     /** Modality filter, applied wherever it would otherwise be live. */
     capabilities?: CapabilityTag[];
+    /** A keymap: live only while it is the innermost one open, at the hotkey
+     *  tier. `unbound` overrides the `gestures.keymapUnbound` kit setting for
+     *  this keymap. Open one with a leader (`keymapContribution`). */
+    keymap?: true | {
+        unbound?: KeymapUnbound;
+    };
 }
 /**
  * Where an entry's overlay sits in the layer stack, relative to the
@@ -1908,9 +2011,9 @@ interface Eligibility {
  * all three collapse to `'top'`.
  */
 type OverlayPosition = 'top' | 'before-selection' | 'after-selection';
-/** Dep sources an entry provides while it is installed, by dep name. */
+/** Dep sources an entry provides while it is installed, by dep name. A source may read the one it displaces. */
 type ContributionDeps = {
-    [K in DepName]?: () => DepSchema[K];
+    [K in DepName]?: DepSource<K>;
 };
 /**
  * What routing reads off an entry: when its bindings are live, which they
@@ -1996,6 +2099,17 @@ interface DispatcherContext {
      * is, the rest only while it holds them. Absent, every binding is live.
      */
     keyReach?: KeyReach;
+    /** The keymaps open on this surface. Absent: none can open. */
+    keymaps?: KeymapStack;
+    /** Which bindings this pass of an input reaches while a keymap is open:
+     *  `'only'` the innermost keymap's, `'none'` everything but it. Absent: both. */
+    keymapPass?: 'only' | 'none';
+    /** What a key no open keymap binds does, unless the keymap says: the
+     *  `gestures.keymapUnbound` kit setting. Default `'modal'`. */
+    leaderUnbound?: KeymapUnbound;
+    /** The binding overrides in force, read per input, for contribution bindings;
+     *  the registry lays them over actions' own. Absent overrides nothing. */
+    bindingOverrides?: () => ResolvedBindingOverrides;
     /** Where the dispatcher records how it resolved each input. Absent records nothing. */
     trace?: DispatchTrace;
 }
@@ -2300,6 +2414,12 @@ interface ActionsRegistry {
      *  passes `given`: every tuning's params, `given` laid over them. What a
      *  tool's chrome reads to show what the action it binds will do. */
     paramsOf(id: string, given?: Record<string, unknown>): Record<string, unknown>;
+    /** Replace or remove bindings by id, here and in scopes below. Holders
+     *  merge: an inner scope's beats an outer one's, and a later one beats an
+     *  earlier one in the same scope. Returns a release. See {@link BindingOverrides}. */
+    overrideBindings(overrides: BindingOverrides): () => void;
+    /** Every override in force from this scope, read into specs. */
+    bindingOverrides(): ResolvedBindingOverrides;
     list(): readonly Action[];
     /** Fire an immediate-invoker action by id. The optional `params` arg is
      *  forwarded to `ImmediateInvoker.run` as its second argument — use it for
@@ -2366,6 +2486,24 @@ declare function validateActionId(id: string): void;
  *  (Tool.bindings) are the right place for '&' atoms. */
 declare function validateActionDefaultBinding(action: Action): void;
 
+/** What the dispatcher reads straight off an input event. */
+
+/**
+ * Modifier flags as an immediate invoker sees them, in the kit's
+ * `ModifierState` spelling rather than the DOM's `*Key` one.
+ *
+ * Most actions should still express modifier semantics as separate bindings
+ * with `opts.params` — that is what makes them visible to conflict detection
+ * and the inspector. This is for the cases where the modifier is data rather
+ * than a route.
+ */
+declare function modifierStateOf(e: {
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+}): ModifierState;
+
 /** Canonical id of the consolidated tool-offhand action. One descriptor
  *  serves every tool; the matched binding supplies `params.toolId` to select
  *  which tool to engage while the key is held. */
@@ -2381,8 +2519,8 @@ interface ToolOffhandBindingSpec {
 declare function offhandKeyFor(trigger: HotkeyTrigger): string;
 /** Build the per-tool `BoundGesture` list for the consolidated action's
  *  `defaultBinding`. Each entry pairs a `key-held` spec with
- *  `opts.params.toolId` so the invoker's `start` can pick out which tool
- *  to engage.
+ *  `opts.params.toolId`, so the invoker's `start` can pick out which tool
+ *  to engage, and is overridden as `tool.offhand.<toolId>`.
  *
  *  An offhand tool engages only between gestures. Swapping the tool out
  *  mid-drag would cancel the drag, and the key is free for the gesture's own
@@ -2542,6 +2680,7 @@ declare function createLongPressStore(): LongPressStore;
  * The `gestures` kit settings area. Declared here rather than in core because
  * the dispatcher reads it, and routing sits below core.
  */
+
 /** Pointer gesture timings and travel; each falls back to its constant in `@weasel-js/gestures`. */
 interface GestureKitSettings {
     /** Longest gap between the clicks of a double click, in ms. */
@@ -2554,6 +2693,9 @@ interface GestureKitSettings {
     tapPx: number;
     /** Travel that makes a press a drag, in CSS px. */
     dragPx: number;
+    /** What a key an open keymap does not bind does: `'modal'` swallows it,
+     *  `'cascade'` closes the keymap and lets it through. */
+    keymapUnbound: KeymapUnbound;
 }
 declare module '@weasel-js/react' {
     interface KitSettings {
@@ -2681,6 +2823,8 @@ interface EligibilityState {
     engagedIds?: ReadonlySet<string>;
     /** Whether the active mode allows these capability tags. Omitted → allow. */
     allows?: (tags: readonly CapabilityTag[]) => boolean;
+    /** The innermost open keymap's id: the one keymap entry that is live. */
+    openKeymap?: string | null;
 }
 /**
  * The scope tier an entry's bindings are live at, or null when none are.
@@ -2696,7 +2840,7 @@ declare function liveScope(id: string, eligibility: Eligibility, state: Eligibil
  * breaks ties by declaration order, so the caller's entry order decides which
  * of two same-specificity bindings in one tier wins.
  */
-declare function scopeBindings(entries: Iterable<Contribution<unknown>>, state: EligibilityState): ScopedBinding[];
+declare function scopeBindings(entries: Iterable<Contribution<unknown>>, state: EligibilityState, overrides?: ResolvedBindingOverrides): ScopedBinding[];
 /** What decides which entries are live, and in what order they are walked. */
 interface AssemblyInputs {
     focusedId: string | null;
@@ -2705,6 +2849,8 @@ interface AssemblyInputs {
     /** The capability tags the active mode allows. Omitted: no mode system, so
      *  every entry is allowed. */
     allowedCapabilities?: ReadonlySet<CapabilityTag>;
+    /** The innermost open keymap's id, if one is open. */
+    openKeymap?: string | null;
 }
 /**
  * The entry set as routing walks it, with the state that tiers it. The
@@ -2773,6 +2919,126 @@ declare function modeShortcutSpec(shortcut: string): KeySpec;
  */
 declare function modeShortcuts(registry: ModeRegistry, handlers: ModeShortcutHandlers): Contribution<never>;
 
+/**
+ * A keymap and the leader that opens it, from one definition. The keymap is an
+ * entry whose bindings are live only while it is open; the leader is an
+ * action on the hotkey tier, so it outranks what the active tool binds to the
+ * same key, and it opens the keymap mid-gesture as well as between them.
+ */
+
+/** What {@link keymapContribution} builds a keymap and its leader from. */
+interface KeymapDef<TOverlay = never> {
+    /** The keymap entry's id. Its leader action is `keymap.<id>`. */
+    id: string;
+    /** What the hint and a shortcut chip call it: `Loupe ▸ 2`. */
+    label: string;
+    /** The keystroke, or keystrokes, that open it. A `key-held` spec is read as
+     *  its `key` form: holding the key is what holds the keymap open. */
+    leader: GestureSpec | readonly GestureSpec[];
+    /** The keymap's own bindings. Escape is not one: it always closes the keymap. */
+    bindings: readonly GestureBinding[];
+    /** Actions the bindings name that are not registered elsewhere. */
+    actions?: readonly Action[];
+    /** Overrides the `gestures.keymapUnbound` kit setting for this keymap. */
+    unbound?: KeymapUnbound;
+    /** Drawn while the keymap is open. */
+    overlay?: TOverlay | TOverlay[];
+    overlayPosition?: OverlayPosition;
+}
+/** The leader action's id for keymap `id`. */
+declare const keymapLeaderId: (id: string) => string;
+/** The binding id of a keymap's leader — what a binding override rebinds it by.
+ *  A second leader key is `<id>#1`, and so on. */
+declare const keymapLeaderBindingId: (id: string, index?: number) => string;
+/** `[keymap entry, leader entry]`. Triggered without a key, the leader opens
+ *  its keymap tapped; `trigger('keymap.<id>', { hold: true })` holds it open
+ *  until Escape. Install both, with `<SceneCanvas ambient>`
+ *  or `useTools`'s `ambient`; the leader entry carries the actions. */
+declare function keymapContribution<TOverlay = never>(def: KeymapDef<TOverlay>): Contribution<TOverlay>[];
+
+/** One row of a keymap's hint: a key chip, or a pointer gesture in words, and what it does. */
+interface KeymapRow {
+    shortcut?: MenuShortcut;
+    gesture?: string;
+    label: string;
+}
+/** An open keymap as a hint shows it: {@link describeKeymap}'s result. */
+interface KeymapDescription {
+    id: string;
+    label: string;
+    /** Whether a held leader is keeping it open. */
+    held: boolean;
+    rows: readonly KeymapRow[];
+}
+/** The rows a hint lists for an open keymap, under the overrides in force. */
+declare function describeKeymap(level: OpenKeymap, actions: readonly Action[], overrides?: ResolvedBindingOverrides): KeymapDescription;
+/**
+ * Every key in `def` as a menu chip, by action id, each carrying the path
+ * through its leader (`Loupe ▸ 2`), under `overrides`. A keymap with no key
+ * leader gives its keys no path.
+ */
+declare function keymapShortcuts(def: KeymapDef, overrides?: ResolvedBindingOverrides): ReadonlyMap<string, readonly MenuShortcut[]>;
+
+/** Options for {@link captureKey}. */
+interface CaptureKeyOptions {
+    /** Capture the held form, `key-held`, rather than the keystroke. */
+    held?: boolean;
+    /** Stop listening and resolve `null`. */
+    signal?: AbortSignal;
+    /** Whether Cmd is Mod. Defaults to the detected platform. */
+    apple?: boolean;
+}
+/**
+ * The next keystroke on `target` as a key spec: {@link captureGesture} taking
+ * a keystroke alone, and leaving the pointer to the page. A bare modifier is
+ * waited past. Write the result with `keySpecRoute` to persist it as a binding
+ * override.
+ */
+declare function captureKey(target: EventTarget, opts?: CaptureKeyOptions): Promise<KeySpec | KeyHeldSpec | null>;
+
+/** A spec kind a binding editor can capture. */
+type CaptureKind = 'key' | 'key-held' | 'click' | 'doubleClick' | 'drag' | 'contextMenu';
+/** What `captureGesture` resolves to. */
+type CapturedSpec = KeySpec | KeyHeldSpec | ClickSpec | DoubleClickSpec | DragSpec | ContextMenuSpec;
+
+/** The click-and-drag thresholds a capture reads, each defaulting to its constant. */
+interface CaptureThresholds {
+    dragPx?: number;
+    doubleClickMs?: number;
+    doubleClickPx?: number;
+}
+
+/** Options for {@link captureGesture}. */
+interface CaptureGestureOptions extends CaptureThresholds {
+    /** The kinds to take; input of any other kind is waited past. A keystroke
+     *  is taken as `key` when both `key` and `key-held` are listed. Defaults to
+     *  `key`, `click`, `doubleClick`, `drag` and `contextMenu`. */
+    kinds?: readonly CaptureKind[];
+    /** Stop listening and resolve `null`. */
+    signal?: AbortSignal;
+    /** Whether Cmd is Mod. Defaults to the detected platform. */
+    apple?: boolean;
+    /** Travel that makes a press a drag, in CSS px: pass the `gestures.dragPx`
+     *  kit setting. Defaults to `DRAG_THRESHOLD_PX`. */
+    dragPx?: number;
+    /** The `gestures.doubleClickMs` kit setting. Defaults to `DOUBLE_CLICK_MAX_MS`. */
+    doubleClickMs?: number;
+    /** The `gestures.doubleClickPx` kit setting. Defaults to `DOUBLE_CLICK_MAX_PX`. */
+    doubleClickPx?: number;
+}
+/**
+ * The next input on `target` of one of `opts.kinds`, as a gesture spec, for a
+ * binding editor: its modifiers with the platform's primary one as `mod`. A
+ * press is told a click or a drag by the dispatcher's own recognizer, at its
+ * drag threshold; a click is held back for a double click only when both are
+ * asked for. A bare modifier key is waited past. Escape, or an abort, resolves
+ * `null`. What it takes is `preventDefault`ed and stopped, the click a browser
+ * follows a press with included, so nothing else acts on it. The pointer is
+ * left alone when no pointer kind is asked for, and keys other than Escape
+ * when no key kind is.
+ */
+declare function captureGesture(target: EventTarget, opts?: CaptureGestureOptions): Promise<CapturedSpec | null>;
+
 /**
  * A tool's activation key, as `ToolDef.keybinding` declares it. Captures
  * only the fields meaningful to a tool-select key —
@@ -3079,6 +3345,9 @@ interface ToolScopes {
      *  definition). Two gated actions conflict only when some mode lets both
      *  rules hold. Default: the kit's `DEFAULT_MODES`. */
     modes?: readonly ActiveMode[];
+    /** Binding overrides in force, applied to the entries' bindings. Actions are
+     *  read as given: an `ActionsRegistry`'s `list()` has applied them already. */
+    overrides?: ResolvedBindingOverrides;
 }
 /**
  * Detect reachable route conflicts in an assembled tool set and report each one.
@@ -3348,6 +3617,8 @@ interface DepSchema {
     menuHost?: MenuHost;
     /** The canvas's dispatch trace, for a dep to record a mode switch into. */
     dispatchTrace?: DispatchTrace;
+    /** The keymaps open on the canvas: what a leader opens and a hint reads. */
+    keymaps?: KeymapStack;
 }
 /** Every dep name declared by anything that has merged into {@link DepSchema}. */
 type DepName = keyof DepSchema;
@@ -3395,4 +3666,4 @@ type KernelOverlay = OverlaySchema extends {
     overlay: infer O;
 } ? O : unknown;
 
-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 };
+export { type BindingScope as $, type Action as A, type BoundGesture as B, type Contribution as C, type DepRegistry as D, type ActionParams as E, type ActionPresentation as F, type ActionSettings as G, type ActionSettingsState as H, type ActionShortcut as I, type ActionSource as J, type KeymapDescription as K, type LongPressOptions as L, type MenuHost as M, type NodeId as N, type OverlayPosition as O, type ActionTuning as P, type ActionTunings as Q, type RuleCtx as R, ScopeNode as S, ToolNode as T, type ActionUnavailable as U, type ActionsProp as V, type AnyTool as W, type AssemblyInputs as X, BROWSER_RESERVED_CHORDS as Y, type BindingOpts as Z, type BindingOverrides as _, type DepName as a, NEVER as a$, type BindingSource as a0, type BodyPredicate as a1, type Bounds as a2, type BuildRuleCtxArgs as a3, COARSE_TARGET_SCALE as a4, type CaptureGestureOptions as a5, type CaptureKeyOptions as a6, type CaptureKind as a7, type CapturedSpec as a8, type Carried as a9, type HitShape as aA, type HotkeyTrigger as aB, INGEST_STRING_MIMES as aC, type ImmediateInvoker as aD, type InvocationCtx as aE, type Invoker as aF, KEYMAP_HOLD as aG, type KeyBinding as aH, type KeyReach as aI, type KeymapDef as aJ, type KeymapRow as aK, type KeymapStack as aL, type KeymapUnbound as aM, type KeymapVerdict as aN, type LongPressState as aO, type LongPressStore as aP, type MatchOutcome as aQ, type MatchResult as aR, type MenuHit as aS, type MenuOpenRequest as aT, type MenuSources as aU, type MenuWhen as aV, type ModeShortcutHandlers as aW, type ModeSwitchLogEntry as aX, type ModifierRole as aY, type ModifierRoles as aZ, type ModifierState as a_, type Carry as aa, type CarryCallbacks as ab, type CarryPayload as ac, type CarryPointer as ad, type CarryStage as ae, type Condition as af, type Conflict as ag, type ContributionChrome as ah, type ContributionDeps as ai, type ContributionRouting as aj, DEFAULT_ALLOWED_CAPABILITIES as ak, DEFAULT_DEVICE_PROFILE as al, type DebugSink as am, type DepListing as an, type DetectedDeviceFacts as ao, type DeviceProfile as ap, type DispatchRecord as aq, type DispatchRecordInput as ar, type DispatcherContext as as, type DragSample as at, type DroppedCandidate as au, type Eligibility as av, type EligibilityState as aw, type GestureBinding as ax, type GestureKitSettings as ay, type HandleKind as az, type DepSource as b, buildRuleCtx as b$, type OngoingHandle as b0, type OngoingInvoker as b1, type OngoingOverlay as b2, type OpenKeymap as b3, type OpenMenu as b4, type OverlayRole as b5, type OverlaySchema as b6, type OwnedMenuDef as b7, PREDICATE_TARGET as b8, type PendingLongPress as b9, type ToolEntry as bA, type ToolKeybinding as bB, type ToolModifiers as bC, type ToolOffhandBindingSpec as bD, type ToolPresentation as bE, type ToolScopes as bF, type ToolSet as bG, type ToolSlot as bH, type TraceLogEntry as bI, type TraceRing as bJ, type TunedBinding as bK, type UiOngoingControl as bL, type ViewportGestureKind as bM, type WalkStep as bN, actionBindings as bO, actionCursor as bP, actionItemTitle as bQ, actionItems as bR, actionSettingsParams as bS, actionShortcuts as bT, actionsTagged as bU, admitIngestMime as bV, assembleEntries as bW, bindingId as bX, browserReservedChord as bY, buildDepsFromRequires as bZ, buildRouteRegistry as b_, type PlacedBy as ba, type Point2 as bb, type PointerSession as bc, type PointerSessionCallbacks as bd, type PointerSessionCancelReason as be, type PointerSessionOptions as bf, type RankedCandidate as bg, type RecordCandidate as bh, type RegistryEntry as bi, type ReservedChord as bj, type ResizeAnchor as bk, type ResolveAllOptions as bl, type ResolveOnlyResult as bm, type ResolvedBindingOverrides as bn, type ResolvedCandidate as bo, type RoleKeys as bp, type RoleRebinds as bq, type Rule as br, type ScopedBinding as bs, type ScratchKey as bt, type ScratchStore as bu, type SelectionApi as bv, type Selector as bw, type SpecificityPart as bx, TOOL_OFFHAND_ID as by, type ToolDef as bz, type ActionDeps as c, multiTouchGestureId as c$, buildToolOffhandBindings as c0, captureGesture as c1, captureKey as c2, clientToCanvas as c3, clientToCanvasRect as c4, createDepRegistry as c5, createDispatchTrace as c6, createDispatcher as c7, createKeymapStack as c8, createLongPressStore as c9, isSegment as cA, isSelectedBody as cB, isTool as cC, isToolSet as cD, isUnselectedBody as cE, itemTypesFromDataTransfer as cF, itemsFromClipboardData as cG, itemsFromDataTransfer as cH, itemsFromFiles as cI, keySpecShortcut as cJ, keymapContribution as cK, keymapLeaderBindingId as cL, keymapLeaderId as cM, keymapShortcuts as cN, keysHeld as cO, liveScope as cP, makeToolOffhandAction as cQ, matchActionItem as cR, matchBest as cS, matchSorted as cT, matchSortedWithBarred as cU, matchesKeyBinding as cV, mergeContributions as cW, mergeMenuDefs as cX, modeShortcutSpec as cY, modeShortcuts as cZ, modifierStateOf as c_, createMenuHost as ca, createTraceRing as cb, defineTool as cc, deleteScratch as cd, describeKeymap as ce, describeRule as cf, dlog as cg, dwarn as ch, evaluate as ci, evaluateActive as cj, evaluateEnabled as ck, findConflicts as cl, getScratch as cm, heldKeySpec as cn, historyKey as co, isAnchor as cp, isAnchorOrControl as cq, isBalanceGrip as cr, isBody as cs, isControlHandle as ct, isCornerWidget as cu, isDebugEnabled as cv, isEmpty as cw, isPathEditPart as cx, isResizeHandle as cy, isRotateHandle as cz, type ActionsRegistry as d, offhandKeyFor as d0, openPointerSession as d1, overlaysOf as d2, overriddenBindings as d3, pickMenu as d4, pointerGestureId as d5, readActionSettings as d6, reportRouteConflicts as d7, resolveBindingOverrides as d8, resolveDeviceProfile as d9, resolveMenu as da, resolveParams as db, resolveSchemaMenu as dc, roleReader as dd, routesForSpec as de, ruleCanHoldIn as df, rulesExclusive as dg, scopeBindings as dh, scratchKey as di, setScratch as dj, startCarry as dk, taggedActionItems as dl, targetConsultsAffordance as dm, toolIdsOf as dn, toolSet as dp, toolSetHas as dq, tuneAction as dr, validateActionDefaultBinding as ds, validateActionId as dt, withoutTools as du, ActionDisabledReason as e, type ActionVariant as f, type MenuDef as g, DepNode as h, type KernelOverlay as i, type Tool as j, ActiveToolContextProvider as k, ActiveToolContextProviderIfRoot as l, type ActiveToolContextProviderProps as m, type ActiveToolContextValue as n, useOptionalActiveToolContext as o, type Dispatcher as p, type AffordanceHit as q, type DispatchTrace as r, type DepSchema as s, ALWAYS as t, useActiveToolContext as u, type ActionDispatch as v, type ActionEnabledResult as w, type ActionEntry as x, type ActionItem as y, type ActionParamSchema as z };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { s as ALWAYS, A as Action, c as ActionDeps, e as ActionDisabledReason, e as ActionDisabledReasonValue, t as ActionDispatch, v as ActionEnabledResult, w as ActionEntry, x as ActionItem, y as ActionParamSchema, z as ActionParams, E as ActionPresentation, F as ActionSettings, G as ActionSettingsState, H as ActionShortcut, I as ActionSource, J as ActionTuning, P as ActionTunings, f as ActionVariant, Q as ActionsProp, d as ActionsRegistry, p as AffordanceHit, U as AnyTool, V as AssemblyInputs, W as BROWSER_RESERVED_CHORDS, X as BindingOpts, Y as BindingScope, Z as BindingSource, _ as BodyPredicate, B as BoundGesture, $ as Bounds, a0 as BuildRuleCtxArgs, a1 as COARSE_TARGET_SCALE, a2 as Carried, a3 as Carry, a4 as CarryCallbacks, a5 as CarryPayload, a6 as CarryPointer, a7 as CarryStage, a8 as Condition, a9 as Conflict, C as Contribution, aa as ContributionChrome, ab as ContributionDeps, ac as ContributionRouting, ad as DEFAULT_ALLOWED_CAPABILITIES, ae as DEFAULT_DEVICE_PROFILE, af as DebugSink, ag as DepListing, a as DepName, D as DepRegistry, r as DepSchema, b as DepSource, ah as DetectedDeviceFacts, ai as DeviceProfile, aj as DispatchRecord, ak as DispatchRecordInput, q as DispatchTrace, o as Dispatcher, al as DispatcherContext, am as DragSample, an as DroppedCandidate, ao as Eligibility, ap as EligibilityState, aq as GestureBinding, ar as GestureKitSettings, as as HandleKind, at as HitShape, au as HotkeyTrigger, av as INGEST_STRING_MIMES, aw as ImmediateInvoker, ax as InvocationCtx, ay as Invoker, K as KernelOverlay, az as KeyBinding, aA as KeyReach, L as LongPressOptions, aB as LongPressState, aC as LongPressStore, aD as MatchOutcome, aE as MatchResult, g as MenuDef, aF as MenuHit, M as MenuHost, aG as MenuOpenRequest, aH as MenuSources, aI as MenuWhen, aJ as ModeShortcutHandlers, aK as ModeSwitchLogEntry, aL as ModifierRole, aM as ModifierRoles, aN as ModifierState, aO as NEVER, N as NodeId, aP as OngoingHandle, aQ as OngoingInvoker, aR as OngoingOverlay, aS as OpenMenu, O as OverlayPosition, aT as OverlayRole, aU as OverlaySchema, aV as OwnedMenuDef, aW as PREDICATE_TARGET, aX as PendingLongPress, aY as PlacedBy, aZ as Point2, a_ as PointerSession, a$ as PointerSessionCallbacks, b0 as PointerSessionCancelReason, b1 as PointerSessionOptions, b2 as RankedCandidate, b3 as RecordCandidate, b4 as RegistryEntry, b5 as ReservedChord, b6 as ResizeAnchor, b7 as ResolveAllOptions, b8 as ResolveOnlyResult, b9 as ResolvedCandidate, ba as RoleKeys, bb as RoleRebinds, bc as Rule, R as RuleCtx, bd as ScopedBinding, be as ScratchKey, bf as ScratchStore, bg as SelectionApi, bh as Selector, bi as SpecificityPart, bj as TOOL_OFFHAND_ID, i as Tool, bk as ToolDef, bl as ToolEntry, bm as ToolKeybinding, bn as ToolModifiers, bo as ToolOffhandBindingSpec, bp as ToolPresentation, bq as ToolScopes, br as ToolSet, bs as ToolSlot, bt as TraceLogEntry, bu as TraceRing, bv as TunedBinding, bw as UiOngoingControl, bx as ViewportGestureKind, by as WalkStep, bz as actionBindings, bA as actionCursor, bB as actionItemTitle, bC as actionItems, bD as actionSettingsParams, bE as actionShortcuts, bF as actionsTagged, bG as admitIngestMime, bH as assembleEntries, bI as browserReservedChord, bJ as buildDepsFromRequires, bK as buildRouteRegistry, bL as buildRuleCtx, bM as buildToolOffhandBindings, bN as clientToCanvas, bO as clientToCanvasRect, bP as createDepRegistry, bQ as createDispatchTrace, bR as createDispatcher, bS as createLongPressStore, bT as createMenuHost, bU as createTraceRing, bV as defineTool, bW as deleteScratch, bX as describeRule, bY as dlog, bZ as dwarn, b_ as evaluate, b$ as evaluateActive, c0 as evaluateEnabled, c1 as findConflicts, c2 as getScratch, c3 as heldKeySpec, c4 as historyKey, c5 as isAnchor, c6 as isAnchorOrControl, c7 as isBalanceGrip, c8 as isBody, c9 as isControlHandle, ca as isCornerWidget, cb as isDebugEnabled, cc as isEmpty, cd as isPathEditPart, ce as isResizeHandle, cf as isRotateHandle, cg as isSegment, ch as isSelectedBody, ci as isTool, cj as isToolSet, ck as isUnselectedBody, cl as itemTypesFromDataTransfer, cm as itemsFromClipboardData, cn as itemsFromDataTransfer, co as itemsFromFiles, cp as keySpecShortcut, cq as keysHeld, cr as liveScope, cs as makeToolOffhandAction, ct as matchActionItem, cu as matchBest, cv as matchSorted, cw as matchSortedWithBarred, cx as matchesKeyBinding, cy as mergeContributions, cz as mergeMenuDefs, cA as modeShortcutSpec, cB as modeShortcuts, cC as multiTouchGestureId, cD as offhandKeyFor, cE as openPointerSession, cF as overlaysOf, cG as pickMenu, cH as pointerGestureId, cI as readActionSettings, cJ as reportRouteConflicts, cK as resolveDeviceProfile, cL as resolveMenu, cM as resolveParams, cN as resolveSchemaMenu, cO as roleReader, cP as routesForSpec, cQ as ruleCanHoldIn, cR as rulesExclusive, cS as scopeBindings, cT as scratchKey, cU as setScratch, cV as startCarry, cW as taggedActionItems, cX as targetConsultsAffordance, cY as toolIdsOf, cZ as toolSet, c_ as toolSetHas, c$ as tuneAction, d0 as validateActionDefaultBinding, d1 as validateActionId, d2 as withoutTools } from './index-Cb7ehEks.js';
+export { t as ALWAYS, A as Action, c as ActionDeps, e as ActionDisabledReason, e as ActionDisabledReasonValue, v as ActionDispatch, w as ActionEnabledResult, x as ActionEntry, y as ActionItem, z as ActionParamSchema, E as ActionParams, F as ActionPresentation, G as ActionSettings, H as ActionSettingsState, I as ActionShortcut, J as ActionSource, P as ActionTuning, Q as ActionTunings, U as ActionUnavailable, f as ActionVariant, V as ActionsProp, d as ActionsRegistry, q as AffordanceHit, W as AnyTool, X as AssemblyInputs, Y as BROWSER_RESERVED_CHORDS, Z as BindingOpts, _ as BindingOverrides, $ as BindingScope, a0 as BindingSource, a1 as BodyPredicate, B as BoundGesture, a2 as Bounds, a3 as BuildRuleCtxArgs, a4 as COARSE_TARGET_SCALE, a5 as CaptureGestureOptions, a6 as CaptureKeyOptions, a7 as CaptureKind, a8 as CapturedSpec, a9 as Carried, aa as Carry, ab as CarryCallbacks, ac as CarryPayload, ad as CarryPointer, ae as CarryStage, af as Condition, ag as Conflict, C as Contribution, ah as ContributionChrome, ai as ContributionDeps, aj as ContributionRouting, ak as DEFAULT_ALLOWED_CAPABILITIES, al as DEFAULT_DEVICE_PROFILE, am as DebugSink, an as DepListing, a as DepName, D as DepRegistry, s as DepSchema, b as DepSource, ao as DetectedDeviceFacts, ap as DeviceProfile, aq as DispatchRecord, ar as DispatchRecordInput, r as DispatchTrace, p as Dispatcher, as as DispatcherContext, at as DragSample, au as DroppedCandidate, av as Eligibility, aw as EligibilityState, ax as GestureBinding, ay as GestureKitSettings, az as HandleKind, aA as HitShape, aB as HotkeyTrigger, aC as INGEST_STRING_MIMES, aD as ImmediateInvoker, aE as InvocationCtx, aF as Invoker, aG as KEYMAP_HOLD, i as KernelOverlay, aH as KeyBinding, aI as KeyReach, aJ as KeymapDef, K as KeymapDescription, aK as KeymapRow, aL as KeymapStack, aM as KeymapUnbound, aN as KeymapVerdict, L as LongPressOptions, aO as LongPressState, aP as LongPressStore, aQ as MatchOutcome, aR as MatchResult, g as MenuDef, aS as MenuHit, M as MenuHost, aT as MenuOpenRequest, aU as MenuSources, aV as MenuWhen, aW as ModeShortcutHandlers, aX as ModeSwitchLogEntry, aY as ModifierRole, aZ as ModifierRoles, a_ as ModifierState, a$ as NEVER, N as NodeId, b0 as OngoingHandle, b1 as OngoingInvoker, b2 as OngoingOverlay, b3 as OpenKeymap, b4 as OpenMenu, O as OverlayPosition, b5 as OverlayRole, b6 as OverlaySchema, b7 as OwnedMenuDef, b8 as PREDICATE_TARGET, b9 as PendingLongPress, ba as PlacedBy, bb as Point2, bc as PointerSession, bd as PointerSessionCallbacks, be as PointerSessionCancelReason, bf as PointerSessionOptions, bg as RankedCandidate, bh as RecordCandidate, bi as RegistryEntry, bj as ReservedChord, bk as ResizeAnchor, bl as ResolveAllOptions, bm as ResolveOnlyResult, bn as ResolvedBindingOverrides, bo as ResolvedCandidate, bp as RoleKeys, bq as RoleRebinds, br as Rule, R as RuleCtx, bs as ScopedBinding, bt as ScratchKey, bu as ScratchStore, bv as SelectionApi, bw as Selector, bx as SpecificityPart, by as TOOL_OFFHAND_ID, j as Tool, bz as ToolDef, bA as ToolEntry, bB as ToolKeybinding, bC as ToolModifiers, bD as ToolOffhandBindingSpec, bE as ToolPresentation, bF as ToolScopes, bG as ToolSet, bH as ToolSlot, bI as TraceLogEntry, bJ as TraceRing, bK as TunedBinding, bL as UiOngoingControl, bM as ViewportGestureKind, bN as WalkStep, bO as actionBindings, bP as actionCursor, bQ as actionItemTitle, bR as actionItems, bS as actionSettingsParams, bT as actionShortcuts, bU as actionsTagged, bV as admitIngestMime, bW as assembleEntries, bX as bindingId, bY as browserReservedChord, bZ as buildDepsFromRequires, b_ as buildRouteRegistry, b$ as buildRuleCtx, c0 as buildToolOffhandBindings, c1 as captureGesture, c2 as captureKey, c3 as clientToCanvas, c4 as clientToCanvasRect, c5 as createDepRegistry, c6 as createDispatchTrace, c7 as createDispatcher, c8 as createKeymapStack, c9 as createLongPressStore, ca as createMenuHost, cb as createTraceRing, cc as defineTool, cd as deleteScratch, ce as describeKeymap, cf as describeRule, cg as dlog, ch as dwarn, ci as evaluate, cj as evaluateActive, ck as evaluateEnabled, cl as findConflicts, cm as getScratch, cn as heldKeySpec, co as historyKey, cp as isAnchor, cq as isAnchorOrControl, cr as isBalanceGrip, cs as isBody, ct as isControlHandle, cu as isCornerWidget, cv as isDebugEnabled, cw as isEmpty, cx as isPathEditPart, cy as isResizeHandle, cz as isRotateHandle, cA as isSegment, cB as isSelectedBody, cC as isTool, cD as isToolSet, cE as isUnselectedBody, cF as itemTypesFromDataTransfer, cG as itemsFromClipboardData, cH as itemsFromDataTransfer, cI as itemsFromFiles, cJ as keySpecShortcut, cK as keymapContribution, cL as keymapLeaderBindingId, cM as keymapLeaderId, cN as keymapShortcuts, cO as keysHeld, cP as liveScope, cQ as makeToolOffhandAction, cR as matchActionItem, cS as matchBest, cT as matchSorted, cU as matchSortedWithBarred, cV as matchesKeyBinding, cW as mergeContributions, cX as mergeMenuDefs, cY as modeShortcutSpec, cZ as modeShortcuts, c_ as modifierStateOf, c$ as multiTouchGestureId, d0 as offhandKeyFor, d1 as openPointerSession, d2 as overlaysOf, d3 as overriddenBindings, d4 as pickMenu, d5 as pointerGestureId, d6 as readActionSettings, d7 as reportRouteConflicts, d8 as resolveBindingOverrides, d9 as resolveDeviceProfile, da as resolveMenu, db as resolveParams, dc as resolveSchemaMenu, dd as roleReader, de as routesForSpec, df as ruleCanHoldIn, dg as rulesExclusive, dh as scopeBindings, di as scratchKey, dj as setScratch, dk as startCarry, dl as taggedActionItems, dm as targetConsultsAffordance, dn as toolIdsOf, dp as toolSet, dq as toolSetHas, dr as tuneAction, ds as validateActionDefaultBinding, dt as validateActionId, du as withoutTools } from './index-HWqV4VxU.js';
 export { CONTROL_SELECTOR, ChannelRef, DRAG_THRESHOLD_PX, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, IngestItem, InputEvent, LONG_PRESS_MS, ModRequirement, ModifierKey, ParsedModifiers, ParsedRoute, PhaseAtom, PhaseContext, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RouteDescriptionPart, RouteFieldName, RouteTermLabel, activatesFocusedControl, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, focusedControlOwnsKey, formatPhaseAtom, formatRoute, getGestureDescriptor, isEditableTarget, isInControlWithin, isKnownGestureName, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, parseRoute, pastDragThreshold, routeGestureForSpecKind, specKindForRouteGesture, specificity } from '@weasel-js/gestures';
 export { SelectionExtendKey, SelectionMode } from '@weasel-js/select';
 export { View } from '@weasel-js/geom';