@weasel-js/core 1.0.1 → 1.0.3

package/dist/{index-DPI8DV0A.d.ts → registry-CxnkXbG8.d.ts}

@@ -1,19 +1,19 @@
-import { N as NodeId, R as RectPose, S as Scene } from './types-Kh_osAq9.js';
-import { M as ModifierState, A as ActionBehavior, c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior } from './types-BhJJ2OCM.js';
+import { N as NodeId, R as RectPose, S as Scene } from './types-vqxpCFVp.js';
+import { M as ModifierState, A as ActionBehavior, c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior } from './types-ByZxoD6P.js';
 import { V as View } from './view-DSQgxBJB.js';
 import { CapabilityTag } from '@weasel-js/modes';
 import * as React from 'react';
 import { MutableRefObject, ReactNode, ReactElement } from 'react';
-import { GestureSpec, IngestItem, InputEvent, ParsedModifiers, GestureName, 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, parseRoute } from '@weasel-js/gestures';
-import { B as Bounds, P as PoseProjection } from './geometry-DVeZ2i-c.js';
+import { GestureSpec, IngestItem, InputEvent } from '@weasel-js/gestures';
+import { B as Bounds, P as PoseProjection } from './geometry-5X6TrAkX.js';
 import { F as FillStyle, S as Stroke } from './paint-types-CnLIzqq1.js';
-import { D as DrawCommand } from './DrawCommand-DCmiNkBj.js';
+import { D as DrawCommand } from './DrawCommand-BbPrSTra.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { P as Path } from './path-B6MMiodD.js';
 import { Op, History } from '@weasel-js/history';
-import { L as LayoutStrategy, I as InsertAdapter } from './types-B_-khFM0.js';
+import { L as LayoutStrategy, I as InsertAdapter } from './types-DpQ0cWYC.js';
+import { D as DebugSink } from './types-BHK2dkMu.js';
 import { Mat3 } from '@weasel-js/geom';
-import { D as DebugSink } from './types-BJ8_cyT7.js';
 
 /**
  * Read-only state that affordances consult on every render and hit-test
@@ -169,6 +169,13 @@ interface AffordanceRegion<TScratch = unknown> {
      *  pump in `useGestureDispatcher` via `AffordanceHit.cursor`, which
      *  `buildAffordanceAt` fills in from the region the walk landed on. */
     cursor?: string;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Read only when the affordance is composed into a
+     *  consumer-registered layer; kit chrome routes through
+     *  `buildAffordanceAt`, which reports `'shared'`. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
     /** 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
@@ -448,6 +455,8 @@ interface RuleCtx {
      *  an absent profile is behavior-preserving by construction. */
     readonly device?: DeviceProfile;
 }
