@weasel-js/core 0.8.0 → 1.0.0

package/dist/{index-Clf_koyR.d.ts → index-ChM3ZJ2v.d.ts}

@@ -4,13 +4,14 @@ 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 { IngestItem, GestureSpec, 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 { F as FillStyle, a as Stroke, D as DrawCommand } from './DrawCommand-BKJ5JPkC.js';
+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 { F as FillStyle, S as Stroke } from './paint-types-CnLIzqq1.js';
+import { D as DrawCommand } from './DrawCommand-DCmiNkBj.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 { B as Bounds, P as PoseProjection } from './geometry-DVeZ2i-c.js';
 import { Mat3 } from '@weasel-js/geom';
 import { D as DebugSink } from './types-BJ8_cyT7.js';
 
@@ -239,6 +240,31 @@ interface CommonAffordanceScratch {
         y: number;
     };
 }
+/**
+ * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
+ * so existing implementations keep typechecking; the added fields are how a
+ * consumer's own chrome says the things kit chrome says through
+ * `AffordanceRegion` — which cursor to show, and whether it owns the point
+ * outright.
+ */
+interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
+    /** CSS cursor while the pointer is over this hit. Reaches the hover-cursor
+     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
+    cursor?: string;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
+     *  meaning as `AffordanceHit.strength`, which it becomes. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+}
+/**
+ * Gesture kinds an affordance claim can bar, in the spec vocabulary bindings
+ * are written in. `'pointer'` is one token because `pointerDown` / `click` /
+ * `drag` are a single press protocol — at the event level the first two are
+ * the same `kind: 'pointerdown'`, told apart only by `stage`.
+ */
+type ClaimableGesture = 'pointer' | 'doubleClick' | 'contextMenu' | 'longPress' | 'wheel';
 
 /**
  * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
@@ -317,7 +343,7 @@ interface RenderLayer<TData> {
     /** 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;
+    isVisible?: (id: string) => boolean) => LayerHit | null;
     /**
      * Called on every pointermove when no gesture is currently captured.
      * Lets layers (e.g. HUD widgets) track hover state without participating
@@ -623,6 +649,15 @@ interface Point2 {
 interface AffordanceHit {
     /** Discriminator string, e.g. `'handle:bottom-right'`. */
     kind: string;
+    /** Id of whatever produced this hit — a kit affordance's `id`, or the
+     *  registered layer's id. Read only by the dispatcher's dead-claim warning today. */
+    owner?: string;
+    /** `'exclusive'` means no binding may act on this point unless its target
+     *  consults the affordance. `'shared'` (the default) competes on scope and
+     *  specificity as bindings always have. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
     /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
     fixedPoint?: {
         x: number;
@@ -950,6 +985,20 @@ interface OngoingInvoker {
  *  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;
+}
+
 /**
  * Pose composition for hierarchical scene graphs.
  *
@@ -2073,17 +2122,35 @@ declare function useOptionalDepRegistry(): DepRegistry | null;
 declare function useDepSource<K extends DepName>(name: K, source: () => DepSchema[K]): void;
 
 /**
- * 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`.
+ * When an entry's bindings are live. A set, not one value: the hand tool is
+ * palette-selectable AND engaged by holding space, and both hold at once.
+ */
+interface Eligibility {
+    /** Selectable as the focused entry — exclusive, one at a time. */
+    focus?: boolean;
+    /** Also live while this key is held. */
+    offhand?: HotkeyTrigger;
+    /** Live regardless of what is focused. */
+    always?: boolean;
+    /** Live only for input this entry's own affordances produced. */
+    claimed?: boolean;
+    /** Modality filter, applied wherever it would otherwise be live. */
+    capabilities?: CapabilityTag[];
+}
+/**
+ * A registry entry: what it contributes, and when it is eligible. Every role
+ * is optional and independent — an entry that only routes input declares only
+ * `bindings` and `actions`.
  */
