@weasel-js/core 0.5.1 → 0.7.0

package/dist/index-DZBYMsHI.d.ts

@@ -1,1555 +0,0 @@
-import { N as NodeId } from './types-Cpb4hii1.js';
-import { Op } from '@weasel-js/history';
-import * as React from 'react';
-import { ReactElement } from 'react';
-import { V as View } from './view-DSQgxBJB.js';
-import { A as ActionBehavior, M as ModifierState, c as ResizeAnchor } from './types-BjUi2vA-.js';
-import { B as Bounds } from './fitViewToBounds-evGsnR8Q.js';
-import { D as DrawCommand, F as FillStyle, a as Stroke } from './DrawCommand-Dl0bXNfS.js';
-import { D as DebugSink } from './types-BJ8_cyT7.js';
-import { GestureSpec, ModifierCombo, GestureName, ParsedModifiers, ChannelRef, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, ModRequirement, ModifierKey, ParsedRoute, PhaseAtom, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RouteDescriptionPart, RouteFieldName, RouteTermLabel, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, mods, parseRoute } from '@weasel-js/gestures';
-import { CapabilityTag } from '@weasel-js/modes';
-
-/**
- * Selection click policy. `single` always replaces; `multi` toggles when the
- * configured extend key is held, otherwise replaces.
- */
-type SelectionMode = 'single' | 'multi';
-/** Modifier key used to extend the selection in `multi` mode. */
-type SelectionExtendKey = 'shift' | 'meta' | 'ctrl';
-/** API returned by {@link useSelection}. */
-interface SelectionApi {
-    /** Current selection. Re-renders trigger when this reference changes. */
-    current: readonly NodeId[];
-    /** Imperative read for use inside event callbacks (avoids stale closures). */
-    get(): NodeId[];
-    /** Replace selection. */
-    set(ids: NodeId[]): void;
-    /** Add id (multi-mode appends; single-mode replaces). */
-    add(id: NodeId): void;
-    /** Remove id from selection. */
-    remove(id: NodeId): void;
-    /** Toggle id in/out of selection. */
-    toggle(id: NodeId): void;
-    /** Clear selection. */
-    clear(): void;
-    /** True if id is selected. */
-    contains(id: NodeId): boolean;
-    /**
-     * Apply a click to the selection per the configured mode/extend key.
-     * - `single`: replaces selection with `[id]`, regardless of modifiers.
-     * - `multi`: with the extend key held, toggles `id` in/out of the selection;
-     *   otherwise replaces with `[id]`.
-     */
-    applyClick(id: NodeId, modifiers: {
-        shift: boolean;
-        meta: boolean;
-        ctrl: boolean;
-    }): void;
-    /** Pre-built methods for spreading into an adapter that needs them. */
-    adapterMethods: {
-        getSelection: () => NodeId[];
-        setSelection: (ids: NodeId[]) => void;
-    };
-}
-/** Options for {@link useSelection}. */
-interface UseSelectionOptions {
-    /** Default `'single'`. */
-    mode?: SelectionMode;
-    /** Default `'shift'`. Ignored in single-mode. */
-    extend?: SelectionExtendKey;
-    /** Default `[]`. */
-    initial?: readonly NodeId[];
-    /** When `true`, every mutator (`set`/`add`/`remove`/`toggle`/`clear`/
-     *  `applyClick`) is a no-op — selection stays at whatever `initial`
-     *  pinned it to. Useful for demos that exist to showcase a single
-     *  pre-selected node (e.g. the bezier-edit curve) and don't want a
-     *  stray click to deselect. */
-    lock?: boolean;
-}
-/**
- * Default implementation of the `getSelection` / `setSelection` adapter
- * contract every action hook (delete, duplicate, nudge, group, ...) requires.
- *
- * Owns selection state, exposes a click-policy helper (single vs multi with
- * an extend key), and pre-builds the two adapter methods consumers otherwise
- * hand-roll in every demo:
- *
- * ```tsx
- * const selection = useSelection({ mode: 'multi' });
- * const adapter = { ...arrayAdapter({...}), ...selection.adapterMethods };
- * ```
- */
-declare function useSelection(opts?: UseSelectionOptions): SelectionApi;
-
-/** Returned from a continuation closure or action handler. */
-type Result<TScratch> = {
-    kind: 'apply';
-    ops: Op[];
-    label?: string;
-} | {
-    kind: 'begin';
-    spec: BeginSpec<TScratch>;
-} | {
-    kind: 'hold';
-    scratch: TScratch;
-} | {
-    kind: 'commit';
-    ops: Op[];
-    label?: string;
-} | {
-    kind: 'cancel';
-} | {
-    kind: 'claim';
-} | {
-    kind: 'none';
-};
-/** Spec for `begin()` — opens engaged phase with continuation handlers. */
-interface BeginSpec<TScratch> {
-    scratch: TScratch;
-    thresholdPx?: number;
-    onMove?: (ctx: ToolCtx<TScratch>, event?: PointerEvent) => Result<TScratch>;
-    onRelease?: (ctx: ToolCtx<TScratch>, event?: PointerEvent) => Result<TScratch>;
-    onCancel?: (ctx: ToolCtx<TScratch>) => void | Result<TScratch>;
-}
-declare function apply<TScratch>(ops: Op[], label?: string): Result<TScratch>;
-declare function begin<TScratch>(spec: BeginSpec<TScratch>): Result<TScratch>;
-declare function hold<TScratch>(scratch: TScratch): Result<TScratch>;
-declare function commit<TScratch>(ops: Op[], label?: string): Result<TScratch>;
-declare function cancel<TScratch>(): Result<TScratch>;
-declare function claim<TScratch>(): Result<TScratch>;
-declare function none<TScratch>(): Result<TScratch>;
-
-/** A 2D point in either world or screen coordinates. */
-interface Point2 {
-    x: number;
-    y: number;
-}
-/**
- * Information about which UI affordance was hit at pointerdown.
- *
- * Populated by the dispatcher when the `affordanceAt` thunk is provided to
- * `useGestureDispatcher`. Tools / action invokers that only fire on a specific
- * affordance (e.g. a resize handle) use this field as a guard — if the
- * affordance is absent or is the wrong kind, they return `{}` and let other
- * bindings handle the drag.
- *
- * `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.
- *
- * `fixedPoint` is the world-space point that should remain stationary during
- * the gesture. For resize handles this is the opposite (diagonally fixed)
- * corner; for rotate it is the pivot.
- *
- * `targetIds` are the node ids this affordance belongs to.
- */
-interface AffordanceHit$1 {
-    /** Discriminator string, e.g. `'handle:bottom-right'`. */
-    kind: string;
-    /** 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 when `kind` matches `'handle:*'`. Identifies which corner stays
-     *  fixed during a resize so consumers (resizeAction) don't re-parse `kind`.
-     *  Other affordance kinds (rotate-handle, anchor:N, controlIn:N, controlOut:N)
-     *  leave this undefined. */
-    anchor?: ResizeAnchor;
-    /** CSS cursor to show while the pointer hovers this affordance (no
-     *  gesture in flight). Consumed by the hover-cursor pump in
-     *  `useGestureDispatcher`; unset = the pump falls through to
-     *  action-cursor prediction, then to the active tool's cursor. */
-    cursor?: string;
-}
-/** 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;
-    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.
-         *
-         * Populated when the dispatcher received `clientX`/`clientY` on the
-         * underlying pointer events. Absent for legacy callers that don't
-         * provide them.
-         */
-        screenDelta?: Point2;
-        affordance?: AffordanceHit$1;
-        /**
-         * Full pointermove history for the current drag, in world space.
-         * Accumulated by the dispatcher on every `pointermove` pump event.
-         * Available only during `onMove` and `onEnd` calls (not on `start`).
-         * Used by `lassoSelectAction` to build its polygon vertex list.
-         */
-        points?: Point2[];
-    };
-    wheel?: {
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-    };
-    multiTouch?: {
-        centroid: Point2;
-        spread: number;
-        rotation: number;
-        /**
-         * Pinch-zoom geometry. Populated by the dispatcher when a multitouch
-         * handle is in flight and a pointermove-pump fires.
-         * `startSpread` is the spread at the moment the gesture began.
-         * `currentSpread` is the spread at the current frame.
-         */
-        pinch?: {
-            startSpread: number;
-            currentSpread: number;
-            centroid: Point2;
-        };
-    };
-    key?: {
-        key: string;
-        repeat: boolean;
-    };
-    /**
-     * Per-invocation parameters. Populated by `ActionsRegistry.begin()` for
-     * UI-driven ongoing actions (color picker, opacity slider) so handles can
-     * read the current value on `start` and updated values on `onMove`. 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`. Today carries
- *  behaviors; extensible. */
-interface BindingOpts {
-    behaviors?: ActionBehavior<unknown, unknown, unknown>[];
-    /** Per-binding action parameters. The action's invoker reads
-     *  these via the second arg to `run` (or via InvocationCtx for ongoing
-     *  invokers, when needed). Loose typing (Record<string, unknown>) for
-     *  now; consider per-action typing later via BindingOpts<A>.
-     *
-     *  params may also be a thunk evaluated each time the
-     *  dispatcher (or invoker) needs the value. Thunks let tools close over
-     *  refs that mutate during a gesture (e.g. polygon `sides` adjusted
-     *  mid-drag via ArrowUp). For ongoing invokers that want the latest
-     *  values at commit, the invoker can re-call the thunk inside `onEnd`
-     *  via `resolveParams(opts?.params)`. */
-    params?: Record<string, unknown> | (() => Record<string, unknown>);
-}
-/** Convention-shaped action dependencies bag. Actions declare which
- *  contexts they consume; the dispatcher composes them per call.
- *  Consumer-side contexts (e.g. ColorContext) plug in by extending. */
-interface ActionDeps {
-    selection?: unknown;
-    view?: unknown;
-    scene?: unknown;
-    pointer?: unknown;
-    activeTool?: unknown;
-    [k: string]: unknown;
-}
-/**
- * Discriminated overlay shape returned by `OngoingHandle.overlay()`.
- * Dispatcher-side chrome surface for in-flight
- * gestures that paint non-ghost visuals. The canvas's
- * `useDispatcherOverlayLayer` walks every in-flight handle, calls
- * `overlay()`, and dispatches on `kind` to draw the appropriate shape.
- *
- * `marquee` mirrors `AreaSelectOverlay`; `lasso` mirrors `LassoSelectOverlay`.
- * `commands` is the generic escape hatch — actions emit arbitrary
- * `DrawCommand[]` for previews the typed variants can't express (insert
- * shape outlines, paste ghosts of synthetic nodes, custom chrome). World-
- * space is the default; the layer wraps in `viewToMat3` so commands track
- * the camera. Set `space: 'screen'` for projections you've already done
- * yourself (rare).
- */
-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;
-} | {
-    kind: 'commands';
-    commands: readonly DrawCommand[];
-    /** Coordinate space the commands are authored in. Default `'world'`
-     *  — the layer wraps them in `viewToMat3(view)` so they track the
-     *  camera. `'screen'` emits them as-is (CSS pixels). */
-    space?: 'world' | 'screen';
-} | {
-    /**
-     * Live insert-drag preview — dispatched by `insertAction` while the
-     * user is dragging out a new shape. Pre-commit there is no scene node
-     * to ghost via `previewIds()`/`previewPose()`, so insert paints its
-     * preview through the dispatcher overlay layer instead.
-     *
-     * `shape` is the kit's built-in insert kind. `bounds` is the AABB of
-     * the current drag (start/current normalized). `extras` is the
-     * per-kind extras the action already collected — the overlay
-     * renderer rebuilds the shape using the same path builders the
-     * commit factory uses, so the preview matches the eventual node.
-     *
-     * `extras` is opaque (`unknown`) at the union level; the overlay
-     * renderer narrows on `shape` and casts the field shape it expects.
-     */
-    kind: 'insertPreview';
-    shape: 'rect' | 'ellipse' | 'line' | 'polygon' | 'star' | 'pencil';
-    bounds: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    extras: unknown;
-    /** World-space point to paint a small "anchor" dot at. Sells the
-     *  click point as the drag's anchor — particularly useful for
-     *  radial shapes (polygon/star) where no vertex sits on the
-     *  click point, and for any shape in center mode where the dot
-     *  marks the center the shape grows around. */
-    anchorPoint?: {
-        x: number;
-        y: 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()` for chrome-visibility
-     * rules and any other surface that wants to react to "what action
-     * is currently in flight" without inspecting handles directly.
-     *
-     * Examples: `'marquee'`, `'lasso'`, `'move'`, `'resize'`, `'rotate'`,
-     * `'pan'`, `'pinch'`.
-     *
-     * Distinct from the dispatcher's internal `gestureId` (`pointer-mouse`,
-     * `key-held-Space`, etc.) which keys per-pointer state and is not
-     * meaningful to consumers.
-     *
-     * When omitted, the action is "anonymous" — `getActiveAction().kind`
-     * reports `null` even though a handle is in flight. This is fine for
-     * actions that don't have visible chrome of their own.
-     */
-    kind?: string;
-    onMove?(ctx: InvocationCtx): void;
-    onEnd?(ctx: InvocationCtx, reason: 'commit' | 'cancel'): void;
-    /**
-     * Optional preview surface — dispatcher-side ghost overlay.
-     *
-     * An ongoing-action implementation may populate `previewIds()` +
-     * `previewPose(id)` to expose its in-flight preview state for the
-     * canvas's preview-ghost layer (`usePreviewGhostLayer`) to render on
-     * top of the committed scene during the gesture.
-     *
-     * Returning `null` (or omitting the method entirely) means "no preview
-     * this gesture" — the canvas will skip this handle as a source.
-     *
-     * Semantics mirror the tool-side `Tool.previewIds` / `Tool.previewPose`
-     * pair: `previewIds()` enumerates the displaced node ids; `previewPose(id)`
-     * returns the interim pose for one of those ids (shape opaque — the
-     * canvas casts to its `TPose` parameter). The preview-ghost layer
-     * merges all sources via first-non-null semantics, with tool-side
-     * previews taking precedence over dispatcher-side (preserves
-     * backwards-compat during the registry-unification migration).
-     */
-    previewIds?(): Iterable<string> | null;
-    previewPose?(id: string): unknown | null;
-    /**
-     * When `false`, the preview-ghost layer paints the ghost AND the
-     * source node stays visible at its committed pose. Defaults to
-     * `true` (move/resize/rotate semantics: ghost replaces the source
-     * during the gesture). Clone overrides to `false` so the original
-     * stays put and the ghost appears at the drag target.
-     */
-    previewHidesSource?: boolean;
-    /**
-     * Optional per-id preview *data*. Falls back to the committed
-     * `node.data` when null/absent. Use when the gesture mutates
-     * `node.data` (e.g. anchor-edit on nodes that store the polygon on
-     * `data.path`) rather than (or in addition to) the pose. The preview-
-     * ghost layer assembles a synthetic node from `{ ...node, pose:
-     * previewPose ?? node.pose, data: previewData ?? node.data }` before
-     * calling the scene slot's `drawOne`.
-     *
-     * Sources compose first-non-null per axis: an action can emit only
-     * `previewPose` (translation), only `previewData` (data-only edit),
-     * or both (pose + data both change, e.g. anchor drag on a data.path
-     * node where the bounds shift).
-     */
-    previewData?(id: string): unknown | null;
-    /**
-     * Optional chrome surface — dispatcher-side overlay layer.
-     *
-     * An ongoing-action implementation may populate `overlay()` to expose a
-     * non-ghost visual (marquee rectangle, lasso polyline) for the canvas's
-     * `useDispatcherOverlayLayer` to paint while the gesture is in flight.
-     * Returning `null` (or omitting the method) means "no overlay this
-     * gesture" — the canvas will skip this handle as a chrome source.
-     *
-     * Distinct from the `previewIds()`/`previewPose(id)` ghost surface,
-     * which paints displaced scene-node silhouettes. Marquee and lasso
-     * gestures don't displace any node, but still need on-screen feedback.
-     */
-    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. When
-     *  invoked via the legacy `Action.run` bridge or from the command palette
-     *  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. Future variants
- *  (`longPress`, `twoStage`, `modal`) extend this union without touching
- *  the `Action` type. */
-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.
- *
- * See `docs/superpowers/specs/2026-05-16-registry-unification-design.md`.
- */
-
-interface GestureBinding {
-    spec: GestureSpec;
-    actionId: string;
-    opts?: BindingOpts;
-}
-
-/**
- * Configurable activation-key descriptor for tools that expose their
- * keybinding to the host (currently Lasso and Eyedropper). Captures
- * only the fields meaningful to a caller-supplied tool-select key —
- * dispatcher-internal fields (`skipInEditable`, `enabled`,
- * `preventDefault`) live on `KeyBinding` in keyHelpers.ts and are
- * not part of the configurable surface.
- */
-interface ToolKeybinding {
-    /** Key or list of keys to match (case-insensitive against `event.key`). */
-    key: string | readonly string[];
-    /** Require Cmd (mac) / Ctrl (others). Default `false`. */
-    mod?: boolean;
-    /** Require Alt. Default `false`. */
-    alt?: boolean;
-    /**
-     * Shift policy. `undefined`/`false` forbids shift, `true` requires
-     * shift, `'optional'` allows either.
-     */
-    shift?: boolean | 'optional';
-}
-type ActionFn<TScratch> = (ctx: ToolCtx<TScratch>, event?: PointerEvent | KeyboardEvent | WheelEvent) => Result<TScratch>;
-type ModifierRoute<TScratch> = Partial<Record<ModifierCombo, ActionFn<TScratch>>>;
-type RouteEntry<TScratch> = ActionFn<TScratch> | ModifierRoute<TScratch>;
-type RouteTable<TScratch> = Partial<Record<string, RouteEntry<TScratch>>>;
-/** Map from key-route string (e.g. `"ArrowDown"`, `"ArrowDown?shift"`) to
- *  action. Parsed by the reflection emitter and dispatcher. */
-type KeyRouteTable<TScratch> = Partial<Record<string, ActionFn<TScratch>>>;
-/** Wheel direction sub-table. Keys: `'up' | 'down' | '*'`. Function form
- *  is sugar for `{ '*': fn }` (matches both directions). */
-type WheelTable<TScratch> = Partial<Record<'up' | 'down' | '*', ActionFn<TScratch>>>;
-/** MultiTouch tap fingers sub-table. Keys: `'2' | '3' | '4'`. */
-type MultiTouchTapTable<TScratch> = Partial<Record<'2' | '3' | '4', ActionFn<TScratch>>>;
-interface PhaseDef<TScratch> {
-    click?: RouteTable<TScratch>;
-    /** Pre-threshold classifier route. Runs synchronously on pointerdown,
-     *  before the dispatcher distinguishes click vs. drag. Use this for
-     *  classification gestures that need to mutate scratch *before* the
-     *  drag pipeline starts — e.g. select tool determining whether a hit
-     *  belongs to the existing selection ("drag will move all") or not
-     *  ("drag will move just this one").
-     *
-     *  Semantics:
-     *  - Return `begin(spec)` to open engaged phase with scratch. The
-     *    spec's `onMove`/`onRelease` will fire if the dispatcher escalates
-     *    to drag; otherwise the next click handler runs normally with the
-     *    prepared scratch visible.
-     *  - Return `apply(ops)` or `commit(ops)` to finish the gesture
-     *    immediately (rare).
-     *  - Return `none()` or omit to pass through to threshold-gated
-     *    click/drag classification.
-     *
-     *  Predates the imperative
-     *  `pointer.onDown` channel that useSelectTool used earlier. */
-    pointerDown?: RouteTable<TScratch>;
-    dblTap?: RouteTable<TScratch>;
-    /** Right-click route table. Mirrors `click` semantics — keyed by hit-test
-     *  target, modifier-aware. The dispatcher calls `preventDefault()` on the
-     *  underlying `contextmenu` DOM event so tools fully own the menu. */
-    contextMenu?: RouteTable<TScratch>;
-    drag?: RouteTable<TScratch> | ActionFn<TScratch>;
-    wheel?: WheelTable<TScratch> | ActionFn<TScratch>;
-    keyDown?: KeyRouteTable<TScratch>;
-    keyUp?: KeyRouteTable<TScratch>;
-    /** Multi-finger tap. Synthesized by the dispatcher when a multitouch
-     *  gesture releases without movement past the tap threshold. Keys: the
-     *  fingers count as a string (`'2'`, `'3'`, `'4'`). */
-    multiTouchTap?: MultiTouchTapTable<TScratch>;
-    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
-    /** Optional overlay layer rendered while the tool is in any active slot
-     *  (active, hotkey, or ambient). The factory evaluates the thunk once
-     *  at translation time and emits the resulting RenderLayer on
-     *  Tool.overlay. The layer's `draw` closure should read dynamic state
-     *  (scratch, controller overlay snapshots) via refs/closures captured
-     *  in the enclosing render scope — same pattern hand-rolled
-     *  tools use today.
-     *
-     *  Function form rather than a direct RenderLayer so consumers can
-     *  defer construction until inside a `useMemo` factory body, where
-     *  `useRef`-backed values are stable. Symmetric with `cursor`'s
-     *  function form.
-     *
-     *  Note: only `initial.overlay` is read. If `engaged.overlay`
-     *  is set, it is ignored — phase-specific overlay routing is a future
-     *  enhancement. Tools that need engagement-aware previews should gate
-     *  inside the single overlay's `draw` body via `if (!scratch.somefield)
-     *  return []`, which is how every hand-rolled tool already
-     *  does it. */
-    overlay?: () => RenderLayer<unknown>;
-    /** Modal-claim predicate. When this resolves to `true`, the dispatcher
-     *  routes every pointerdown to this tool and bypasses the affordance-layer
-     *  hit-test pipeline — used by tools in modal states (pen mid-path, text
-     *  mid-edit) where affordance hits would otherwise interrupt the
-     *  in-progress gesture.
-     *
-     *  Function form receives the live ToolCtx (scratch, view, modifiers,
-     *  target). Boolean form is sugar for `() => true` / `() => false` —
-     *  use the function form when the decision depends on scratch state
-     *  (e.g. `(ctx) => ctx.scratch?.midPath === true`).
-     *
-     *  Resolved per-call by the factory — the function fires on every
-     *  pointerdown the dispatcher considers handing to this tool. Keep it
-     *  cheap (no allocations, just a scratch read). */
-    claimsAll?: boolean | ((ctx: ToolCtx<TScratch>) => boolean);
-}
-interface ToolDef<TScratch = void> {
-    id: string;
-    /** Capability tags for modality eligibility. Forwarded onto `Tool.capabilities`. */
-    capabilities?: CapabilityTag[];
-    /** 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.
-     *  Introspection-only — do not make this load-bearing in production.
-     *  Read off the def via `Tool.def` (the reflection escape hatch). */
-    hookName?: string;
-    presentation?: ToolPresentation<TScratch>;
-    /** Optional caller-supplied activation key. Most built-in tools have their
-     *  activation key declared in `BUILTIN_SELECT_KEYS` in `useKeybindings.ts`;
-     *  this field is for tools that want their activation key to be
-     *  configurable by the host (currently Lasso and Eyedropper). The dynamic
-     *  loop in `useKeybindings.ts` picks this up and appends a binding entry
-     *  to the consolidated `tool.activate` action (with `opts.params.toolId`
-     *  set so the invoker knows which tool to switch to). */
-    keybinding?: ToolKeybinding;
-    /** Declarative held-key trigger (reflection / inspector only). When set,
-     *  signals to the host that this tool can engage via a held key; the host
-     *  must register the activation via the consolidated `tool.offhand` action
-     *  (`makeToolOffhandAction` + `buildToolOffhandBindings`). Built-in tools
-     *  declare held keys in `BUILTIN_OFFHAND_ACTIONS`; configurable-hotkey
-     *  tools rely on the host to wire the binding. Setting this field does NOT
-     *  automatically engage the held-key behavior. */
-    hotkey?: HotkeyTrigger;
-    onActivate?: (ctx: ToolCtx<TScratch>) => void;
-    onDeactivate?: (ctx: ToolCtx<TScratch>) => void;
-    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
-    /** Override the default scratch initializer. Default is `() => null`
-     *  cast to `TScratch`, which works for tools whose scratch is fresh
-     *  every gesture. Tools that need scratch identity to survive across
-     *  gesture boundaries (e.g. the pen tool's multi-click subpath state)
-     *  pass a stable-ref-returning thunk here. The factory forwards this
-     *  onto the returned `Tool.initScratch`. */
-    initScratch?: () => TScratch;
-    /** Optional hit-test override. Mirrors `Tool.hitOverride` — see that
-     *  field for full semantics. The factory forwards this directly onto the
-     *  returned Tool. */
-    hitOverride?: (ctx: {
-        worldX: number;
-        worldY: number;
-        scratch: TScratch;
-        view: View;
-        modifiers: ToolModifiers;
-    }) => {
-        target: string;
-        extra?: unknown;
-    } | null;
-    /** Declarative gesture-bindings forwarded onto `Tool.bindings`.
-     *  The new dispatcher consults these while this tool is active. */
-    bindings?: GestureBinding[];
-    initial: PhaseDef<TScratch>;
-    engaged?: PhaseDef<TScratch>;
-}
-/** Viewport-tool spec — strict subset of ToolDef. Drops click/dblTap,
- *  narrows drag to plain ActionFn. Mechanically derived via Pick/Omit
- *  so the subset relationship is compiler-enforced. */
-type ViewportPhaseDef<TScratch = void> = Pick<PhaseDef<TScratch>, 'wheel' | 'keyDown' | 'keyUp' | 'cursor' | 'overlay' | 'claimsAll'> & {
-    drag?: ActionFn<TScratch>;
-};
-type ViewportToolDef<TScratch = void> = Omit<ToolDef<TScratch>, 'initial' | 'engaged'> & {
-    initial: ViewportPhaseDef<TScratch>;
-    engaged?: ViewportPhaseDef<TScratch>;
-};
-
-/** Common payload for any hit that references a scene node. */
-interface NodeRef {
-    id: NodeId;
-    pose: unknown;
-    data: unknown;
-    meta?: Record<string, unknown>;
-}
-/** No hit — pointer landed on the background. */
-interface EmptyHit {
-    category: 'empty';
-    kind: 'empty';
-}
-/** Hit on a scene node's body. */
-interface NodeHit extends NodeRef {
-    category: 'node';
-    kind: string;
-}
-/** Hit on a node's affordance chrome (handle, anchor, etc.). */
-interface AffordanceHit extends NodeRef {
-    category: 'affordance';
-    kind: string;
-}
-/** Hit on a tool-defined target (anchor, handle, segment, etc.) supplied
- *  via the tool's `hitOverride`. The `kind` string is the tool's own
- *  vocabulary; the dispatcher does not interpret it. */
-interface ToolHit {
-    category: 'tool';
-    kind: string;
-    extra?: unknown;
-}
-/** Full discriminated union — every routed action's `ctx.target`. */
-type HitResult = EmptyHit | NodeHit | AffordanceHit | ToolHit;
-/** Convenience: any hit that references a node (i.e., not EmptyHit). */
-type NodeRefHit = NodeHit | AffordanceHit;
-
-/** Phase the route was resolved against. Mirrors the spec's two-phase
- *  vocabulary — `initial` (idle, scratch null) or `engaged` (mid-gesture). */
-type RoutePhase = 'initial' | 'engaged';
-/** Gesture channel the route fired on. */
-type RouteGesture = GestureName;
-/** Snapshot of one route resolution, emitted by the factory on each
- *  successful lookup. Captured by the dispatcher as the "last resolved
- *  route" for debug-overlay consumers. */
-interface RouteResolvedInfo {
-    toolId: string;
-    phase: RoutePhase;
-    gesture: RouteGesture;
-    /** Argument captured at match time for arg-bearing gestures
-     *  (`wheel` direction, `keyDown`/`keyUp` key, `multiTouchTap` fingers).
-     *  Undefined for no-arg gestures. */
-    arg: string | undefined;
-    /** Route-table key that matched (post-precedence). E.g. 'rect:selected',
-     *  '*:selected', 'rect', '*', 'empty'. For function-form `drag` (no
-     *  table), this is '*'. For keyDown/keyUp, it's the key name ('Escape',
-     *  'Enter', etc.). */
-    matchedKey: string;
-    modifiers: ModifierCombo;
-    /** The full HitResult at resolution time (snapshot — safe to read). */
-    target: HitResult;
-    /** Monotonic timestamp (ms since page load via performance.now()).
-     *  Used for "resolved Nms ago" displays. */
-    timestamp: number;
-}
-/** Render-friendly one-line string. Used by ToolDebugOverlay; exported
- *  so non-React consumers can format the same way. */
-declare function formatRouteResolved(info: RouteResolvedInfo): string;
-
-/** Outcome of a channel handler. `'claim'` stops dispatch for this event;
- *  `'pass'` lets the next slot try. Handlers that return nothing are
- *  treated as `'pass'`. */
-type Decision = 'claim' | 'pass' | void;
-/** Modifier-key snapshot at event dispatch time. `space` is included
- *  because tools commonly use space as a hotkey-slot trigger and may
- *  also want to read it as a flag mid-gesture. */
-interface ToolModifiers {
-    alt: boolean;
-    shift: boolean;
-    meta: boolean;
-    ctrl: boolean;
-    space: boolean;
-}
-/** Per-event context passed to every channel handler. `scratch` is typed
- *  via the tool's `TScratch` parameter; it survives across a single
- *  gesture (pointer-down through end/cancel) and is replaced on next
- *  gesture start by `initScratch()`. */
-interface ToolCtx<TScratch = unknown> {
-    worldX: number;
-    worldY: number;
-    modifiers: ToolModifiers;
-    /** Hit-test result for the current event. Populated by the dispatcher
-     *  before each handler call. Tools that don't use declarative routing
-     *  can ignore this. Optional for migration; will become
-     *  required once the routing migration is complete. */
-    target?: HitResult;
-    selection: SelectionApi;
-    /** Adapter/scene access — opaque at this layer; tools that need it
-     *  cast to a known shape. This layer doesn't constrain it. */
-    adapter: unknown;
-    applyOps: (ops: Op[], label: string) => void;
-    /** Current viewport. Reflects camera-position semantics — see
-     *  `View` JSDoc. */
-    view: View;
-    /** Mutate the viewport. In controlled mode this calls the consumer's
-     *  `onViewChange`; in uncontrolled mode it updates Canvas's internal
-     *  state. View changes are not undoable. */
-    setView: (next: View) => void;
-    /** Bounding rect of the canvas element in viewport coords. Used by
-     *  zoom/pan tools to convert event clientX/clientY to canvas-relative
-     *  anchors. */
-    canvasRect: DOMRect;
-    /** Screen-space pointer coords relative to `canvasRect`. Useful for
-     *  viewport tools that pan/zoom in screen space (e.g. hand-pan
-     *  computes deltas in pixels, not world units). Optional — populated
-     *  by the dispatcher on pointer events; absent on keyboard events. */
-    screenPoint?: {
-        x: number;
-        y: number;
-    };
-    /** Optional debug sink. When `<Canvas debug={...}>` is enabled, Canvas
-     *  threads its sink here so tool-internal hit math (handle hitboxes,
-     *  rotation handle, etc.) lands in the same overlay as Canvas's own
-     *  bounds/origin records. Tools should call this conditionally with `?.`. */
-    debug?: DebugSink;
-    /** Kit-internal: route-resolution reporter. The dispatcher populates
-     *  this; the declarative routing factory calls it after each successful
-     *  resolveRoute() hit so the dispatcher can publish the last-resolved
-     *  snapshot to debug-overlay consumers. Underscore prefix signals
-     *  "do not consume in tool code." */
-    __reportRoute?: (info: RouteResolvedInfo) => void;
-    scratch: TScratch;
-}
-interface PointerChannel<TScratch> {
-    onDown?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-    onClick?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-}
-interface DragChannel<TScratch> {
-    onStart?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-    onMove?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-    onEnd?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-    onCancel?: (ctx: ToolCtx<TScratch>) => void;
-}
-interface KeyboardChannel<TScratch> {
-    onDown?: (e: KeyboardEvent, ctx: ToolCtx<TScratch>) => Decision;
-    onUp?: (e: KeyboardEvent, ctx: ToolCtx<TScratch>) => Decision;
-}
-interface WheelChannel<TScratch> {
-    onWheel?: (e: WheelEvent, ctx: ToolCtx<TScratch>) => Decision;
-}
-/** Double-tap (double-click) channel. Fires on the pointerup of the second
- *  sub-threshold tap when it follows a previous sub-threshold tap within the
- *  dispatcher's `dblTap.windowMs` and `dblTap.maxDistance` (CSS px). The
- *  scratch handed to the handler is fresh — `dblTap` is not part of a drag
- *  pipeline, so `initScratch()` runs immediately before the call. A `'claim'`
- *  return suppresses the regular `pointer.onClick` for this gesture. */
-interface DblTapChannel<TScratch> {
-    onTap?: (e: PointerEvent, ctx: ToolCtx<TScratch>) => Decision;
-}
-/** Hotkey-slot trigger key. The slot is engaged while this key is held —
- *  hence "hotkey": active as long as the key is hot. `null` (or omitted)
- *  means the tool is not eligible for the hotkey slot. */
-type HotkeyTrigger = 'space' | 'alt' | 'ctrl' | 'meta' | 'shift';
-/** World-space AABB shape used by `previewBounds`. Alias of the kit-wide
- *  `Bounds` type — the optional `rotation` field carries through so a tool
- *  can report an oriented preview rect (e.g. mid-rotate). */
-type ToolBounds = Bounds;
-/** 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. The top-level `Tool.cursor` field below is
- *  already plumbed through `<Canvas>` to `style.cursor` on the host. */
-interface ToolPresentation<TScratch = unknown> {
-    /** Human-readable label, distinct from the `id`. Falls back to `id`. */
-    label?: string;
-    /** Inline-SVG icon component output. May be a static `ReactNode` or a
-     *  function of scratch state (rare; useful for shape-aware affordances). */
-    icon?: React.ReactNode | ((scratch?: TScratch) => 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;
-}
-/** Full Tool record. */
-interface Tool<TScratch = unknown> {
-    id: string;
-    /**
-     * App-level capability tags for modality. The `weasel-modes` package's
-     * `eligibleForMode(mode, capabilities)` predicate consumes these to decide
-     * whether the tool is usable in the active mode. Tags are extensible
-     * strings — apps can define their own. Untagged tools are treated as
-     * ineligible by all modes except those whose `allows` list includes
-     * every implicit-or-declared tag (i.e. `normal` in the default preset).
-     */
-    capabilities?: CapabilityTag[];
-    /** Optional caller-supplied key. Most built-in tools have their activation
-     *  key declared in `BUILTIN_SELECT_KEYS` in `useKeybindings.ts`; this field
-     *  is for tools that want their activation key to be configurable by the
-     *  host (currently Lasso and Eyedropper). The dynamic loop in
-     *  `useKeybindings.ts` picks this up and appends a binding entry to the
-     *  consolidated `tool.activate` action (with `opts.params.toolId` set so
-     *  the invoker knows which tool to switch to). */
-    keybinding?: ToolKeybinding;
-    initScratch?: () => TScratch;
-    onActivate?: (ctx: ToolCtx<TScratch>) => void;
-    onDeactivate?: (ctx: ToolCtx<TScratch>) => void;
-    pointer?: PointerChannel<TScratch>;
-    drag?: DragChannel<TScratch>;
-    keyboard?: KeyboardChannel<TScratch>;
-    wheel?: WheelChannel<TScratch>;
-    /** Double-tap channel — fires when two sub-threshold taps land within
-     *  `dblTap.windowMs` / `dblTap.maxDistance` of each other. Lets tools
-     *  enter modal modes (e.g. select → edit-anchors) without consumers
-     *  attaching `onDoubleClick` to a wrapper DOM node. */
-    dblTap?: DblTapChannel<TScratch>;
-    /**
-     * State-aware predicate. When true, this tool claims every pointerdown
-     * and bypasses the affordance layer hit-test pipeline. Used by tools
-     * in modal states (pen mid-path, text mid-edit) where affordance hits
-     * would otherwise interrupt the in-progress gesture.
-     *
-     * Default: undefined (treated as false). Called once per pointerdown
-     * with the tool's current ctx (scratch + view + modifiers).
-     */
-    claimsAll?: (ctx: ToolCtx<TScratch>) => boolean;
-    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
-    /** Presentation metadata for tool palettes. See `ToolPresentation`. */
-    presentation?: ToolPresentation<TScratch>;
-    /** Returns the in-flight preview pose for `id` if this tool is mid-gesture
-     *  on it; otherwise `null`. Lets `Canvas.helpersRef.getEffectivePose`
-     *  reflect live gesture state without reaching into hook internals. The
-     *  return type is `unknown` here because the Tool interface is pose-agnostic;
-     *  callers that know the pose shape (e.g. Canvas typed by `TPose`) cast at
-     *  the use site. */
-    previewPose?: (id: string) => unknown;
-    /** Returns the in-flight preview bounds for `id` if this tool is mid-gesture
-     *  on it; otherwise `null`. Optional companion to `previewPose` for tools that
-     *  can compute bounds without round-tripping through a geometry adapter. */
-    previewBounds?: (id: string) => ToolBounds | null;
-    /** Returns ids whose committed scene-render should be suppressed while this
-     *  tool is mid-gesture (e.g. cascade move's dragged + descendant ids whose
-     *  preview ghosts replace the committed pose). The standard scene slot
-     *  consults this alongside `previewPose` to avoid double-rendering. Returns
-     *  `null` when no gesture is in flight. */
-    previewIds?: () => Iterable<string> | null;
-    /** Optional overlay layer rendered on top of the scene/chrome whenever
-     *  this tool is in any active slot (active, hotkey, or ambient).
-     *  The layer's `draw` function reads from this tool's scratch via React
-     *  closure (re-evaluated each render). Return early from `draw` to render
-     *  nothing — typically gated on a scratch field like
-     *  `if (!scratch.overlay) return`. */
-    overlay?: RenderLayer<unknown>;
-    /** Declarative gesture-bindings the
-     *  dispatcher consults while this tool is active. Empty/undefined keeps
-     *  legacy imperative-channel behavior. See
-     *  `docs/superpowers/specs/2026-05-16-registry-unification-design.md`. */
-    bindings?: GestureBinding[];
-    /**
-     * Optional. When set, the dispatcher consults this before its built-in
-     * node/empty hit-test. If it returns a value, that target replaces the
-     * default `target` on the routed action's ctx. The string `target` is
-     * the tool's own vocabulary — the dispatcher does not interpret it.
-     *
-     * Used for tools that need richer sub-object hit categories (e.g., pen
-     * edit-mode's anchor/handle/segment vs the default node/empty).
-     */
-    hitOverride?(ctx: {
-        worldX: number;
-        worldY: number;
-        scratch: TScratch;
-        view: View;
-        modifiers: ToolModifiers;
-    }): {
-        target: string;
-        extra?: unknown;
-    } | null;
-    /** Reflection escape hatch: when this `Tool` was produced by `defineTool`,
-     *  the source `ToolDef` is attached here so introspection consumers
-     *  (`buildActionRegistry`, `findConflicts`, the toolkit-builder UI, the
-     *  reflection demo) can walk the declarative source rather than the
-     *  translated runtime channels. Tools constructed without `defineTool`
-     *  may leave this undefined. Typed as `unknown` to keep this file from
-     *  importing the routing types — consumers cast at the use site. */
-    def?: unknown;
-}
-/** Internal — which slot a tool occupies in the dispatch order. */
-type ToolSlot = 'hotkey' | 'active' | 'ambient';
-/** Internal alias for "a Tool of any scratch type" — used in registries and
- *  dispatchers that hold tools of heterogeneous scratch shapes. `any` is
- *  intentional: `Tool<TScratch>` is invariant in TScratch, so `Tool<unknown>`
- *  is too strict for containers that accept any concrete `Tool<T>`. */
-type AnyTool = Tool<any>;
-
-/**
- * Read-only state that affordances consult on every render and hit-test
- * call. Built once per Canvas render via `buildChromeState`; affordances
- * must not cache it across calls.
- */
-interface ChromeState {
-    /** Currently selected ids. Live; reflects useSelection's React state. */
-    readonly selection: readonly NodeId[];
-    /** True when the canvas is in multi-mode AND >= 2 ids are selected. */
-    readonly multiActive: boolean;
-    /** Bounds for any selection member id. Honors active-tool overlay state
-     *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed
-     *  pose bounds). Returns null for unknown ids or ids whose bounds aren't
-     *  computable. */
-    boundsOf(id: string): Bounds | null;
-    /** Multi-union AABB when `multiActive`. Computed lazily from `boundsOf`
-     *  over every selected id; null otherwise. */
-    readonly unionBounds: Bounds | null;
-    /** Active modifier state at the moment of the call. */
-    readonly modifiers: ModifierState;
-    /** True iff the node's pose-descriptor declares it can carry a rotation.
-     *  Affordances consult this to decide whether to expose rotate cursors /
-     *  drag-bands. Defaults to `true` when the descriptor doesn't declare
-     *  (back-compat) or when the id is unknown — the rotation gesture will
-     *  no-op visually for poses without AABB fields, but the affordance
-     *  doesn't lie about the cursor. Optional on the interface so unit-test
-     *  call sites that construct `ChromeState` by hand keep compiling;
-     *  affordances should treat an absent predicate as "true". */
-    canRotate?(id: string): boolean;
-}
-
-/**
- * @experimental
- * A single interactive piece of chrome. Pure functions; the kit composes
- * multiple affordances into a single RenderLayer per tool via
- * `composeAffordanceLayer`.
- *
- * Affordances declare interactive regions in a target's *local* frame.
- * The framework (`composeAffordanceLayer`) composes the target's bounds
- * transform (rotation around the AABB center, when present) for both paint
- * and hit-test, so the affordance never touches rotation, view.scale, or
- * world↔screen math.
- */
-interface Affordance {
-    /** Stable id for debug overlays + visibility maps. */
-    id: string;
-    /** Enumerate this affordance's interactive regions. Each region lives in
-     *  some target id's local frame (or in the world frame when `targetId`
-     *  is `null`). Returning `[]` means "no chrome for this state" (no
-     *  selection, multi-mode disabled, etc.). */
-    regions(state: ChromeState): readonly AffordanceRegion[];
-    /** Optional non-interactive decoration (e.g., a leader line drawn from
-     *  a bounds edge to a handle — visual only, not draggable). Receives
-     *  raw state + view because the decoration may live outside any single
-     *  target's local frame. Most affordances leave this undefined. */
-    decorate?(state: ChromeState, view: View): DrawCommand[];
-}
-/**
- * @experimental
- * One interactive region produced by an affordance. The framework owns
- * the local↔world transform for `targetId` (when non-null), so `shape`,
- * `paint.sizePx`, and `hitRadiusPx` are always specified in coordinates
- * the affordance can reason about directly.
- */
-interface AffordanceRegion<TScratch = unknown> {
-    /** Stable id, e.g. `corner-min-min`. Used for debug overlays + a11y. */
-    id: string;
-    /** Target id whose `state.boundsOf(targetId)` defines this region's
-     *  local frame. `bounds.rotation` (if present) is the only transform
-     *  applied — translation is the AABB origin; scale is identity. Pass
-     *  `null` for affordances anchored to the viewport / world frame
-     *  (identity transform). */
-    targetId: string | null;
-    /** Region geometry, expressed in the target's local frame.
-     *
-     *  - `point` — circular hit (`hitRadiusPx` is screen-space).
-     *  - `rect`  — axis-aligned rect (target rotation applies).
-     *  - `annulus` — outer ellipse minus inner rect cutout. Used for
-     *    invisible zones that sit *around* the AABB (e.g. rotate-on-
-     *    hover band). The outer ellipse is defined by world-space
-     *    semi-axes `rx` / `ry` around `(cx, cy)`; the inner rect is the
-     *    same target-local rect that defines the AABB. Hit-test:
-     *    inside outer ellipse AND outside inner rect. */
-    shape: {
-        kind: 'point';
-        x: number;
-        y: number;
-        hitRadiusPx: number;
-    } | {
-        kind: 'rect';
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    } | {
-        kind: 'annulus';
-        /** Outer-ellipse center (target-local). */
-        cx: number;
-        cy: number;
-        /** Outer-ellipse semi-axes (target-local). */
-        rx: number;
-        ry: number;
-        /** Inner rect (target-local) — the cutout. Typically the
-         *  selection's AABB. */
-        innerX: number;
-        innerY: number;
-        innerWidth: number;
-        innerHeight: number;
-    };
-    /** Optional paint. World position is derived from `shape` + target
-     *  transform; visual size stays in screen pixels (so handles don't
-     *  warp under zoom or non-uniform scale). Omit for hit-only regions.
-     *
-     *  - `square` — small fixed-size square (only valid over `point` shapes).
-     *  - `annulus` — fill + stroke the annulus ring (only valid over
-     *    `annulus` shapes). Uses even-odd fill rule to punch the inner-rect
-     *    cutout.
-     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
-    paint?: {
-        kind: 'square';
-        sizePx: number;
-        fill?: FillStyle;
-        stroke?: Stroke;
-    } | {
-        kind: 'annulus';
-        fill?: FillStyle;
-        stroke?: Stroke;
-        insetPx?: number;
-    } | {
-        kind: 'custom';
-        draw: (ctx: CustomPaintContext) => DrawCommand[];
-    };
-    /** Declared CSS cursor for this region. NOTE: nothing consumes this
-     *  field yet — the hover-cursor pump lives on the dispatcher pipeline
-     *  (`useGestureDispatcher`) and reads `AffordanceHit.cursor` from
-     *  `buildAffordanceAt`'s synthesized hits, which do not go through
-     *  region objects. Honoring this field is part of the pending
-     *  affordance-layer unification (see the selection-overlay note in
-     *  `docs/taxonomy.md`). */
-    cursor?: string;
-    /** Drag binding produced when this region is hit. Lazily called so
-     *  affordances don't pay binding-construction cost on every paint frame —
-     *  state snapshots (e.g., capturing per-leaf poses at click time) belong
-     *  inside `bind()`, not inside `regions()`. */
-    bind(): AffordanceBinding<TScratch>;
-}
-/** Context passed to a region's `paint.kind === 'custom'` draw callback.
- *  Provides both the world-space anchor (already transformed) and the
- *  original local shape, for affordances that want to do additional
- *  geometry themselves. */
-interface CustomPaintContext {
-    /** World-space mapping of `shape`. For `point`, only `x`/`y` are set.
-     *  For `rect`, all four fields are set. */
-    world: {
-        x: number;
-        y: number;
-        width?: number;
-        height?: number;
-    };
-    /** The original local shape (same object identity as `region.shape`). */
-    local: AffordanceRegion['shape'];
-    view: View;
-    state: ChromeState;
-}
-/**
- * @experimental
- * Result of an affordance hit — what the dispatcher wires up as the gesture.
- * Nominates the drag channel and (optionally) initial scratch state.
- */
-interface AffordanceBinding<TScratch = unknown> {
-    drag: DragChannel<TScratch>;
-    /** Initial scratch passed to drag.onStart. Lets the affordance pre-fill
-     *  state from what its region's binding already computed (anchor: 'br',
-     *  targetId: 'g1', etc.) so the tool's onStart doesn't re-derive it. */
-    initialScratch?: TScratch;
-}
-
-/**
- * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
- * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
- * supplies it explicitly so layers don't have to know about DPR.
- */
-interface Dims {
-    width: number;
-    height: number;
-}
-/**
- * A single named render sub-layer within a canvas renderer.
- *
- * @template TData - The data object passed to each draw call.
- */
-interface RenderLayer<TData> {
-    /** Unique identifier used in visibility maps and ordering arrays. */
-    id: string;
-    /** Human-readable name for UI toggles. */
-    label: string;
-    /**
-     * Emit a DrawCommand tree for the GL backend to dispatch.
-     *
-     * For world-space layers (the default), emit commands in WORLD COORDS —
-     * `drawLayers` automatically wraps them in `{ kind: 'group', transform:
-     * viewToMat3(view), ... }` before handing them to the renderer. Do NOT
-     * apply the view transform yourself.
-     *
-     * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel
-     * coords directly; `drawLayers` passes them through unchanged. If part
-     * of a screen-space layer's output needs to track the view, wrap that
-     * subset manually with `viewToMat3(view)`.
-     */
-    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
-    /**
-     * Whether the layer is shown when no explicit visibility entry exists.
-     * Defaults to `true` when absent.
-     */
-    defaultVisible?: boolean;
-    /**
-     * When true, the layer is always drawn regardless of the visibility map.
-     * Useful for layers that must never be hidden (e.g. base grid).
-     */
-    alwaysOn?: boolean;
-    /**
-     * Coordinate space the layer draws in.
-     *
-     * - `'world'` (default): the layer's `draw` returns world-space commands;
-     *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`
-     *   automatically.
-     * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)
-     *   commands; `drawLayers` passes them through unchanged. World-anchored
-     *   chrome inside a screen-space layer must call `worldToScreen` or wrap
-     *   the relevant subset with `viewToMat3(view)` manually.
-     */
-    space?: 'world' | 'screen';
-    /**
-     * Optional hit-test. When defined, the dispatcher consults this on
-     * pointerdown (top-down layer order) before falling through to the
-     * active tool's slot walk. First non-null result wins; null means
-     * "I don't claim this hit, try the next layer."
-     *
-     * Coordinates are world-space. The `data` arg is the layer's
-     * configured data slot (same as `draw`); `view` and `dims` mirror
-     * `draw`'s arguments.
-     */
-    hitTest?: (worldX: number, worldY: number, data: TData, view: View, dims: Dims, 
-    /** Chrome-caps visibility predicate. When supplied, the layer must
-     *  not return a hit from any chrome element whose id reports
-     *  `false`. Absent → every element is hittable. */
-    isVisible?: (id: string) => boolean) => AffordanceBinding | null;
-    /**
-     * Called on every pointermove when no gesture is currently captured.
-     * Lets layers (e.g. HUD widgets) track hover state without participating
-     * in the drag pipeline. Coords are world-space; the layer is responsible
-     * for any further conversion (e.g. world→screen for screen-space layers)
-     * and for its own throttling.
-     */
-    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
-    /**
-     * Called when the cursor leaves the canvas element. Lets layers clear
-     * any hover state they're holding.
-     */
-    onUncapturedLeave?: () => void;
-}
-/**
- * Walk visible layers and concatenate their emitted DrawCommand arrays into
- * one flat list, ready to feed to `WeaselRenderer.render(commands)`.
- *
- * Visibility resolution order:
- *   1. `alwaysOn` — always drawn, ignores visibility map.
- *   2. Explicit entry in `visibility` map — overrides default.
- *   3. `layer.defaultVisible` — falls back to `true` when absent.
- *
- * Transform composition: world-space layers (the default; `space` unset or
- * `'world'`) have their commands wrapped in a `kind: 'group'` with
- * `viewToMat3(view)` before they reach the renderer. Screen-space layers
- * (`space: 'screen'`) pass through unchanged.
- */
-declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims): DrawCommand[];
-
-interface SlotsState {
-    hotkey: AnyTool | null;
-    active: AnyTool | null;
-    ambient: AnyTool[];
-    /** Optional fallback tool consulted ONLY for `pointer.onClick` when neither
-     *  the active slot nor any ambient tool claimed the click. Lets a non-select
-     *  tool (pen, ellipse, etc.) stay active while letting unhandled clicks fall
-     *  through to the select tool for click-to-select. Not consulted for
-     *  pointerdown, drag, keyboard, wheel, or dblTap. */
-    fallback?: AnyTool | null;
-}
-/** @internal */
-interface ToolsDispatcherOptions {
-    /** Called on every event to read the current slot occupants. The
-     *  dispatcher keeps no copy — `useTools` owns slot state and updates
-     *  it as the user activates / engages tools. */
-    getSlots: () => SlotsState;
-    /** Called once per channel-handler invocation to construct the ctx
-     *  the handler receives. `<Canvas>` supplies world coords, modifiers,
-     *  selection, adapter, and applyOps; the dispatcher injects scratch. */
-    getCtx: (overrides?: {
-        clientX?: number;
-        clientY?: number;
-        modifiers?: {
-            alt: boolean;
-            shift: boolean;
-            meta: boolean;
-            ctrl: boolean;
-        };
-    }) => Omit<ToolCtx, 'scratch'>;
-    /** Pixel distance the pointer must travel before a click is reclassified
-     *  as a drag. Default 4. */
-    threshold?: number;
-    /** Optional callback fired whenever an in-flight gesture starts or ends
-     *  (including phase transitions pending → drag → end/cancel). `useTools`
-     *  uses this to bump a render tick so consumers reading
-     *  `dispatcher.getActiveScratch()` (e.g. function-form `cursor`) re-resolve
-     *  on real DOM events. */
-    onGestureChange?: () => void;
-    /** Called whenever a declarative route resolves to an ActionFn. The
-     *  dispatcher caches the most recent invocation; consumers read it via
-     *  `getLastRoute()`. Useful for the kit's ToolDebugOverlay. */
-    onRouteResolved?: (info: RouteResolvedInfo) => void;
-    /** Time source for double-tap detection. Defaults to `Date.now`. Override
-     *  in tests to drive the clock deterministically. */
-    now?: () => number;
-    /** Double-tap detection thresholds. */
-    dblTap?: {
-        /** Maximum interval between the two taps (ms). Default 300. */
-        windowMs?: number;
-        /** Maximum CSS-px distance between the two tap positions. Default 8. */
-        maxDistance?: number;
-    };
-    /**
-     * Optional. Returns the hit-test pipeline inputs:
-     *   - `layers`: visible RenderLayers ordered TOP-DOWN (highest z-index first).
-     *   - `chromeState`: passed as the `data` arg to each layer's hitTest call.
-     *   - `view` / `dims`: passed to layer.hitTest for screen-space conversion.
-     *
-     * When supplied, the dispatcher consults each layer's hitTest on
-     * pointerdown (top-down order) before the existing slot walk. Returns
-     * null (or omit the callback entirely) to disable the layer pipeline —
-     * legacy behavior.
-     */
-    getHitTestContext?: () => {
-        layers: readonly RenderLayer<unknown>[];
-        chromeState: ChromeState;
-        view: View;
-        dims: {
-            width: number;
-            height: number;
-        };
-        /** Chrome-caps visibility predicate, keyed by affordance id. When
-         *  supplied, the dispatcher passes it through to each layer's
-         *  `hitTest` so a hidden chrome element is also unhittable. Absent
-         *  → all affordances are hittable (legacy behavior). */
-        isVisible?: (id: string) => boolean;
-    } | null;
-    /** Optional. Returns the scene node at the given world coords, or null
-     *  for empty. The dispatcher uses this to populate `ctx.target` on
-     *  pointer events (down/move/up/click/dblTap), so declarative routing
-     *  factories can dispatch on target.kind ('rect'/'text'/'path'/'empty').
-     *  Omit to leave the dispatcher with the always-empty fallback — see
-     *  `nodeHitFor` for the rationale. */
-    getNodeAtPoint?: (worldX: number, worldY: number) => {
-        id: NodeId;
-        kind: string;
-        pose: unknown;
-        data: unknown;
-        meta?: Record<string, unknown>;
-    } | null;
-}
-interface ToolsDispatcher {
-    onPointerDown: (e: PointerEvent) => void;
-    onPointerMove: (e: PointerEvent) => void;
-    onPointerUp: (e: PointerEvent) => void;
-    onKeyDown: (e: KeyboardEvent) => void;
-    onKeyUp: (e: KeyboardEvent) => void;
-    onWheel: (e: WheelEvent) => void;
-    /** Force-cancel any in-flight gesture (used on explicit tool switch). */
-    cancelGesture: () => void;
-    /** Whether a gesture is currently in flight. Used by `useTools` to
-     *  decide whether a modifier-key press should engage the hotkey slot
-     *  (no, if mid-gesture). */
-    hasActiveGesture: () => boolean;
-    /** Scratch of the in-flight gesture, or `null` when idle. Exposed so
-     *  consumers (cursor resolution, debug overlays) can read what the active
-     *  tool is currently tracking. Read-only — do NOT mutate via this getter. */
-    getActiveScratch: () => unknown;
-    /** Most recent route resolution emitted by a declarative tool, or null
-     *  if none has fired yet. Snapshot — safe to read on every render. */
-    getLastRoute: () => RouteResolvedInfo | null;
-    /** Resolve a synthetic (phase, gesture, hit, modifiers) query against the
-     *  current slot occupants WITHOUT executing the matched action. Walks slots
-     *  in real precedence order (hotkey > active > ambient) and consults each
-     *  tool's attached `def` (the declarative `ToolDef` produced by
-     *  `defineTool`). Tools without an attached `def` (imperative-only) are
-     *  invisible to this query. Returns the first match, or null if no slot
-     *  resolves the query. Pure: no scratch mutation, no scene mutation, no
-     *  RouteResolvedInfo emission. */
-    resolveOnly: (query: ResolveQuery) => ResolveResult | null;
-}
-/** Synthetic resolution query — what the static widget asks "if a pointer
- *  event landed on `hit` with these `modifiers`, which declarative route
- *  would the dispatcher fire in this phase + gesture?" */
-interface ResolveQuery {
-    phase: 'initial' | 'engaged';
-    gesture: 'click' | 'drag' | 'pointerDown' | 'dblTap' | 'wheel';
-    hit: HitResult;
-    modifiers: ToolModifiers;
-}
-/** Successful resolution: which tool, in which slot, matched which route-table
- *  key. `matchedKey` is `'*'` for function-form drag (no table to discriminate)
- *  and for wheel routes (single ActionFn). */
-interface ResolveResult {
-    toolId: string;
-    slot: 'hotkey' | 'active' | 'ambient';
-    gesture: 'click' | 'drag' | 'pointerDown' | 'dblTap' | 'wheel';
-    phase: 'initial' | 'engaged';
-    matchedKey: string;
-}
-declare function createToolsDispatcher(opts: ToolsDispatcherOptions): ToolsDispatcher;
-
-/** Result of a successful `resolveRoute` lookup: the resolved `ActionFn`
- *  plus the route-table key that matched after precedence resolution.
- *  Consumers (currently only `defineTool`) use `matchedKey` for debug
- *  reflection — answering "why did this route fire?" by surfacing the
- *  exact post-precedence key. */
-interface RouteMatch<TScratch> {
-    action: ActionFn<TScratch>;
-    matchedKey: string;
-}
-/** Resolve a route entry to an `ActionFn` (or undefined) given the current
- *  hit-test result and modifier snapshot. Implements the four-level
- *  target precedence (exact → subkind-wildcard → base-kind → universal)
- *  and the modifier sub-table exact-match + 'default' fallback. Returns
- *  the matched route-table key alongside the action so callers can attach
- *  it to debug-overlay reflection. */
-declare function resolveRoute<TScratch>(table: RouteTable<TScratch>, hit: HitResult, modifiers: ToolModifiers): RouteMatch<TScratch> | undefined;
-
-/** Translate a declarative `ToolDef<TScratch>` into the existing imperative
- *  `Tool<TScratch>` shape. The dispatcher consumes the resulting Tool as
- *  it does today; declarative authoring is the only change. */
-declare function defineTool<TScratch = void>(def: ToolDef<TScratch>): Tool<TScratch>;
-
-/** Translate a viewport-tool spec. Viewport tools have no targets,
- *  so route tables aren't allowed — drag is a function-form ActionFn.
- *  This factory delegates to defineTool after lifting the ViewportPhaseDef
- *  shape to the more permissive PhaseDef shape (which accepts both
- *  function-form and route-table drags). */
-declare function defineViewportTool<TScratch = void>(def: ViewportToolDef<TScratch>): Tool<TScratch>;
-
-/**
- * Build an `ActionFn` that forwards `ctx` + the raw DOM event to a
- * consumer-supplied callback and claims the gesture.
- *
- * Useful for tools that want to expose an escape-hatch hook for app
- * code without losing routing: route the gesture declaratively, then
- * fall through to the consumer when the kit doesn't have a better
- * default. The consumer-payload shape is whatever the tool wants —
- * `buildPayload` produces it from `ctx` and the raw event.
- *
- * When `callbackRef.current` is null/undefined, returns `none()` so
- * the routing engine continues to the next route (e.g. an ambient
- * tool's handler).
- *
- * Typical use, inside a `useFooTool` hook:
- *
- *     const onDoubleTapRef = useRef(options.onDoubleTap);
- *     onDoubleTapRef.current = options.onDoubleTap;
- *     const forwardDblTap = forwardActionTo<FooScratch, DblTapPayload>(
- *       onDoubleTapRef,
- *       (ctx, e) => ({
- *         worldX: ctx.worldX,
- *         worldY: ctx.worldY,
- *         event: e as PointerEvent,
- *       }),
- *     );
- *     // ...later, in the route table:
- *     dblTap: { '*': forwardDblTap, empty: forwardDblTap }
- */
-declare function forwardActionTo<TScratch, TPayload>(callbackRef: {
-    readonly current: ((payload: TPayload) => void) | null | undefined;
-}, buildPayload: (ctx: Parameters<ActionFn<TScratch>>[0], event: Parameters<ActionFn<TScratch>>[1]) => TPayload): ActionFn<TScratch>;
-
-/** One row in the action registry — uniquely identifies a routing slot
- *  on one tool. Multiple rows can share (gesture, arg, target, modifiers)
- *  if different tools declare them; consumers walk the list and group
- *  client-side. */
-interface RegistryEntry {
-    toolId: string;
-    phase: RoutePhase;
-    /** Structured v3 modifier requirements. Empty object = "no modifiers
-     *  held" (the strict default). */
-    modifiers: ParsedModifiers;
-    gesture: GestureName;
-    /** Resolved arg value for arg-bearing gestures (wheel direction,
-     *  keyDown/keyUp key, multiTouchTap fingers). Undefined for gestures
-     *  whose descriptor has no `arg`. */
-    arg: string | undefined;
-    /** Route-table key for hit-test gestures (click/dblTap/drag/contextMenu/
-     *  pointerDown). Undefined when the descriptor has `hasTarget: false`. */
-    target: string | undefined;
-}
-declare function buildActionRegistry(tools: readonly ToolDef<unknown>[]): RegistryEntry[];
-
-/** Two or more tools declare the same exact (phase, gesture, arg, target,
- *  modifiers) tuple — the dispatcher's slot precedence picks one
- *  arbitrarily (well, deterministically by slot order, but the author
- *  probably didn't intend the duplication). */
-interface Conflict {
-    phase: RoutePhase;
-    gesture: RouteGesture;
-    arg: string | undefined;
-    target: string | undefined;
-    modifiers: ParsedModifiers;
-    /** All tool ids that registered the same tuple. At least 2 by
-     *  construction. Order matches the input tools[] order. */
-    toolIds: string[];
-}
-/** Detect exact-tuple overlaps across a tool registration set.
- *
- *  Intentionally NOT flagged:
- *  - Wildcard vs. specific (e.g., `click['*']` + `click['rect']`) — that's
- *    the cascading-fallback pattern; the lookup engine resolves cleanly.
- *  - Different modifier sub-keys on the same target — they fire on
- *    different inputs.
- *  - Ambient stacking where a tool returns `pass`/`none()` from its
- *    ActionFn to intentionally let another ambient tool run. We'd need
- *    to evaluate the ActionFn to detect intent; consumers can suppress
- *    known-intentional compositions in their UI layer.
- */
-declare function findConflicts(tools: readonly ToolDef<unknown>[]): Conflict[];
-
-/** Reactive snapshot of the most recently resolved route. Re-renders
- *  the consuming component whenever a new route resolves. Returns null
- *  when no route has resolved yet (or after `cancelGesture()`).
- *
- *  Pass the kit's ToolsDispatcher reference. The hook subscribes via
- *  the dispatcher's existing onRouteResolved option — if the consumer's
- *  dispatcher wasn't constructed with this hook in mind, the consumer
- *  must thread an extra subscription. (Future improvement: kit-shipped
- *  dispatcher context.) */
-declare function useToolDebugInfo(dispatcher: ToolsDispatcher): RouteResolvedInfo | null;
-
-interface ToolDebugOverlayProps {
-    /** Most recent route resolution. Pass the result of useToolDebugInfo(). */
-    info: RouteResolvedInfo | null;
-    /** Optional override for the "idle" placeholder text shown when info is null. */
-    emptyLabel?: string;
-}
-/** Dev-tools-style panel showing the most recently resolved route.
- *  Mount in a corner of the viewport (typically bottom-right). Pure
- *  presentation — no dispatcher coupling; the parent threads the info. */
-declare function ToolDebugOverlay({ info, emptyLabel, }: ToolDebugOverlayProps): ReactElement;
-
-type index_ActionFn<TScratch> = ActionFn<TScratch>;
-type index_AffordanceHit = AffordanceHit;
-type index_BeginSpec<TScratch> = BeginSpec<TScratch>;
-declare const index_ChannelRef: typeof ChannelRef;
-type index_Conflict = Conflict;
-declare const index_DescribeRouteOptions: typeof DescribeRouteOptions;
-type index_EmptyHit = EmptyHit;
-declare const index_GESTURE_DESCRIPTORS: typeof GESTURE_DESCRIPTORS;
-declare const index_GestureArgSpec: typeof GestureArgSpec;
-declare const index_GestureDescriptor: typeof GestureDescriptor;
-declare const index_GestureName: typeof GestureName;
-type index_HitResult = HitResult;
-declare const index_ModRequirement: typeof ModRequirement;
-declare const index_ModifierCombo: typeof ModifierCombo;
-declare const index_ModifierKey: typeof ModifierKey;
-type index_ModifierRoute<TScratch> = ModifierRoute<TScratch>;
-type index_NodeHit = NodeHit;
-type index_NodeRef = NodeRef;
-type index_NodeRefHit = NodeRefHit;
-declare const index_ParsedModifiers: typeof ParsedModifiers;
-declare const index_ParsedRoute: typeof ParsedRoute;
-declare const index_PhaseAtom: typeof PhaseAtom;
-type index_PhaseDef<TScratch> = PhaseDef<TScratch>;
-declare const index_RESERVED_ID_NAMES: typeof RESERVED_ID_NAMES;
-declare const index_RESERVED_ID_PREFIXES: typeof RESERVED_ID_PREFIXES;
-declare const index_ROUTE_FIELD_DEFINITIONS: typeof ROUTE_FIELD_DEFINITIONS;
-declare const index_ROUTE_TERMS: typeof ROUTE_TERMS;
-type index_RegistryEntry = RegistryEntry;
-type index_Result<TScratch> = Result<TScratch>;
-declare const index_RouteDescriptionPart: typeof RouteDescriptionPart;
-type index_RouteEntry<TScratch> = RouteEntry<TScratch>;
-declare const index_RouteFieldName: typeof RouteFieldName;
-type index_RouteGesture = RouteGesture;
-type index_RoutePhase = RoutePhase;
-type index_RouteResolvedInfo = RouteResolvedInfo;
-type index_RouteTable<TScratch> = RouteTable<TScratch>;
-declare const index_RouteTermLabel: typeof RouteTermLabel;
-declare const index_ToolDebugOverlay: typeof ToolDebugOverlay;
-type index_ToolDebugOverlayProps = ToolDebugOverlayProps;
-type index_ToolDef<TScratch = void> = ToolDef<TScratch>;
-type index_ToolKeybinding = ToolKeybinding;
-type index_ViewportPhaseDef<TScratch = void> = ViewportPhaseDef<TScratch>;
-type index_ViewportToolDef<TScratch = void> = ViewportToolDef<TScratch>;
-declare const index_apply: typeof apply;
-declare const index_begin: typeof begin;
-declare const index_buildActionRegistry: typeof buildActionRegistry;
-declare const index_cancel: typeof cancel;
-declare const index_canonicalModifiers: typeof canonicalModifiers;
-declare const index_claim: typeof claim;
-declare const index_collapseShiftPairs: typeof collapseShiftPairs;
-declare const index_commit: typeof commit;
-declare const index_defineTool: typeof defineTool;
-declare const index_defineViewportTool: typeof defineViewportTool;
-declare const index_describeRoute: typeof describeRoute;
-declare const index_describeRouteParts: typeof describeRouteParts;
-declare const index_findConflicts: typeof findConflicts;
-declare const index_formatPhaseAtom: typeof formatPhaseAtom;
-declare const index_formatRoute: typeof formatRoute;
-declare const index_formatRouteResolved: typeof formatRouteResolved;
-declare const index_forwardActionTo: typeof forwardActionTo;
-declare const index_getGestureDescriptor: typeof getGestureDescriptor;
-declare const index_hold: typeof hold;
-declare const index_isKnownGestureName: typeof isKnownGestureName;
-declare const index_mods: typeof mods;
-declare const index_none: typeof none;
-declare const index_parseRoute: typeof parseRoute;
-declare const index_resolveRoute: typeof resolveRoute;
-declare const index_useToolDebugInfo: typeof useToolDebugInfo;
-declare namespace index {
-  export { type index_ActionFn as ActionFn, type index_AffordanceHit as AffordanceHit, type index_BeginSpec as BeginSpec, index_ChannelRef as ChannelRef, type index_Conflict as Conflict, index_DescribeRouteOptions as DescribeRouteOptions, type index_EmptyHit as EmptyHit, index_GESTURE_DESCRIPTORS as GESTURE_DESCRIPTORS, index_GestureArgSpec as GestureArgSpec, index_GestureDescriptor as GestureDescriptor, index_GestureName as GestureName, type index_HitResult as HitResult, index_ModRequirement as ModRequirement, index_ModifierCombo as ModifierCombo, index_ModifierKey as ModifierKey, type index_ModifierRoute as ModifierRoute, type index_NodeHit as NodeHit, type index_NodeRef as NodeRef, type index_NodeRefHit as NodeRefHit, index_ParsedModifiers as ParsedModifiers, index_ParsedRoute as ParsedRoute, index_PhaseAtom as PhaseAtom, type index_PhaseDef as PhaseDef, index_RESERVED_ID_NAMES as RESERVED_ID_NAMES, index_RESERVED_ID_PREFIXES as RESERVED_ID_PREFIXES, index_ROUTE_FIELD_DEFINITIONS as ROUTE_FIELD_DEFINITIONS, index_ROUTE_TERMS as ROUTE_TERMS, type index_RegistryEntry as RegistryEntry, type index_Result as Result, index_RouteDescriptionPart as RouteDescriptionPart, type index_RouteEntry as RouteEntry, index_RouteFieldName as RouteFieldName, type index_RouteGesture as RouteGesture, type index_RoutePhase as RoutePhase, type index_RouteResolvedInfo as RouteResolvedInfo, type index_RouteTable as RouteTable, index_RouteTermLabel as RouteTermLabel, index_ToolDebugOverlay as ToolDebugOverlay, type index_ToolDebugOverlayProps as ToolDebugOverlayProps, type index_ToolDef as ToolDef, type index_ToolKeybinding as ToolKeybinding, type index_ViewportPhaseDef as ViewportPhaseDef, type index_ViewportToolDef as ViewportToolDef, index_apply as apply, index_begin as begin, index_buildActionRegistry as buildActionRegistry, index_cancel as cancel, index_canonicalModifiers as canonicalModifiers, index_claim as claim, index_collapseShiftPairs as collapseShiftPairs, index_commit as commit, index_defineTool as defineTool, index_defineViewportTool as defineViewportTool, index_describeRoute as describeRoute, index_describeRouteParts as describeRouteParts, index_findConflicts as findConflicts, index_formatPhaseAtom as formatPhaseAtom, index_formatRoute as formatRoute, index_formatRouteResolved as formatRouteResolved, index_forwardActionTo as forwardActionTo, index_getGestureDescriptor as getGestureDescriptor, index_hold as hold, index_isKnownGestureName as isKnownGestureName, index_mods as mods, index_none as none, index_parseRoute as parseRoute, index_resolveRoute as resolveRoute, index_useToolDebugInfo as useToolDebugInfo };
-}
-
-export { type NodeHit as $, type ActionDeps as A, type BindingOpts as B, type ChromeState as C, type Dims as D, type ToolSlot as E, createToolsDispatcher as F, type GestureBinding as G, type HotkeyTrigger as H, type Invoker as I, drawLayers as J, type KeyboardChannel as K, index as L, useSelection as M, type ActionFn as N, type OngoingHandle as O, type Point2 as P, type AffordanceHit as Q, type RenderLayer as R, type SelectionApi as S, type Tool as T, type UseSelectionOptions as U, type BeginSpec as V, type WheelChannel as W, type Conflict as X, type EmptyHit as Y, type HitResult as Z, type ModifierRoute as _, type AffordanceHit$1 as a, type NodeRef as a0, type NodeRefHit as a1, type PhaseDef as a2, type RegistryEntry as a3, type Result as a4, type RouteEntry as a5, type RouteGesture as a6, type RoutePhase as a7, type RouteResolvedInfo as a8, type RouteTable as a9, ToolDebugOverlay as aa, type ToolDebugOverlayProps as ab, type ToolDef as ac, type ViewportPhaseDef as ad, type ViewportToolDef as ae, apply as af, begin as ag, buildActionRegistry as ah, cancel as ai, claim as aj, commit as ak, defineTool as al, defineViewportTool as am, findConflicts as an, formatRouteResolved as ao, forwardActionTo as ap, hold as aq, none as ar, resolveRoute as as, useToolDebugInfo as at, type AnyTool as b, type ToolsDispatcher as c, type ToolCtx as d, type ToolsDispatcherOptions as e, type ToolKeybinding as f, type Affordance as g, type AffordanceBinding as h, type AffordanceRegion as i, type CustomPaintContext as j, type DblTapChannel as k, type Decision as l, type DragChannel as m, type ImmediateInvoker as n, type InvocationCtx as o, type OngoingInvoker as p, type OngoingOverlay as q, type PointerChannel as r, type ResolveQuery as s, type ResolveResult as t, type RouteMatch as u, type SelectionExtendKey as v, type SelectionMode as w, type ToolHit as x, type ToolModifiers as y, type ToolPresentation as z };