+/** The live state a `RuleCtx` is assembled from — the chrome context plus
+ *  what the active mode allows. */
 interface BuildRuleCtxArgs {
     focused: boolean;
     selection: readonly NodeId[];
@@ -468,6 +477,8 @@ interface BuildRuleCtxArgs {
     /** Optional — omitted means {@link DEFAULT_DEVICE_PROFILE}. */
     device?: DeviceProfile;
 }
+/** Gather the current canvas and mode state into the context that action
+ *  eligibility and chrome-visibility rules are evaluated against. */
 declare function buildRuleCtx(args: BuildRuleCtxArgs): RuleCtx;
 
 /**
@@ -528,6 +539,7 @@ type Rule = Selector | {
 };
 /** Constant rules. Kept here so they have a single source. */
 declare const ALWAYS: Rule;
+/** A rule that never passes. `any` of nothing is false. */
 declare const NEVER: Rule;
 /**
  * Render a {@link Rule} as a short human-readable string, for inspectors and
@@ -544,6 +556,8 @@ declare const NEVER: Rule;
  * on a cyclic value and renders the `when` arm as a useless `{}`.
  */
 declare function describeRule(rule: Rule): string;
+/** Evaluate a rule against a context. Pure, and cheap enough to run per
+ *  frame for every piece of chrome. */
 declare function evaluate(rule: Rule, ctx: RuleCtx): boolean;
 
 /**
@@ -862,7 +876,7 @@ type OngoingOverlay = {
      * renderer narrows on `shape` and casts the field shape it expects.
      */
     kind: 'insertPreview';
-    shape: 'rect' | 'ellipse' | 'line' | 'polygon' | 'star' | 'pencil';
+    shape: 'rect' | 'ellipse' | 'line' | 'polygon' | 'star' | 'pencil' | 'image';
     bounds: {
         x: number;
         y: number;
@@ -926,6 +940,14 @@ interface OngoingHandle {
      */
     previewIds?(): Iterable<string> | null;
     previewPose?(id: string): unknown | null;
+    /**
+     * Subset of `previewIds()` the ghost layer paints at full opacity. The
+     * ghost alpha says "this is in flight under the pointer"; a node the
+     * gesture merely displaces — a layout sibling reflowing into its
+     * destination slot — is not, and reads better settled. Honored at
+     * subtree-root granularity.
+     */
+    previewOpaqueIds?(): Iterable<string> | null;
     /**
      * When `false`, the preview-ghost layer paints the ghost AND the
      * source node stays visible at its committed pose. Defaults to
@@ -993,6 +1015,9 @@ type Invoker = ImmediateInvoker | OngoingInvoker;
  * See `docs/superpowers/specs/2026-05-16-registry-unification-design.md`.
  */
 
+/** An interaction: a gesture spec composed with the id of the action it
+ *  invokes. Tools declare arrays of these; the dispatcher matches an incoming
+ *  input event against them and runs the winner's action. */
 interface GestureBinding {
     spec: GestureSpec;
     actionId: string;
@@ -1154,6 +1179,15 @@ type BooleanOpResult = {
     kind: 'noop';
     reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result';
 };
+/**
+ * Run one Boolean operation over the selected paths and commit the result as a
+ * single undoable batch.
+ *
+ * Operands are ordered back-to-front, which is what makes `subtract` mean
+ * "everything in front removed from the backmost shape". Returns without
+ * mutating anything when the selection holds no paths, or too few for the
+ * requested operation.
+ */
 declare function applyBooleanOp(adapter: BooleansAdapter, op: BooleanOp): BooleanOpResult;
 
 /**
@@ -1276,6 +1310,9 @@ interface IngestCtx {
     /** Full action-deps bag, for consumer handlers that need more. */
     deps: ActionDeps;
 }
+/** A handler for content arriving by paste, drop or file picker. Handlers are
+ *  matched by MIME glob or predicate and run highest-priority first; the kit's
+ *  own register at a low priority so a consumer's handler wins by default. */
 interface ContentHandlerEntry {
     /** Stable identifier — used for unregistration and debugging
      *  (`'kit:image'`, `'app:csv'`). */
@@ -1342,6 +1379,9 @@ declare function PointerContextProvider({ children }: {
  *  no provider is in scope. */
 declare function usePointerContext(): PointerContextValue | null;
 
+/** Which tool is active, plus the stack of tools temporarily held active by a
+ *  hotkey (space-for-hand and the like). The dispatcher reads this to decide
+ *  whose bindings are in scope. */
 interface ActiveToolContextValue {
     active: string;
     hotkeyStack: string[];
@@ -1349,11 +1389,15 @@ interface ActiveToolContextValue {
     pushHotkey(id: string): void;
     popHotkey(): void;
 }
+/** Props for `<ActiveToolContextProvider>`. */
 interface ActiveToolContextProviderProps {
     children: ReactNode;
     initialActive?: string;
 }
+/** Provides active-tool state for a canvas. `<SceneCanvas>` mounts one. */
 declare function ActiveToolContextProvider({ children, initialActive, }: ActiveToolContextProviderProps): react_jsx_runtime.JSX.Element;
+/** The active-tool state in scope. Throws outside a provider; use
+ *  `useActiveToolContextOptional` where one is not guaranteed. */
 declare function useActiveToolContext(): ActiveToolContextValue;
 /**
  * Like `useActiveToolContext`, but returns `null` when no
@@ -1585,6 +1629,8 @@ type NodeAtPointDep = (point: {
     x: number;
     y: number;
 }, exclude?: Iterable<NodeId>) => NodeId | null;
+/** What an area-selecting action needs: a way to ask what a region covers,
+ *  and a way to read and replace the selection. */
 interface AreaSelectDep {
     /** Return ids of all scene nodes whose AABB overlaps `bounds`. */
     hitTestArea(bounds: {
@@ -1833,6 +1879,13 @@ type InsertExtras = {
 } | {
     kind: 'text';
     text?: string;
+} | {
+    kind: 'image';
+    src?: string;
+    opacity?: number;
+    /** Chrome-only: what the in-flight drag paints. Read by the overlay
+     *  layer, ignored by the insert dep. */
+    preview?: 'bitmap' | 'outline';
 } | {
     kind: string;
     [extra: string]: unknown;
@@ -1916,6 +1969,14 @@ interface ResizePolicy<TPose> {
 interface LayoutDep {
     getLayout(containerId: string): LayoutStrategy<unknown> | null;
 }
+/**
+ * The names an action may declare in `requires`, and what each resolves to.
+ *
+ * This is the whole vocabulary of things an action can reach — selection,
+ * scene, view, history, and the rest. Consumers add their own entries by
+ * augmenting the interface (`declare module '@weasel-js/core'`), which is what
+ * makes a custom dep name type-check in `requires` and in the deps bag.
+ */
 interface DepSchema {
     /** Kit selection state — ids of currently selected nodes. */
     selection: SelectionApi;
@@ -2102,13 +2163,19 @@ interface DepSchema {
  */
 type DepName = keyof DepSchema;
 
+/** Holds the live sources an action's declared dependencies resolve to.
+ *  Sources are thunks, read at invocation time, so an action never captures
+ *  stale state. */
 interface DepRegistry {
     register<K extends DepName>(name: K, source: () => DepSchema[K]): () => void;
     get<K extends DepName>(name: K): DepSchema[K] | undefined;
 }
+/** Provides the dep registry for a canvas. `<SceneCanvas>` mounts one; a
+ *  consumer registering its own dep sources must be inside it. */
 declare function DepRegistryProvider({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
+/** The dep registry in scope. Throws outside a `<DepRegistryProvider>`. */
 declare function useDepRegistry(): DepRegistry;
 /**
  * Like `useDepRegistry`, but returns `null` when no `<DepRegistryProvider>` is
@@ -2137,6 +2204,14 @@ interface Eligibility {
     /** Modality filter, applied wherever it would otherwise be live. */
     capabilities?: CapabilityTag[];
 }
+/**
+ * Where an entry's overlay sits in the layer stack, relative to the
+ * selection chrome. `'top'` is the default and renders above everything;
+ * the other two exist for chrome that belongs under the selection handles
+ * (a snap-target highlight, say). With no selection overlay in the stack,
+ * all three collapse to `'top'`.
+ */
+type OverlayPosition = 'top' | 'before-selection' | 'after-selection';
 /**
  * A registry entry: what it contributes, and when it is eligible. Every role
  * is optional and independent — an entry that only routes input declares only
@@ -2147,12 +2222,121 @@ interface Contribution {
     eligibility: Eligibility;
     bindings?: GestureBinding[];
     actions?: Action[];
-    overlay?: RenderLayer<unknown>;
+    /** One layer, or several composed in the given order. */
+    overlay?: RenderLayer<unknown> | RenderLayer<unknown>[];
+    /** Defaults to `'top'`. Applies to every layer in `overlay`. */
+    overlayPosition?: OverlayPosition;
     presentation?: ToolPresentation;
     /** Reflection escape hatch — the authored form, when there was one. */
     def?: unknown;
 }
 
+/**
+ * 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';
+}
+/**
+ * What a tool declares.
+ *
+ * A tool is a declarative shell, not an event handler: it names the gestures
+ * it responds to and, for each, the action to invoke. The dispatcher owns the
+ * gesture, and the action owns the preview and the commit — so a tool
+ * definition is mostly `bindings`, plus presentation and any actions the tool
+ * itself introduces.
+ */
+interface ToolDef<TScratch = void> {
+    id: string;
+    /** Capability tags for modality eligibility. Forwarded onto `Tool.capabilities`. */
+    capabilities?: CapabilityTag[];
+    /**
+     * Actions this tool owns and needs registered while it is in the tools
+     * registry — e.g. polygon's `polygon.adjustSides`, which its own bindings
+     * reference by id.
+     *
+     * Declared here rather than registered by the hook with `useAction`,
+     * because tool hooks run wherever the consumer calls them — for
+     * `<SceneCanvas>` that is ABOVE `<ActionsProviderIfRoot>`, where
+     * `useActionsRegistry()` returns null and `useAction` silently no-ops. The
+     * result was a binding pointing at an action id nothing had registered, so
+     * the gesture fell through to whatever matched next (polygon's
+     * wheel/arrow-key side adjustment did nothing and `nudge.*` moved the
+     * selection instead). `<ToolActionsMounter>` registers these from inside
+     * the provider.
+     */
+    actions?: Action[];
+    /** 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;
+    /** Held-key trigger: this tool engages while the key is down and
+     *  disengages on release. Carried onto `Tool.eligibility.offhand`, which
+     *  assembly reads to register the consolidated `tool.offhand` action — the
+     *  declaration is the wiring, with nothing for the host to do. */
+    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;
+    /** Declarative gesture bindings, forwarded onto `Tool.bindings`. The
+     *  gesture dispatcher consults these at active scope while this tool is the
+     *  active one, and at hotkey scope while it is held. This is the tool's
+     *  entire input surface — the `initial` / `engaged` phase tables that used
+     *  to sit beside it are gone, along with the second dispatcher that read
+     *  them. */
+    bindings?: GestureBinding[];
+    /** Optional overlay layer rendered while the tool occupies any slot
+     *  (active, hotkey, or ambient), surfaced on `Tool.overlay`.
+     *
+     *  The layer's `draw` closure should read dynamic state through refs or
+     *  closures captured in the enclosing render scope, and gate on it there —
+     *  `if (!scratch.something) return []` — rather than expecting the kit to
+     *  swap layers as the gesture progresses.
+     *
+     *  Pass an array to contribute several layers; they render in order. */
+    overlay?: RenderLayer<unknown> | RenderLayer<unknown>[];
+    /** Where `overlay` sits relative to the selection chrome. Defaults to
+     *  `'top'`, above everything. */
+    overlayPosition?: OverlayPosition;
+}
+/** Viewport-tool spec. Once phase tables went away this stopped differing
+ *  from `ToolDef` in any structural way; `defineViewportTool` survives as the
+ *  authoring signal that a tool pans/zooms the view rather than the scene. */
+type ViewportToolDef<TScratch = void> = ToolDef<TScratch>;
+
 /** 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. */
@@ -2281,7 +2465,11 @@ type AnyTool = Tool<any>;
  * binding-scope / matchBest logic on top.
  */
 
+/** Where a binding came from, which is also its priority: a held hotkey beats
+ *  the active tool, which beats bindings that are always in scope. */
 type BindingScope = 'ambient' | 'active' | 'hotkey';
+/** A binding paired with where it came from, ready to be matched against an
+ *  event. */
 interface ScopedBinding {
     binding: GestureBinding;
     scope: BindingScope;
@@ -2290,6 +2478,7 @@ interface ScopedBinding {
      *  Action with no owning tool. */
     ownerToolId: string | null;
 }
+/** The binding that won a match. */
 interface MatchResult {
     binding: GestureBinding;
     scope: BindingScope;
@@ -2303,7 +2492,7 @@ interface MatchResult {
  *    [0] target — how much the spec's target narrows; see `targetRank`.
  *    [1] mods   — count of required modifier keys (shift/alt/ctrl/meta/mod).
  *                 `'optional'` does NOT count.
- *    [2] phase  — 1 if the spec declares a `phase` field, else 0.
+ *    [2] phase  — how much the spec's `phase` narrows; see `phaseRank`.
  *    [3] exact  — per-kind tiebreak: 2 for a drop/paste spec with a
  *                 non-empty `types` MIME filter, else 1.
  *
@@ -2349,6 +2538,11 @@ declare function specificity(spec: GestureSpec): readonly [number, number, numbe
  * the misconfiguration at dev time.
  */
 
+/** Everything the dispatcher must consult to route one input event: the
+ *  registered actions and their deps, which tool is active, which hotkeys are
+ *  held, and — optionally — the chrome state that action eligibility rules are
+ *  evaluated against. Rebuilt per event rather than held, so the dispatcher
+ *  itself stays stateless apart from in-flight gestures. */
 interface DispatcherContext {
     /** All registered actions; the dispatcher walks `.defaultBinding` for ambient bindings. */
     actions: ActionsRegistry;
@@ -2454,6 +2648,15 @@ interface ResolveAllOptions {
      */
     evaluateShadowed?: boolean;
 }
+/**
+ * Routes input events to actions.
+ *
+ * For each event it assembles the bindings in scope (hotkey, then active tool,
+ * then ambient), matches them in specificity order, filters by eligibility and
+ * each action's `enabled` gate, and invokes the first survivor. Ongoing
+ * actions — anything that runs across a drag — are kept in flight here and
+ * pumped with subsequent moves until the gesture ends.
+ */
 interface Dispatcher {
     /**
      * Route an input event through the binding pipeline. Returns `'handled'`
@@ -2590,6 +2793,8 @@ interface Dispatcher {
      */
     beginUiOngoing(actionId: string, deps: ActionDeps, params?: Record<string, unknown>): UiOngoingControl | null;
 }
+/** Build a dispatcher. `getAction` overrides how action ids are resolved;
+ *  by default the `DispatcherContext`'s registry is used. */
 declare function createDispatcher(opts?: {
     getAction?: (id: string) => Action | undefined;
 }): Dispatcher;
@@ -2743,6 +2948,7 @@ declare const ActionDisabledReason: {
     /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
     readonly PredicateThrew: "predicate-threw";
 };
+/** Why an action is unavailable right now. */
 type ActionDisabledReason = (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];
 /**
  * @experimental
@@ -2752,6 +2958,14 @@ interface ActionEnabledResult {
     enabled: boolean;
     reason?: ActionDisabledReason;
 }
+/**
+ * @experimental
+ * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`
+ * when no predicate is supplied. Catches throws and treats them as disabled
+ * with reason `'(predicate threw)'`. In dev mode, warns once per action id
+ * when a single call exceeds 4ms (single frame at 240fps — generous; real
+ * predicates should be sub-millisecond).
+ */
 declare function evaluateEnabled(action: Action, deps?: ActionDeps): ActionEnabledResult;
 /**
  * @experimental
@@ -2829,343 +3043,4 @@ declare function useActionsRegistry(): ActionsRegistry | null;
  */
 declare function useAction(action: Action): void;
 
-/**
- * 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';
-}
-interface ToolDef<TScratch = void> {
-    id: string;
-    /** Capability tags for modality eligibility. Forwarded onto `Tool.capabilities`. */
-    capabilities?: CapabilityTag[];
-    /**
-     * Actions this tool owns and needs registered while it is in the tools
-     * registry — e.g. polygon's `polygon.adjustSides`, which its own bindings
-     * reference by id.
-     *
-     * Declared here rather than registered by the hook with `useAction`,
-     * because tool hooks run wherever the consumer calls them — for
-     * `<SceneCanvas>` that is ABOVE `<ActionsProviderIfRoot>`, where
-     * `useActionsRegistry()` returns null and `useAction` silently no-ops. The
-     * result was a binding pointing at an action id nothing had registered, so
-     * the gesture fell through to whatever matched next (polygon's
-     * wheel/arrow-key side adjustment did nothing and `nudge.*` moved the
-     * selection instead). `<ToolActionsMounter>` registers these from inside
-     * the provider.
-     */
-    actions?: Action[];
-    /** 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;
-    /** Held-key trigger: this tool engages while the key is down and
-     *  disengages on release. Carried onto `Tool.eligibility.offhand`, which
-     *  assembly reads to register the consolidated `tool.offhand` action — the
-     *  declaration is the wiring, with nothing for the host to do. */
-    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;
-    /** Declarative gesture bindings, forwarded onto `Tool.bindings`. The
-     *  gesture dispatcher consults these at active scope while this tool is the
-     *  active one, and at hotkey scope while it is held. This is the tool's
-     *  entire input surface — the `initial` / `engaged` phase tables that used
-     *  to sit beside it are gone, along with the second dispatcher that read
-     *  them. */
-    bindings?: GestureBinding[];
-    /** Optional overlay layer rendered while the tool occupies any slot
-     *  (active, hotkey, or ambient), surfaced on `Tool.overlay`.
-     *
-     *  The layer's `draw` closure should read dynamic state through refs or
-     *  closures captured in the enclosing render scope, and gate on it there —
-     *  `if (!scratch.something) return []` — rather than expecting the kit to
-     *  swap layers as the gesture progresses. */
-    overlay?: RenderLayer<unknown>;
-}
-/** Viewport-tool spec. Once phase tables went away this stopped differing
- *  from `ToolDef` in any structural way; `defineViewportTool` survives as the
- *  authoring signal that a tool pans/zooms the view rather than the scene. */
-type ViewportToolDef<TScratch = void> = ToolDef<TScratch>;
-
-/**
- * Build a `Tool<TScratch>` from a declarative `ToolDef<TScratch>`.
- *
- * This used to be a translator: `ToolDef` carried `initial` / `engaged` phase
- * tables of hit-keyed route handlers, and `defineTool` compiled them into the
- * imperative `pointer` / `drag` / `keyboard` / `wheel` handlers the
- * tool-routing dispatcher called. Both ends of that are gone — tools declare
- * `bindings` and the gesture dispatcher routes them — so what remains is
- * identity plumbing plus the id check and the cursor resolver.
- *
- * It stays a function rather than becoming a spread because the id validation
- * and the `initScratch` / `cursor` defaults are worth applying uniformly, and
- * because `Tool.def` gives reflection a handle on the authored form.
- */
-declare function defineTool<TScratch = void>(def: ToolDef<TScratch>): Tool<TScratch>;
-
-/**
- * Define a tool that acts on the viewport rather than the scene.
- *
- * This used to do real work: `ViewportPhaseDef` was a narrowed `PhaseDef`
- * (no click routes, drag restricted to the function form), and the factory
- * lifted it back to the permissive shape before handing it to `defineTool`.
- * With phase tables gone there is no shape left to narrow — a viewport tool
- * declares `bindings` like any other, pointing at `viewport.*` actions.
- *
- * It survives as an authoring signal. `defineViewportTool` at the top of a
- * hook says "this tool moves the camera, not the drawing", which is worth
- * more than the type gymnastics it replaced.
- */
-declare function defineViewportTool<TScratch = void>(def: ViewportToolDef<TScratch>): Tool<TScratch>;
-
-/**
- * One row in the route registry — a single `GestureBinding` on one tool,
- * flattened into the route grammar's vocabulary so the inspector, the
- * conflict checker, and `describeRoute` can all read the same shape.
- *
- * 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;
-    /** Which phase the binding's `phase` spec restricts it to. `'any'` when it
-     *  declares none, declares `'*'`, or declares an atom list whose atoms
-     *  don't agree on one phase — such a binding fires in either phase, and
-     *  reporting it as `'initial'` made it collide with genuinely-initial
-     *  bindings in `findConflicts`' bucket key. */
-    phase: 'initial' | 'engaged' | 'any';
-    /** 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,
-     *  key name, multiTouchTap fingers). Undefined for gestures whose
-     *  descriptor has no `arg`. */
-    arg: string | undefined;
-    /** Target class for hit-testing gestures. `undefined` when the descriptor
-     *  has `hasTarget: false` or the spec declares no target;
-     *  {@link PREDICATE_TARGET} when the spec uses a `kindOf` predicate, which
-     *  the route grammar has no notation for. */
-    target: string | undefined;
-    /** The action this binding fires. */
-    actionId: string;
-    /** The `GestureSpec` this row was flattened from, by reference. Reflection
-     *  consumers that need something the grammar doesn't capture — the
-     *  specificity tuple, a `kindOf` predicate identity — read it here rather
-     *  than re-walking `Tool.bindings`. */
-    spec: GestureSpec;
-}
-/**
- * Stand-in target for a `{ kindOf }` predicate spec.
- *
- * The route grammar can name target *classes* (`empty`, `selected-body`,
- * `kind:rect`) but not arbitrary predicates, so three distinct select-tool
- * bindings all render as this one token. Narrowing it would mean giving the
- * grammar a way to describe a function, which is a real design question and
- * not one this reflection layer should answer by inventing syntax.
- */
-declare const PREDICATE_TARGET = "predicate";
-/**
- * Flatten every tool's `bindings` into route-registry rows.
- *
- * This was `buildActionRegistry`, and it walked `ToolDef.initial` /
- * `.engaged` phase tables — the grammar that no longer exists. It was also
- * blind to `Tool.bindings` the entire time the two lived side by side, which
- * is why the inspector under-reported select by more than half. The rename
- * fixes a second thing: it never had anything to do with the Actions
- * Registry, and reading `buildActionRegistry` next to `ActionsRegistry`
- * suggested otherwise.
- */
-declare function buildRouteRegistry(tools: readonly Tool<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: 'initial' | 'engaged' | 'any';
-    gesture: GestureName;
-    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:
- *  - Broad vs. narrow targets (e.g. an untargeted `click` alongside
- *    `click` on `empty`) — the dispatcher's specificity ordering resolves
- *    those cleanly, and the broad one is usually the intended fallback.
- *  - Different modifier requirements on the same target — they fire on
- *    different inputs.
- *  - A binding whose action declines via `enabled()` so a lower-priority
- *    one can take the gesture. Detecting that intent would mean evaluating
- *    the action; consumers can suppress known-intentional compositions in
- *    their UI layer.
- *
- *  - Two `{ kindOf }` predicate targets. The route grammar renders every
- *    predicate as the single token {@link PREDICATE_TARGET}, so bucketing on
- *    the rendered target alone reported select's `resize` / `rotate` / `move`
- *    drags — three genuinely different predicates — as a three-way conflict.
- *    Predicate entries bucket by function identity instead, which means two
- *    *separately written but equivalent* predicates go unflagged. That's the
- *    right way to be wrong here: this check has to be silent when nothing is
- *    wrong or nobody will keep it on.
- *
- *  Note that two bindings sharing a tuple on the SAME tool are now possible
- *  (bindings are an array, where phase tables were objects with unique
- *  keys) — so a conflict may name one tool twice.
- *
- *  This is the raw same-tuple detector. Feeding it a whole tool *registry*
- *  over-reports, because registry tools take turns in the active slot and
- *  can't collide with each other — see {@link findScopedConflicts}.
- */
-declare function findConflicts(tools: readonly Tool<unknown>[]): Conflict[];
-/**
- * The tool scopes as the dispatcher sees them — which is what decides whether
- * two same-tuple bindings can actually collide.
- */
-interface ToolScopes {
-    /** Tools eligible for the active slot, keyed by id or as a flat list. */
-    registry: readonly Tool<unknown>[] | Readonly<Record<string, Tool<unknown>>>;
-    /** Always-on tools. Every one of these is live at once. */
-    ambient?: readonly Tool<unknown>[];
-    /** Registered actions. Their `defaultBinding`s assemble at ambient scope
-     *  (hotkey scope when `Action.scope` says so), alongside the tools above. */
-    actions?: readonly Action[];
-}
-/**
- * Detect the same-tuple overlaps that are *reachable* — the ones where the
- * dispatcher really does fall back on declaration order.
- *
- * `matchSorted` walks scopes in strict priority (hotkey > active > ambient)
- * and only sorts by specificity *within* a scope. So a cross-scope tie isn't
- * a tie at all: an ambient tool losing a tuple to the active tool is the
- * documented design, not an accident. Likewise two registry tools sharing a
- * tuple — `rect` and `ellipse` both binding a bare `drag` — can never both be
- * in the active slot, so they never compete.
- *
- * What's left, and what this reports:
- *  - a single tool colliding with **itself** (possible since bindings became
- *    an array), which is ambiguous in whichever slot it occupies;
- *  - two **ambient** tools, all of which are live simultaneously and are
- *    ordered only by registration;
- *  - two **hotkey-capable** tools, which can stack.
- *
- * Registered actions join the same two buckets: their `defaultBinding`s
- * assemble at ambient scope (hotkey scope when `Action.scope` says so), so an
- * ambient tool and an action claiming one tuple really do fall back on
- * declaration order.
- */
-declare function findScopedConflicts(scopes: ToolScopes): Conflict[];
-/**
- * Render a conflict as one line of human-readable text.
- *
- * The tuple is printed through {@link formatRoute}, so the message names the
- * collision in the same grammar the author wrote the binding in — modulo the
- * phase slot, which prints as a bare `'&'`-channel atom because the bucket key
- * collapses channel-bearing phase specs (`sel:engaged` and `&:engaged` collide
- * with each other, and the collapse is what made them collide).
- */
-declare function formatConflict(conflict: Conflict): string;
-/**
- * Detect reachable route conflicts in an assembled tool set and report each one.
- *
- * This is the wiring `findConflicts` spent its first life without: the kit
- * could detect the one class of genuine routing ambiguity it has and never
- * looked. Call it once wherever a tool set is assembled (`useTools` does),
- * behind a `process.env.NODE_ENV !== 'production'` guard.
- *
- * **Warn, never throw.** A conflict between a consumer's tool and a kit tool
- * is a design question — sometimes deliberate, since the loser can still take
- * the gesture by declining through `enabled()` — and exploding in a running
- * app is the wrong way to raise it. A conflict between two *kit* tools is
- * always a bug, but the place to fail on that is the kit's own test suite
- * (`canvas/SceneCanvas.routeConflicts.test.tsx`), not a consumer's console.
- *
- * @returns The conflicts found, so callers can dedupe repeat reports.
- */
-declare function reportRouteConflicts(scopes: ToolScopes, warn?: (message: string) => void): Conflict[];
-
-declare const index_ChannelRef: typeof ChannelRef;
-type index_Conflict = Conflict;
-declare const index_DescribeRouteOptions: typeof DescribeRouteOptions;
-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;
-declare const index_ModRequirement: typeof ModRequirement;
-declare const index_ModifierKey: typeof ModifierKey;
-declare const index_PREDICATE_TARGET: typeof PREDICATE_TARGET;
-declare const index_ParsedModifiers: typeof ParsedModifiers;
-declare const index_ParsedRoute: typeof ParsedRoute;
-declare const index_PhaseAtom: typeof PhaseAtom;
-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;
-declare const index_RouteDescriptionPart: typeof RouteDescriptionPart;
-declare const index_RouteFieldName: typeof RouteFieldName;
-declare const index_RouteTermLabel: typeof RouteTermLabel;
-type index_ToolDef<TScratch = void> = ToolDef<TScratch>;
-type index_ToolKeybinding = ToolKeybinding;
-type index_ToolScopes = ToolScopes;
-type index_ViewportToolDef<TScratch = void> = ViewportToolDef<TScratch>;
-declare const index_buildRouteRegistry: typeof buildRouteRegistry;
-declare const index_canonicalModifiers: typeof canonicalModifiers;
-declare const index_collapseShiftPairs: typeof collapseShiftPairs;
-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_findScopedConflicts: typeof findScopedConflicts;
-declare const index_formatConflict: typeof formatConflict;
-declare const index_formatPhaseAtom: typeof formatPhaseAtom;
-declare const index_formatRoute: typeof formatRoute;
-declare const index_getGestureDescriptor: typeof getGestureDescriptor;
-declare const index_isKnownGestureName: typeof isKnownGestureName;
-declare const index_parseRoute: typeof parseRoute;
-declare const index_reportRouteConflicts: typeof reportRouteConflicts;
-declare namespace index {
-  export { index_ChannelRef as ChannelRef, type index_Conflict as Conflict, index_DescribeRouteOptions as DescribeRouteOptions, index_GESTURE_DESCRIPTORS as GESTURE_DESCRIPTORS, index_GestureArgSpec as GestureArgSpec, index_GestureDescriptor as GestureDescriptor, index_GestureName as GestureName, index_ModRequirement as ModRequirement, index_ModifierKey as ModifierKey, index_PREDICATE_TARGET as PREDICATE_TARGET, index_ParsedModifiers as ParsedModifiers, index_ParsedRoute as ParsedRoute, index_PhaseAtom as PhaseAtom, 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, index_RouteDescriptionPart as RouteDescriptionPart, index_RouteFieldName as RouteFieldName, index_RouteTermLabel as RouteTermLabel, type index_ToolDef as ToolDef, type index_ToolKeybinding as ToolKeybinding, type index_ToolScopes as ToolScopes, type index_ViewportToolDef as ViewportToolDef, index_buildRouteRegistry as buildRouteRegistry, index_canonicalModifiers as canonicalModifiers, index_collapseShiftPairs as collapseShiftPairs, index_defineTool as defineTool, index_defineViewportTool as defineViewportTool, index_describeRoute as describeRoute, index_describeRouteParts as describeRouteParts, index_findConflicts as findConflicts, index_findScopedConflicts as findScopedConflicts, index_formatConflict as formatConflict, index_formatPhaseAtom as formatPhaseAtom, index_formatRoute as formatRoute, index_getGestureDescriptor as getGestureDescriptor, index_isKnownGestureName as isKnownGestureName, index_parseRoute as parseRoute, index_reportRouteConflicts as reportRouteConflicts };
-}
-
-export { type BoundGesture as $, type Action as A, type BooleansAdapter as B, type Condition as C, type Dims as D, type Eligibility as E, type ActionDeps as F, type GeometryProjection as G, type HotkeyTrigger as H, type InsertExtras as I, ActionDisabledReason as J, type ActionEnabledResult as K, type LayerHit as L, type ActionEntry as M, ActionsProvider as N, ActiveToolContextProvider as O, ActiveToolContextProviderIfRoot as P, type ActiveToolContextProviderProps as Q, type RenderLayer as R, type SliceDep as S, type Tool as T, type UseSelectionOptions as U, type VisibilityRules as V, type ActiveToolContextValue as W, type AreaSelectDep as X, type BindingOpts as Y, type BooleanOp as Z, type BooleanOpResult as _, type DeviceProfile as a, index as a$, type BuildRuleCtxArgs as a0, type ClaimableGesture as a1, type ClipboardDep as a2, type ClipboardIngestCtx as a3, type CustomPaintContext as a4, type DepName as a5, type DepRegistry as a6, DepRegistryProvider as a7, type DispatcherContext as a8, type DragSample as a9, type ResolvedCandidate as aA, type SelectionExtendKey as aB, type SelectionMode as aC, type Selector as aD, type SnapDep as aE, type SvgUnpacker as aF, type TextEditDep as aG, type ToolModifiers as aH, type ToolPresentation as aI, type ToolSlot as aJ, type UiOngoingControl as aK, type ViewApi as aL, applyBooleanOp as aM, buildRuleCtx as aN, clipboardCopyAction as aO, clipboardCutAction as aP, composeRectPose as aQ, composeWorldPose as aR, createDispatcher as aS, decomposeRectPose as aT, describeRule as aU, drawLayers as aV, enterTextEditAction as aW, evaluate as aX, evaluateEnabled as aY, rebaseLocalPose as aZ, registerContentHandler as a_, type EditAnchorsDep as aa, type GestureBinding as ab, IDENTITY_POSE_COMPOSITION as ac, type ImmediateInvoker as ad, type IngestCtx as ae, type IngestionDep as af, type InsertDep as ag, type InvocationCtx as ah, type Invoker as ai, type LassoSelectDep as aj, type LayoutDep as ak, type MatchResult as al, NEVER as am, type NodeAtPointDep as an, type OngoingHandle as ao, type OngoingInvoker as ap, type OngoingOverlay as aq, type Point2 as ar, PointerContextProvider as as, type PointerContextValue as at, type PointerWorldPos as au, type PoseAdapter as av, type PoseComposition as aw, type ResizePolicy as ax, type ResolveAllOptions as ay, type ResolveOnlyResult as az, type DetectedDeviceFacts as b, sliceAction as b0, specificity as b1, translateRectPose as b2, useAction as b3, useActionsRegistry as b4, useActiveToolContext as b5, useDepRegistry as b6, useDepSource as b7, useOptionalActiveToolContext as b8, useOptionalDepRegistry as b9, usePointerContext as ba, useSelection as bb, worldPoseLookup as bc, type Conflict as bd, PREDICATE_TARGET as be, type RegistryEntry as bf, type ToolDef as bg, type ToolScopes as bh, type ViewportToolDef as bi, buildRouteRegistry as bj, defineTool as bk, defineViewportTool as bl, findConflicts as bm, findScopedConflicts as bn, formatConflict as bo, reportRouteConflicts as bp, type Rule as c, type RuleCtx as d, type ChromeCtx as e, type ChromeId as f, type DepSchema as g, type ActionsRegistry as h, type AffordanceHit as i, type Dispatcher as j, type AnyTool as k, type ToolCtx as l, type ToolKeybinding as m, type ChromeState as n, type SelectionApi as o, type ContentHandlerEntry as p, type SvgIngestOptions as q, type ActionsProp as r, type Affordance as s, type AffordanceBinding as t, type AffordanceRegion as u, type CommonAffordanceScratch as v, type BindingScope as w, type Contribution as x, type ScopedBinding as y, ALWAYS as z };
+export { type BindingOpts as $, type Action as A, type BooleansAdapter as B, type Condition as C, type Dims as D, type Eligibility as E, type ScopedBinding as F, type GeometryProjection as G, type HotkeyTrigger as H, type InsertExtras as I, ALWAYS as J, type ActionDeps as K, type LayerHit as L, ActionDisabledReason as M, type ActionEnabledResult as N, type OverlayPosition as O, type ActionEntry as P, ActionsProvider as Q, type RenderLayer as R, type SliceDep as S, type Tool as T, type UseSelectionOptions as U, type VisibilityRules as V, ActiveToolContextProvider as W, ActiveToolContextProviderIfRoot as X, type ActiveToolContextProviderProps as Y, type ActiveToolContextValue as Z, type AreaSelectDep as _, type DeviceProfile as a, evaluateEnabled as a$, type BooleanOp as a0, type BooleanOpResult as a1, type BoundGesture as a2, type BuildRuleCtxArgs as a3, type ClaimableGesture as a4, type ClipboardDep as a5, type ClipboardIngestCtx as a6, type CustomPaintContext as a7, type DepName as a8, type DepRegistry as a9, type ResizePolicy as aA, type ResolveAllOptions as aB, type ResolveOnlyResult as aC, type ResolvedCandidate as aD, type SelectionExtendKey as aE, type SelectionMode as aF, type Selector as aG, type SnapDep as aH, type SvgUnpacker as aI, type TextEditDep as aJ, type ToolModifiers as aK, type ToolPresentation as aL, type ToolSlot as aM, type UiOngoingControl as aN, type ViewApi as aO, applyBooleanOp as aP, buildRuleCtx as aQ, clipboardCopyAction as aR, clipboardCutAction as aS, composeRectPose as aT, composeWorldPose as aU, createDispatcher as aV, decomposeRectPose as aW, describeRule as aX, drawLayers as aY, enterTextEditAction as aZ, evaluate as a_, DepRegistryProvider as aa, type DispatcherContext as ab, type DragSample as ac, type EditAnchorsDep as ad, type GestureBinding as ae, IDENTITY_POSE_COMPOSITION as af, type ImmediateInvoker as ag, type IngestCtx as ah, type IngestionDep as ai, type InsertDep as aj, type InvocationCtx as ak, type Invoker as al, type LassoSelectDep as am, type LayoutDep as an, type MatchResult as ao, NEVER as ap, type NodeAtPointDep as aq, type OngoingHandle as ar, type OngoingInvoker as as, type OngoingOverlay as at, type Point2 as au, PointerContextProvider as av, type PointerContextValue as aw, type PointerWorldPos as ax, type PoseAdapter as ay, type PoseComposition as az, type DetectedDeviceFacts as b, rebaseLocalPose as b0, registerContentHandler as b1, sliceAction as b2, specificity as b3, translateRectPose as b4, useAction as b5, useActionsRegistry as b6, useActiveToolContext as b7, useDepRegistry as b8, useDepSource as b9, useOptionalActiveToolContext as ba, useOptionalDepRegistry as bb, usePointerContext as bc, useSelection as bd, worldPoseLookup as be, type Rule as c, type RuleCtx as d, type ChromeCtx as e, type ChromeId as f, type DepSchema as g, type ActionsRegistry as h, type AffordanceHit as i, type Dispatcher as j, type ToolDef as k, type ViewportToolDef as l, type AnyTool as m, type ToolCtx as n, type ToolKeybinding as o, type ChromeState as p, type SelectionApi as q, type ContentHandlerEntry as r, type SvgIngestOptions as s, type ActionsProp as t, type Affordance as u, type AffordanceRegion as v, type AffordanceBinding as w, type CommonAffordanceScratch as x, type BindingScope as y, type Contribution as z };