-
-interface GestureBinding {
-    spec: GestureSpec;
-    actionId: string;
-    opts?: BindingOpts;
+interface Contribution {
+    id: string;
+    eligibility: Eligibility;
+    bindings?: GestureBinding[];
+    actions?: Action[];
+    overlay?: RenderLayer<unknown>;
+    presentation?: ToolPresentation;
+    /** Reflection escape hatch — the authored form, when there was one. */
+    def?: unknown;
 }
 
 /** Modifier-key snapshot at event dispatch time. `space` is included
@@ -2147,8 +2214,8 @@ type ToolBounds = Bounds;
  *  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. */
+ *  Note: cursor is NOT here. `Tool.cursor` (inherited from `Contribution`)
+ *  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;
@@ -2163,34 +2230,13 @@ interface ToolPresentation<TScratch = unknown> {
      *  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[];
-    /**
-     * 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[];
+/**
+ * The focus-declaring case of a `Contribution`: a mode the user switches
+ * into, plus the hooks that only make sense for one (`initScratch`,
+ * activate/deactivate, live preview, `cursor`). Everything else — bindings,
+ * actions, overlay, presentation — is inherited.
+ */
+interface Tool<TScratch = unknown> extends Contribution {
     /** 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
@@ -2200,11 +2246,9 @@ interface Tool<TScratch = unknown> {
      *  the invoker knows which tool to switch to). */
     keybinding?: ToolKeybinding;
     initScratch?: () => TScratch;
+    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
     onActivate?: (ctx: ToolCtx<TScratch>) => void;
     onDeactivate?: (ctx: ToolCtx<TScratch>) => void;
-    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
@@ -2222,26 +2266,6 @@ interface Tool<TScratch = unknown> {
      *  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 tool's entire input surface. The
-     *  gesture dispatcher consults these at active scope while this tool is
-     *  active, and at hotkey scope while it is held. See
-     *  `docs/superpowers/specs/2026-05-16-registry-unification-design.md`. */
-    bindings?: GestureBinding[];
-    /** Reflection escape hatch: when this `Tool` was produced by `defineTool`,
-     *  the source `ToolDef` is attached here so introspection consumers
-     *  (`buildRouteRegistry`, `findConflicts`, the toolkit-builder UI, the
-     *  reflection demo) can read the authored form — `hookName` in particular,
-     *  which the runtime `Tool` doesn't carry. 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';
@@ -2334,17 +2358,6 @@ interface DispatcherContext {
     activeToolId: string;
     /** Held-hotkey stack, top of stack last. */
     hotkeyStack: readonly string[];
-    /**
-     * Ids of always-on tools. Their bindings are assembled at AMBIENT scope, so
-     * they lose to the active tool on a tie — which is what "always listening,
-     * never in the way" needs. Chrome that floats over the scene lives here:
-     * `@weasel-js/hud`'s tool is the worked example.
-     *
-     * Without this an ambient tool's `bindings` were assembled nowhere at all:
-     * the walk covered hotkey and active tools plus actions' `defaultBinding`,
-     * and an ambient tool is in neither set.
-     */
-    ambientToolIds?: readonly string[];
     /** Lookup for tool definitions. */
     toolsById: ReadonlyMap<string, Tool>;
     /** Platform flag for `mod` shorthand resolution. */
@@ -2872,13 +2885,10 @@ interface ToolDef<TScratch = void> {
      *  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. */
+    /** 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;
@@ -3056,6 +3066,9 @@ interface ToolScopes {
     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
@@ -3075,10 +3088,10 @@ interface ToolScopes {
  *    ordered only by registration;
  *  - two **hotkey-capable** tools, which can stack.
  *
- * Not covered: the actions registry's `defaultBinding`s, which the dispatcher
- * also folds into ambient/hotkey scope. They're assembled somewhere else
- * entirely (`ActionsRegistry`, not `useTools`), so catching tool-vs-action
- * collisions means giving this function a second input it doesn't have yet.
+ * 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[];
 /**
@@ -3155,4 +3168,4 @@ 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 CustomPaintContext as $, type Action as A, type BooleansAdapter as B, type Condition as C, type Dims as D, type ActionEntry as E, ActionsProvider as F, type GeometryProjection as G, type HotkeyTrigger as H, type InsertExtras as I, ActiveToolContextProvider as J, ActiveToolContextProviderIfRoot as K, type ActiveToolContextProviderProps as L, type ActiveToolContextValue as M, type AreaSelectDep as N, type BindingOpts as O, type BindingScope as P, type BooleanOp as Q, type RenderLayer as R, type SliceDep as S, type Tool as T, type UseSelectionOptions as U, type VisibilityRules as V, type BooleanOpResult as W, type BoundGesture as X, type BuildRuleCtxArgs as Y, type ClipboardDep as Z, type ClipboardIngestCtx as _, type DeviceProfile as a, useAction as a$, type DepName as a0, type DepRegistry as a1, DepRegistryProvider as a2, type DispatcherContext as a3, type DragSample as a4, type EditAnchorsDep as a5, type GestureBinding as a6, IDENTITY_POSE_COMPOSITION as a7, type ImmediateInvoker as a8, type IngestCtx as a9, type SnapDep as aA, type SvgUnpacker as aB, type TextEditDep as aC, type ToolModifiers as aD, type ToolPresentation as aE, type ToolSlot as aF, type UiOngoingControl as aG, type ViewApi as aH, applyBooleanOp as aI, buildRuleCtx as aJ, clipboardCopyAction as aK, clipboardCutAction as aL, composeRectPose as aM, composeWorldPose as aN, createDispatcher as aO, decomposeRectPose as aP, describeRule as aQ, drawLayers as aR, enterTextEditAction as aS, evaluate as aT, evaluateEnabled as aU, rebaseLocalPose as aV, registerContentHandler as aW, index as aX, sliceAction as aY, specificity as aZ, translateRectPose as a_, type IngestionDep as aa, type InsertDep as ab, type InvocationCtx as ac, type Invoker as ad, type LassoSelectDep as ae, type LayoutDep as af, type MatchResult as ag, NEVER as ah, type NodeAtPointDep as ai, type OngoingHandle as aj, type OngoingInvoker as ak, type OngoingOverlay as al, type Point2 as am, PointerContextProvider as an, type PointerContextValue as ao, type PointerWorldPos as ap, type PoseAdapter as aq, type PoseComposition as ar, type ResizePolicy as as, type ResolveAllOptions as at, type ResolveOnlyResult as au, type ResolvedCandidate as av, type ScopedBinding as aw, type SelectionExtendKey as ax, type SelectionMode as ay, type Selector as az, type DetectedDeviceFacts as b, useActionsRegistry as b0, useActiveToolContext as b1, useDepRegistry as b2, useDepSource as b3, useOptionalActiveToolContext as b4, useOptionalDepRegistry as b5, usePointerContext as b6, useSelection as b7, worldPoseLookup as b8, type Conflict as b9, PREDICATE_TARGET as ba, type RegistryEntry as bb, type ToolDef as bc, type ToolScopes as bd, type ViewportToolDef as be, buildRouteRegistry as bf, defineTool as bg, defineViewportTool as bh, findConflicts as bi, findScopedConflicts as bj, formatConflict as bk, reportRouteConflicts as bl, 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 AffordanceBinding as n, type ChromeState as o, type SelectionApi as p, type ContentHandlerEntry as q, type SvgIngestOptions as r, type ActionsProp as s, type Affordance as t, type AffordanceRegion as u, type CommonAffordanceScratch as v, ALWAYS as w, type ActionDeps as x, ActionDisabledReason as y, type ActionEnabledResult as z };
+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 };