@weasel-js/routing 1.6.1 → 1.7.0

package/dist/{chunk-VEC3ACV5.js → chunk-Q3Y3DPKH.js}

@@ -1,6 +1,6 @@
-import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, matchSpec, isKnownGestureName, getGestureDescriptor, formatRoute, canonicalModifiers } from '@weasel-js/gestures';
-export { GESTURE_DESCRIPTORS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, parseRoute } from '@weasel-js/gestures';
-import { NORMAL, IMPLICIT_TAGS } from '@weasel-js/modes';
+import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, matchSpec, routeGestureForSpecKind, getGestureDescriptor, formatRoute, canonicalModifiers, specificity } from '@weasel-js/gestures';
+export { GESTURE_DESCRIPTORS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, parseRoute, routeGestureForSpecKind, specKindForRouteGesture, specificity } from '@weasel-js/gestures';
+import { activeModeOf, NORMAL, DEFAULT_MODES } from '@weasel-js/modes';
 import { resolveCursor } from '@weasel-js/cursor';
 
 // src/interactions/actions/binding.ts
@@ -44,6 +44,150 @@ function buildDepsFromRequires(action, depRegistry) {
   return deps;
 }
 
+// src/interactions/actions/scopeNode.ts
+var ScopeNode = class {
+  /** `descends`: whether reads made here answer from the active child down —
+   *  true for a root or a yoke, which chrome reads through; false for a scope,
+   *  which answers for itself even with a scope nested inside it. */
+  constructor(parent, descends) {
+    this.parent = parent;
+    this.descends = descends;
+    this.tree = parent ? parent.tree : { version: 0, listeners: /* @__PURE__ */ new Set() };
+  }
+  parent;
+  descends;
+  tree;
+  children = [];
+  activeChild = null;
+  /** Bump the tree's version and tell every listener in it. */
+  changed() {
+    this.tree.version++;
+    for (const listener of this.tree.listeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("weasel input scope: subscriber threw", err);
+      }
+    }
+  }
+  /** Join the parent's children, newest last; returns the leave. */
+  mount() {
+    const parent = this.parent;
+    if (!parent) return () => {
+    };
+    parent.children.push(this);
+    this.changed();
+    let left = false;
+    return () => {
+      if (left) return;
+      left = true;
+      const i = parent.children.lastIndexOf(this);
+      if (i !== -1) parent.children.splice(i, 1);
+      if (parent.activeChild === this) parent.activeChild = null;
+      this.changed();
+    };
+  }
+  /** Make this node the one its ancestors resolve through. */
+  activate() {
+    let moved = false;
+    for (let n = this; n.parent; n = n.parent) {
+      if (n.parent.activeChild !== n) {
+        n.parent.activeChild = n;
+        moved = true;
+      }
+    }
+    if (moved) this.changed();
+  }
+  /** The node a lookup made here starts from: down the active children, or the
+   *  newest where nothing has been activated yet. A yoke with no members yet
+   *  is passed over — there is no canvas behind it to answer. */
+  leaf() {
+    let n = this;
+    for (; ; ) {
+      const next = n.activeChild ?? n.newestMember();
+      if (!next) return n;
+      n = next;
+    }
+  }
+  newestMember() {
+    for (let i = this.children.length - 1; i >= 0; i--) {
+      const c = this.children[i];
+      if (!(c.descends && c.children.length === 0)) return c;
+    }
+    return null;
+  }
+  /** Where a read made through this node starts. */
+  start() {
+    return this.descends ? this.leaf() : this;
+  }
+  /** Whether this node is on the path a read from the root takes. */
+  isActive() {
+    let root = this;
+    while (root.parent) root = root.parent;
+    for (const n of root.leaf().chain()) if (n === this) return true;
+    return false;
+  }
+  /** This node, then each ancestor up to the root. */
+  *chain() {
+    for (let n = this; n; n = n.parent) yield n;
+  }
+};
+function pushOwner(stack, value) {
+  if (value === null) return () => {
+  };
+  stack.push(value);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const i = stack.lastIndexOf(value);
+    if (i !== -1) stack.splice(i, 1);
+  };
+}
+
+// src/interactions/actions/depNode.ts
+var DepNode = class extends ScopeNode {
+  sources = /* @__PURE__ */ new Map();
+  registry = {
+    register: (name, source) => {
+      const key = name;
+      const entry = source;
+      const stack = this.sources.get(key);
+      if (stack) stack.push(entry);
+      else this.sources.set(key, [entry]);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const cur = this.sources.get(key);
+        if (!cur) return;
+        const i = cur.lastIndexOf(entry);
+        if (i === -1) return;
+        cur.splice(i, 1);
+        if (cur.length === 0) this.sources.delete(key);
+      };
+    },
+    get: (name) => {
+      for (const n of this.start().chain()) {
+        const source = n.sources.get(name)?.at(-1);
+        if (source) return source();
+      }
+      return void 0;
+    }
+  };
+  constructor(parent, descends) {
+    super(parent, descends);
+    NODES.set(this.registry, this);
+  }
+};
+var NODES = /* @__PURE__ */ new WeakMap();
+function depNodeOf(registry) {
+  return registry ? NODES.get(registry) ?? null : null;
+}
+function createDepRegistry() {
+  return new DepNode(null, true).registry;
+}
+
 // src/interactions/actions/registry.ts
 function validateActionId(id) {
   if (id.length === 0) {
@@ -99,6 +243,8 @@ function offhandKeyFor(trigger) {
       return "Meta";
     case "shift":
       return "Shift";
+    default:
+      return trigger;
   }
 }
 function buildToolOffhandBindings(specs) {
@@ -148,7 +294,7 @@ function scopeBindings(entries, state) {
     const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
     if (scope === null) continue;
     for (const binding of entry.bindings ?? []) {
-      out.push({ binding, scope, ownerToolId: entry.id });
+      out.push({ binding, scope, ownerId: entry.id });
     }
   }
   return out;
@@ -161,34 +307,6 @@ function isDev() {
 
 // src/interactions/dispatcher/matcher.ts
 var SCOPE_PRIORITY = ["hotkey", "active", "ambient"];
-function modsCount(mods) {
-  if (!mods) return 0;
-  let n = 0;
-  if (mods.alt === true) n++;
-  if (mods.ctrl === true) n++;
-  if (mods.meta === true) n++;
-  if (mods.mod === true) n++;
-  if (mods.shift === true) n++;
-  return n;
-}
-function targetRank(target) {
-  if (target === void 0) return 0;
-  const form = parseTargetSpec(target);
-  if (form === null) return 1;
-  switch (form.form) {
-    case "kind":
-      return form.requireSelected ? 3 : 2;
-    case "affordance":
-      return 2;
-    case "body":
-      return 1;
-    case "predicate":
-      return 1;
-    default: {
-      return 1;
-    }
-  }
-}
 function targetConsultsAffordance(specTarget) {
   if (specTarget === void 0) return false;
   const form = parseTargetSpec(specTarget);
@@ -249,25 +367,6 @@ function reportDeadClaim(owner, warn) {
     `[weasel] exclusive claim by "${key}" matched no binding: no \`affordance:\` or \`kindOf\` target resolved against it, so the press was dropped.`
   );
 }
-function phaseRank(spec) {
-  if (spec === void 0) return 0;
-  const atoms = typeof spec === "string" ? [{ channel: "&", phase: spec }] : spec;
-  if (atoms.length === 0) return 0;
-  let min = 2;
-  for (const a of atoms) {
-    const rank = (a.channel === "*" ? 0 : 1) + (a.phase === "*" ? 0 : 1);
-    if (rank < min) min = rank;
-  }
-  return min;
-}
-function specificity(spec) {
-  const t = targetRank(specTargetOf(spec));
-  const mods = "mods" in spec ? spec.mods : void 0;
-  const m = modsCount(mods);
-  const p = phaseRank("phase" in spec ? spec.phase : void 0);
-  const typed = (spec.kind === "drop" || spec.kind === "paste") && spec.types !== void 0 && spec.types.length > 0 ? 2 : 1;
-  return [t, m, p, typed];
-}
 function compareSpecificity(a, b) {
   const sa = specificity(a);
   const sb = specificity(b);
@@ -281,28 +380,122 @@ function matchBest(e, bindings, isMac, engagedChannels) {
   return sorted.length > 0 ? sorted[0] : null;
 }
 function matchSorted(e, bindings, isMac, engagedChannels, warn = (m) => console.warn(m)) {
-  const out = [];
+  return matchSortedWithBarred(e, bindings, isMac, engagedChannels, { warn }).matches;
+}
+function matchSortedWithBarred(e, bindings, isMac, engagedChannels, opts = {}) {
+  const warn = opts.warn ?? ((m) => console.warn(m));
   const engaged = engagedChannels ?? EMPTY_ENGAGED;
   const exclusive = isExclusiveClaim(e);
-  const pool = exclusive ? bindings.filter((sb) => targetConsultsAffordance(specTargetOf(sb.binding.spec))) : bindings;
+  const admits = (sb) => !exclusive || targetConsultsAffordance(specTargetOf(sb.binding.spec));
+  const out = [];
+  const barred = [];
   for (const scope of SCOPE_PRIORITY) {
     const scopeMatches = [];
-    for (const sb of pool) {
+    const scopeBarred = [];
+    for (const sb of bindings) {
       if (sb.scope !== scope) continue;
-      const phaseCtx = { selfChannel: sb.ownerToolId, engagedChannels: engaged };
+      const admitted = admits(sb);
+      if (!admitted && !opts.collectBarred) continue;
+      const phaseCtx = { selfChannel: sb.ownerId, engagedChannels: engaged };
       if (matchSpec(e, sb.binding.spec, isMac, phaseCtx)) {
-        scopeMatches.push({ binding: sb.binding, scope, ownerToolId: sb.ownerToolId });
+        (admitted ? scopeMatches : scopeBarred).push({ binding: sb.binding, scope, ownerId: sb.ownerId });
       }
     }
     scopeMatches.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
+    scopeBarred.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
     out.push(...scopeMatches);
+    barred.push(...scopeBarred);
   }
   if (exclusive && out.length === 0 && bindings.length > 0) {
     reportDeadClaim(claimOf(e)?.owner, warn);
   }
-  return out;
+  const owner = exclusive ? claimOf(e)?.owner : void 0;
+  return { matches: out, barred, ...owner !== void 0 ? { claimOwner: owner } : {} };
 }
 var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
+var PREDICATE_TARGET = "predicate";
+function buildRouteRegistry(entries) {
+  const out = [];
+  for (const owner of entries) {
+    for (const binding of owner.bindings ?? []) {
+      const row = entryFor(owner.id, binding.spec, binding.actionId);
+      if (!row) continue;
+      const views = binding.opts?.views;
+      out.push(views === void 0 ? row : { ...row, views });
+    }
+  }
+  return out;
+}
+function routesForSpec(spec) {
+  const gesture = routeGestureForSpecKind(spec.kind);
+  if (!gesture) return [];
+  const descriptor = getGestureDescriptor(gesture);
+  const modifiers = parseModSpec("mods" in spec ? spec.mods : void 0);
+  const phases = phaseAtomsForSpec("phase" in spec ? spec.phase : void 0);
+  const target = descriptor.hasTarget ? routeTargetForSpec("target" in spec ? spec.target : void 0) ?? "*" : void 0;
+  const args = descriptor.arg ? routeArgsForSpec(spec, descriptor.arg.default) : [void 0];
+  return args.map((arg) => formatRoute({ phases, gesture, arg, target, modifiers }));
+}
+function entryFor(ownerId, spec, actionId) {
+  const gesture = routeGestureForSpecKind(spec.kind);
+  if (!gesture) return null;
+  const descriptor = getGestureDescriptor(gesture);
+  return {
+    ownerId,
+    actionId,
+    gesture,
+    phase: phaseOf("phase" in spec ? spec.phase : void 0),
+    modifiers: parseModSpec("mods" in spec ? spec.mods : void 0),
+    arg: descriptor.arg ? argOf(spec, descriptor.arg.default) : void 0,
+    ...descriptor.arg ? argAlternativesOf(spec, descriptor.arg.default) : {},
+    target: descriptor.hasTarget ? routeTargetForSpec("target" in spec ? spec.target : void 0) : void 0,
+    spec
+  };
+}
+function phaseOf(phase) {
+  if (phase === void 0 || phase === "*") return "any";
+  if (phase === "initial" || phase === "engaged") return phase;
+  const distinct = new Set(phase.map((atom) => atom.phase));
+  if (distinct.size !== 1) return "any";
+  const only = [...distinct][0];
+  return only === "initial" || only === "engaged" ? only : "any";
+}
+function parseModSpec(mods) {
+  if (!mods) return {};
+  const out = {};
+  for (const [name, req] of Object.entries(mods)) {
+    if (req === true) out[name] = "required";
+    else if (req === "optional") out[name] = "optional";
+  }
+  return out;
+}
+function phaseAtomsForSpec(phase) {
+  if (phase === void 0) return [{ channel: "*", phase: "*" }];
+  if (phase === "initial" || phase === "engaged" || phase === "*") {
+    return [{ channel: "&", phase }];
+  }
+  return phase;
+}
+function routeTargetForSpec(target) {
+  if (target === void 0) return void 0;
+  return typeof target === "string" ? target : PREDICATE_TARGET;
+}
+function routeArgsForSpec(spec, fallback) {
+  if ("key" in spec) return Array.isArray(spec.key) ? spec.key : [spec.key];
+  if ("fingers" in spec) return [String(spec.fingers)];
+  if ("direction" in spec) return [spec.direction ?? fallback];
+  if ("types" in spec) return [spec.types?.length ? spec.types.join("|") : fallback];
+  return [fallback];
+}
+function argOf(spec, fallback) {
+  const args = routeArgsForSpec(spec, fallback);
+  return args.length > 1 ? args.join("|") : args[0];
+}
+function argAlternativesOf(spec, fallback) {
+  const types = "types" in spec ? spec.types : void 0;
+  const alts = types?.length ? types : routeArgsForSpec(spec, fallback).filter((a) => a !== void 0);
+  return alts.length > 1 ? { argAlternatives: alts } : {};
+}
 
 // src/eligibility/deviceProfile.ts
 var COARSE_TARGET_SCALE = 1.75;
@@ -418,10 +611,118 @@ function evaluate(rule, ctx) {
   if (isWhenRule(rule)) return rule.when(ctx);
   return evaluateSelector(rule, ctx);
 }
-var DEFAULT_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
-  ...NORMAL.allows,
-  ...IMPLICIT_TAGS
-]);
+
+// src/eligibility/exclusive.ts
+function rulesExclusive(a, b) {
+  if (isAllRule(a)) return a.all.some((r) => rulesExclusive(r, b));
+  if (isAllRule(b)) return b.all.some((r) => rulesExclusive(a, r));
+  if (isAnyRule(a)) return a.any.every((r) => rulesExclusive(r, b));
+  if (isAnyRule(b)) return b.any.every((r) => rulesExclusive(a, r));
+  if (isNotRule(a)) return rulesEqual(a.not, b);
+  if (isNotRule(b)) return rulesEqual(b.not, a);
+  if (isWhenRule(a) || isWhenRule(b)) return false;
+  return selectorsExclusive(a, b);
+}
+function ruleCanHoldIn(rule, mode) {
+  return decideIn(rule, mode) !== false;
+}
+function decideIn(rule, mode) {
+  if (isAllRule(rule)) return all3(rule.all.map((r) => decideIn(r, mode)));
+  if (isAnyRule(rule)) {
+    const parts = rule.any.map((r) => decideIn(r, mode));
+    if (parts.includes(true)) return true;
+    return parts.every((p) => p === false) ? false : void 0;
+  }
+  if (isNotRule(rule)) {
+    const inner = decideIn(rule.not, mode);
+    return inner === void 0 ? void 0 : !inner;
+  }
+  if (isWhenRule(rule)) return void 0;
+  const ctx = { mode: mode.id, allowedCapabilities: mode.allowedCapabilities };
+  const settled = [
+    rule.mode === void 0 ? true : checkMode(rule.mode, ctx),
+    rule.capability === void 0 ? true : checkCapability(rule.capability, ctx)
+  ];
+  const { mode: _m, capability: _c, ...rest } = rule;
+  return all3([...settled, Object.keys(rest).length > 0 ? void 0 : true]);
+}
+function all3(parts) {
+  if (parts.includes(false)) return false;
+  return parts.every((p) => p === true) ? true : void 0;
+}
+var BOOLEAN_KEYS = [
+  "gesturing",
+  "focused",
+  "hovering",
+  "hoveringSelected",
+  "editingAnchors",
+  "resizable",
+  "coarsePointer",
+  "canHover"
+];
+function selectorsExclusive(a, b) {
+  for (const key of BOOLEAN_KEYS) {
+    if (a[key] !== void 0 && b[key] !== void 0 && a[key] !== b[key]) return true;
+  }
+  if (a.actionIs !== void 0 && b.actionIs !== void 0 && a.actionIs !== b.actionIs) return true;
+  if (a.actionIs !== void 0 && b.gesturing === false) return true;
+  if (b.actionIs !== void 0 && a.gesturing === false) return true;
+  if (a.mode !== void 0 && b.mode !== void 0 && modesExclusive(a.mode, b.mode)) return true;
+  if (a.selection && b.selection && selectionsExclusive(a.selection, b.selection)) return true;
+  if (a.capability !== void 0 && b.capability !== void 0 && capabilitiesExclusive(a.capability, b.capability)) return true;
+  return false;
+}
+function modeSet(m) {
+  if (typeof m === "string") return { in: /* @__PURE__ */ new Set([m]) };
+  if ("not" in m) return { notIn: /* @__PURE__ */ new Set([m.not]) };
+  return { in: new Set(m.in) };
+}
+function modesExclusive(a, b) {
+  const x = modeSet(a);
+  const y = modeSet(b);
+  if ("in" in x && "in" in y) return ![...x.in].some((m) => y.in.has(m));
+  if ("in" in x && "notIn" in y) return [...x.in].every((m) => y.notIn.has(m));
+  if ("notIn" in x && "in" in y) return [...y.in].every((m) => x.notIn.has(m));
+  return false;
+}
+function selectionRange(s) {
+  let lo = 0;
+  let hi = Infinity;
+  if (s.empty === true) hi = 0;
+  if (s.empty === false) lo = 1;
+  if (s.is !== void 0) {
+    lo = Math.max(lo, s.is);
+    hi = Math.min(hi, s.is);
+  }
+  if (s.atLeast !== void 0) lo = Math.max(lo, s.atLeast);
+  return [lo, hi];
+}
+function selectionsExclusive(a, b) {
+  const [alo, ahi] = selectionRange(a);
+  const [blo, bhi] = selectionRange(b);
+  return Math.max(alo, blo) > Math.min(ahi, bhi);
+}
+function capabilityTerms(c) {
+  if (typeof c === "string") return { requires: [c] };
+  if (Array.isArray(c)) return { requires: c };
+  if ("not" in c) return { requires: [], forbids: c.not };
+  return { requires: [] };
+}
+function capabilitiesExclusive(a, b) {
+  const x = capabilityTerms(a);
+  const y = capabilityTerms(b);
+  return x.forbids !== void 0 && y.requires.includes(x.forbids) || y.forbids !== void 0 && x.requires.includes(y.forbids);
+}
+function rulesEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => rulesEqual(a[k], b[k]));
+}
+var DEFAULT_ALLOWED_CAPABILITIES = activeModeOf(NORMAL).allowedCapabilities;
 function buildRuleCtx(args) {
   return {
     focused: args.focused,
@@ -455,6 +756,10 @@ function recordTrace(entry) {
   traceLog.push(entry);
   if (traceLog.length > TRACE_LIMIT) traceLog.shift();
 }
+function publishLiveDispatch(explain) {
+  if (!DEV2 || typeof window === "undefined") return;
+  window.__weaselDispatchLive__ = explain;
+}
 function recordModeSwitch(mode, from, to, detail) {
   recordTrace({
     kind: "mode",
@@ -469,11 +774,14 @@ function liveInView(binding, view) {
   const views = binding.opts?.views;
   return views === void 0 || views.includes(view);
 }
+function namesView(binding, view) {
+  return binding.opts?.views?.includes(view) ?? false;
+}
 function preferViewScoped(matches, view) {
   const named = [];
   const rest = [];
   for (const m of matches) {
-    (m.binding.opts?.views?.includes(view) ? named : rest).push(m);
+    (namesView(m.binding, view) ? named : rest).push(m);
   }
   return named.length === 0 ? [...matches] : [...named, ...rest];
 }
@@ -498,6 +806,40 @@ function filterEligible(matches, actionLookup, ruleCtx) {
     return isEligible(action, ruleCtx);
   });
 }
+function preferContextual(matches, actionLookup, holds, view) {
+  const out = [];
+  let run = [];
+  const flush = () => {
+    const gated = run.filter((m) => {
+      const action = actionLookup(m.binding.actionId);
+      return action?.eligible !== void 0 && holds(action);
+    });
+    out.push(...gated, ...run.filter((m) => !gated.includes(m)));
+    run = [];
+  };
+  for (const m of matches) {
+    const head = run[0];
+    if (head && (head.scope !== m.scope || namesView(head.binding, view) !== namesView(m.binding, view) || !sameSpecificity(head.binding.spec, m.binding.spec))) flush();
+    run.push(m);
+  }
+  flush();
+  return out;
+}
+var SPECIFICITY_PARTS = ["target", "mods", "phase", "exact"];
+function placedBy(prev, cur, view, contextual) {
+  if (namesView(prev.binding, view) !== namesView(cur.binding, view)) return { step: "view" };
+  if (prev.scope !== cur.scope) return { step: "tier" };
+  const sp = specificity(prev.binding.spec);
+  const sc = specificity(cur.binding.spec);
+  const i = sp.findIndex((v, k) => v !== sc[k]);
+  if (i >= 0) return { step: "specificity", part: SPECIFICITY_PARTS[i] };
+  return contextual ? { step: "context" } : { step: "order" };
+}
+function sameSpecificity(a, b) {
+  const sa = specificity(a);
+  const sb = specificity(b);
+  return sa.every((v, i) => v === sb[i]);
+}
 var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
 function modifiersOf(e) {
   return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
@@ -628,11 +970,11 @@ function createDispatcher(opts) {
     const ordered = [];
     for (let i = ctx.hotkeyStack.length - 1; i >= 0; i--) {
       const id = ctx.hotkeyStack[i];
-      const tool = ctx.toolsById.get(id);
-      if (tool && !ordered.includes(tool)) ordered.push(tool);
+      const entry = ctx.entriesById.get(id);
+      if (entry && !ordered.includes(entry)) ordered.push(entry);
     }
-    for (const tool of ctx.toolsById.values()) {
-      if (!ordered.includes(tool)) ordered.push(tool);
+    for (const entry of ctx.entriesById.values()) {
+      if (!ordered.includes(entry)) ordered.push(entry);
     }
     const capsCtx = ctx.getRuleCtx?.();
     const allows = capsCtx ? (tags) => tags.every((tag) => capsCtx.allowedCapabilities.has(tag)) : void 0;
@@ -646,7 +988,7 @@ function createDispatcher(opts) {
       const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
       for (const binding of actionBindings(action)) {
         if (!liveInView(binding, view)) continue;
-        result.push({ binding, scope: targetScope, ownerToolId: null });
+        result.push({ binding, scope: targetScope, ownerId: null });
       }
     }
     return result;
@@ -753,209 +1095,302 @@ function createDispatcher(opts) {
         pinchStartSpreads.delete(id);
       }
     }
-    const scopedBindings = assembleScopedBindings(ctx);
-    const engagedChannels = snapshotEngagedChannels();
-    const rawMatches = preferViewScoped(
-      matchSorted(event, scopedBindings, ctx.isMac, engagedChannels),
-      ctx.viewId ?? null
-    );
-    const traceCandidates = [];
-    const eventKey = event.kind === "key" || event.kind === "key-held" ? event.key : void 0;
-    const finishTrace = (fired, outcome) => {
-      recordTrace({
-        kind: "dispatch",
-        ts: Date.now(),
-        eventKind: event.kind,
-        ...eventKey !== void 0 ? { key: eventKey } : {},
-        candidates: traceCandidates,
-        fired,
-        outcome
-      });
-    };
-    if (rawMatches.length === 0) {
-      finishTrace(null, "unhandled");
-      return "unhandled";
-    }
-    const actionMap = buildActionMap(ctx.actions);
-    const ruleCtx = ruleCtxOf(ctx);
-    const matches = ruleCtx ? filterEligible(rawMatches, (id) => actionMap.get(id), ruleCtx) : rawMatches;
-    if (matches.length === 0) {
-      finishTrace(null, "unhandled");
-      return "unhandled";
+    const r = rank(event, ctx, DEV2);
+    const walked = walk(r, event, ctx, (match, action, deps) => invoke(event, match, action, deps), false);
+    const outcome = walked.stop === "fired" ? "handled" : "unhandled";
+    if (DEV2) recordTrace(buildRecord(r, walked, event, ctx, false, outcome));
+    return outcome;
+  }
+  function invoke(event, match, action, deps) {
+    if (action.invoker?.timing === "immediate") {
+      try {
+        const resolved = resolveParams(match.binding.opts?.params);
+        let params;
+        if (event.kind === "wheel") {
+          params = {
+            deltaX: event.deltaX,
+            deltaY: event.deltaY,
+            clientX: event.clientX,
+            clientY: event.clientY,
+            affordance: event.affordance,
+            ...resolved
+          };
+        } else if (event.kind === "pinch") {
+          params = {
+            scale: event.scale,
+            rotation: event.rotation,
+            clientX: event.clientX,
+            clientY: event.clientY,
+            affordance: event.affordance,
+            ...resolved
+          };
+        } else if (event.kind === "click" || event.kind === "doubleclick") {
+          params = {
+            worldX: event.x,
+            worldY: event.y,
+            affordance: event.affordance,
+            // Press point as well as release point — an action that places
+            // geometry at the click wants the former. See `ClickEvent`.
+            ...event.kind === "click" ? { pressX: event.pressX, pressY: event.pressY } : {},
+            mods: modifiersOf(event),
+            ...resolved
+          };
+        } else if (event.kind === "contextmenu" || event.kind === "longpress") {
+          params = {
+            worldX: event.x,
+            worldY: event.y,
+            affordance: event.affordance,
+            bodyTarget: event.bodyTarget,
+            mods: modifiersOf(event),
+            ...resolved
+          };
+        } else if (event.kind === "pointerdown") {
+          params = {
+            worldX: event.x,
+            worldY: event.y,
+            affordance: event.affordance,
+            bodyTarget: event.bodyTarget,
+            mods: modifiersOf(event),
+            ...resolved
+          };
+        } else if (event.kind === "drop" || event.kind === "paste") {
+          params = {
+            items: event.items,
+            via: event.kind,
+            ...event.kind === "drop" && event.x !== void 0 ? { worldX: event.x, worldY: event.y } : {},
+            ...resolved
+          };
+        } else {
+          params = resolved;
+        }
+        action.invoker.run(deps, params);
+      } catch (err) {
+        console.error(`weasel dispatcher: action "${action.id}" invoker threw`, err);
+      }
+      return "fired";
     }
-    const triedActionIds = /* @__PURE__ */ new Set();
-    for (const match of matches) {
-      if (triedActionIds.has(match.binding.actionId)) continue;
-      triedActionIds.add(match.binding.actionId);
-      const action = actionMap.get(match.binding.actionId);
-      if (!action) {
-        traceCandidates.push({ actionId: match.binding.actionId, scope: match.scope, enabledResult: "no-such-action" });
-        console.warn(
-          `weasel dispatcher: binding resolved actionId "${match.binding.actionId}" which has no registered action. Skipping. (misconfiguration)`
+    if (action.invoker?.timing === "ongoing") {
+      if (event.kind === "pointerdown" && event.stage === "press") {
+        console.error(
+          `weasel dispatcher: action "${action.id}" has an ongoing invoker but is bound to a pointerDown spec, which fires at press time. Bind it to a drag spec, or give the action an immediate invoker.`
         );
-        continue;
+        return "misbound";
       }
-      const deps = buildDepsFromRequires(action, ctx.depRegistry);
-      if (action.enabled) {
-        const result = action.enabled(deps, worldPointOf(event));
-        if (result !== true) {
-          traceCandidates.push({ actionId: action.id, scope: match.scope, enabledResult: String(result) });
-          continue;
-        }
+      const gestureId = gestureIdFor(event);
+      if (event.kind === "pointerdown") {
+        dragOrigins.set(gestureId, {
+          x: event.x ?? 0,
+          y: event.y ?? 0,
+          ...event.clientX !== void 0 ? { clientX: event.clientX } : {},
+          ...event.clientY !== void 0 ? { clientY: event.clientY } : {}
+        });
+        dragPoints.set(gestureId, [{
+          x: event.x ?? 0,
+          y: event.y ?? 0,
+          ...event.pressure !== void 0 ? { pressure: event.pressure } : {},
+          ...event.tiltX !== void 0 ? { tiltX: event.tiltX } : {},
+          ...event.tiltY !== void 0 ? { tiltY: event.tiltY } : {}
+        }]);
       }
-      traceCandidates.push({ actionId: action.id, scope: match.scope, enabledResult: true });
-      if (action.invoker?.timing === "immediate") {
-        try {
-          const resolved = resolveParams(match.binding.opts?.params);
-          let params;
-          if (event.kind === "wheel") {
-            params = {
-              deltaX: event.deltaX,
-              deltaY: event.deltaY,
-              clientX: event.clientX,
-              clientY: event.clientY,
-              affordance: event.affordance,
-              ...resolved
-            };
-          } else if (event.kind === "pinch") {
-            params = {
-              scale: event.scale,
-              rotation: event.rotation,
-              clientX: event.clientX,
-              clientY: event.clientY,
-              affordance: event.affordance,
-              ...resolved
-            };
-          } else if (event.kind === "click" || event.kind === "doubleclick") {
-            params = {
-              worldX: event.x,
-              worldY: event.y,
-              affordance: event.affordance,
-              // Press point as well as release point — an action that places
-              // geometry at the click wants the former. See `ClickEvent`.
-              ...event.kind === "click" ? { pressX: event.pressX, pressY: event.pressY } : {},
-              mods: modifiersOf(event),
-              ...resolved
-            };
-          } else if (event.kind === "contextmenu" || event.kind === "longpress") {
-            params = {
-              worldX: event.x,
-              worldY: event.y,
-              affordance: event.affordance,
-              bodyTarget: event.bodyTarget,
-              mods: modifiersOf(event),
-              ...resolved
-            };
-          } else if (event.kind === "pointerdown") {
-            params = {
-              worldX: event.x,
-              worldY: event.y,
-              affordance: event.affordance,
-              bodyTarget: event.bodyTarget,
-              mods: modifiersOf(event),
-              ...resolved
-            };
-          } else if (event.kind === "drop" || event.kind === "paste") {
-            params = {
-              items: event.items,
-              via: event.kind,
-              ...event.kind === "drop" && event.x !== void 0 ? { worldX: event.x, worldY: event.y } : {},
-              ...resolved
-            };
-          } else {
-            params = resolved;
-          }
-          action.invoker.run(deps, params);
-        } catch (err) {
-          console.error(`weasel dispatcher: action "${action.id}" invoker threw`, err);
-        }
-        finishTrace(action.id, "handled");
-        return "handled";
+      if (event.kind === "multitouch" && event.spread !== void 0) {
+        pinchStartSpreads.set(gestureId, event.spread);
       }
-      if (action.invoker?.timing === "ongoing") {
-        if (event.kind === "pointerdown" && event.stage === "press") {
-          console.error(
-            `weasel dispatcher: action "${action.id}" has an ongoing invoker but is bound to a pointerDown spec, which fires at press time. Bind it to a drag spec, or give the action an immediate invoker.`
-          );
-          finishTrace(action.id, "unhandled");
-          return "unhandled";
-        }
-        const gestureId = gestureIdFor(event);
+      const invCtx = buildInvocationCtx(event, deps, gestureId);
+      const handle = action.invoker.start(invCtx, match.binding.opts);
+      if (isEmptyOngoingHandle(handle)) {
         if (event.kind === "pointerdown") {
-          dragOrigins.set(gestureId, {
-            x: event.x ?? 0,
-            y: event.y ?? 0,
-            ...event.clientX !== void 0 ? { clientX: event.clientX } : {},
-            ...event.clientY !== void 0 ? { clientY: event.clientY } : {}
-          });
-          dragPoints.set(gestureId, [{
-            x: event.x ?? 0,
-            y: event.y ?? 0,
-            ...event.pressure !== void 0 ? { pressure: event.pressure } : {},
-            ...event.tiltX !== void 0 ? { tiltX: event.tiltX } : {},
-            ...event.tiltY !== void 0 ? { tiltY: event.tiltY } : {}
-          }]);
-        }
-        if (event.kind === "multitouch" && event.spread !== void 0) {
-          pinchStartSpreads.set(gestureId, event.spread);
+          dragOrigins.delete(gestureId);
+          dragPoints.delete(gestureId);
         }
-        const invCtx = buildInvocationCtx(event, deps, gestureId);
-        const handle = action.invoker.start(invCtx, match.binding.opts);
-        if (isEmptyOngoingHandle(handle)) {
-          if (event.kind === "pointerdown") {
-            dragOrigins.delete(gestureId);
-            dragPoints.delete(gestureId);
-          }
-          if (event.kind === "multitouch") {
-            pinchStartSpreads.delete(gestureId);
-          }
-          traceCandidates.push({ actionId: action.id, scope: match.scope, enabledResult: "empty-handle" });
-          continue;
+        if (event.kind === "multitouch") {
+          pinchStartSpreads.delete(gestureId);
         }
-        inFlightHandles.set(gestureId, handle);
-        inFlightOwners.set(gestureId, match.ownerToolId);
-        inFlightActions.set(gestureId, action);
-        finishTrace(action.id, "handled");
-        return "handled";
+        return "empty-handle";
       }
-      finishTrace(action.id, "handled");
-      return "handled";
+      inFlightHandles.set(gestureId, handle);
+      inFlightOwners.set(gestureId, match.ownerId);
+      inFlightActions.set(gestureId, action);
+      return "fired";
     }
-    finishTrace(null, "unhandled");
-    return "unhandled";
+    return "fired";
   }
-  function resolveAll(event, ctx, resolveOpts) {
-    const scopedBindings = assembleScopedBindings(ctx);
-    const engagedChannels = snapshotEngagedChannels();
-    const matches = preferViewScoped(
-      matchSorted(event, scopedBindings, ctx.isMac, engagedChannels),
-      ctx.viewId ?? null
+  function rank(event, ctx, collectBarred) {
+    const view = ctx.viewId ?? null;
+    const outcome = matchSortedWithBarred(
+      event,
+      assembleScopedBindings(ctx),
+      ctx.isMac,
+      snapshotEngagedChannels(),
+      { collectBarred }
     );
-    if (matches.length === 0) return [];
+    const sorted = preferViewScoped(outcome.matches, view);
     const actionMap = buildActionMap(ctx.actions);
     const ruleCtx = ruleCtxOf(ctx);
+    const held = /* @__PURE__ */ new Map();
+    const holds = (a) => {
+      if (ruleCtx === void 0) return true;
+      let h = held.get(a);
+      if (h === void 0) held.set(a, h = isEligible(a, ruleCtx));
+      return h;
+    };
+    const ordered = ruleCtx ? preferContextual(sorted, (id) => actionMap.get(id), holds, view) : sorted;
+    return {
+      ordered,
+      barred: outcome.barred,
+      ...outcome.claimOwner !== void 0 ? { claimOwner: outcome.claimOwner } : {},
+      actionMap,
+      ruleCtx,
+      eligible: (m) => {
+        const a = actionMap.get(m.binding.actionId);
+        return a === void 0 || holds(a);
+      }
+    };
+  }
+  function walk(r, event, ctx, attempt, evaluateShadowed) {
+    const steps = [];
+    const tried = /* @__PURE__ */ new Set();
+    let stop = "exhausted";
+    let winner = null;
+    for (const match of r.ordered) {
+      if (!r.eligible(match)) continue;
+      const push = (step) => {
+        steps.push({ match, step });
+      };
+      const actionId = match.binding.actionId;
+      if (tried.has(actionId)) {
+        push({ kind: "duplicate" });
+        continue;
+      }
+      if (stop !== "exhausted" && !evaluateShadowed) {
+        push({ kind: "not-asked" });
+        continue;
+      }
+      tried.add(actionId);
+      const action = r.actionMap.get(actionId);
+      if (!action) {
+        if (attempt) {
+          console.warn(
+            `weasel dispatcher: binding resolved actionId "${actionId}" which has no registered action. Skipping. (misconfiguration)`
+          );
+        }
+        push({ kind: "no-such-action" });
+        continue;
+      }
+      const deps = buildDepsFromRequires(action, ctx.depRegistry);
+      const enabled = action.enabled ? action.enabled(deps, worldPointOf(event)) : true;
+      if (enabled !== true) {
+        push({ kind: "declined", reason: String(enabled) });
+        continue;
+      }
+      if (stop !== "exhausted") {
+        push({ kind: "outranked" });
+        continue;
+      }
+      if (!attempt) {
+        push({ kind: "would-fire" });
+        stop = "fired";
+        winner = { match, action };
+        continue;
+      }
+      const result = attempt(match, action, deps);
+      if (result === "empty-handle") {
+        push({ kind: "empty-handle" });
+        continue;
+      }
+      push({ kind: result === "fired" ? "fired" : "misbound" });
+      stop = result;
+      winner = { match, action };
+    }
+    return { steps, stop, winner };
+  }
+  function buildRecord(r, walked, event, ctx, predicted, outcome) {
+    const view = ctx.viewId ?? null;
+    const candidates = /* @__PURE__ */ new Map();
+    const candidateOf = (m) => {
+      let c = candidates.get(m);
+      if (!c) {
+        const eligible = r.actionMap.get(m.binding.actionId)?.eligible;
+        c = {
+          actionId: m.binding.actionId,
+          routes: routesForSpec(m.binding.spec),
+          scope: m.scope,
+          ownerId: m.ownerId,
+          namesView: namesView(m.binding, view),
+          specificity: specificity(m.binding.spec),
+          ...eligible !== void 0 ? { eligible: describeEligible(eligible) } : {}
+        };
+        candidates.set(m, c);
+      }
+      return c;
+    };
+    const dropped = [
+      ...r.barred.map((m) => ({
+        candidate: candidateOf(m),
+        filter: "claim",
+        ...r.claimOwner !== void 0 ? { owner: r.claimOwner } : {}
+      }))
+    ];
+    for (const m of r.ordered) {
+      if (r.eligible(m)) continue;
+      const c = candidateOf(m);
+      dropped.push({ candidate: c, filter: "ineligible", rule: c.eligible ?? "" });
+    }
+    const gated = (m) => r.actionMap.get(m.binding.actionId)?.eligible !== void 0;
+    const ranked = walked.steps.map(({ match, step }, i) => {
+      const prev = walked.steps[i - 1]?.match;
+      return {
+        candidate: candidateOf(match),
+        placedBy: prev ? placedBy(prev, match, view, r.ruleCtx !== void 0 && gated(prev) && !gated(match)) : { step: "first" },
+        walk: step
+      };
+    });
+    const eventKey = event.kind === "key" || event.kind === "key-held" ? event.key : void 0;
+    const world = worldPointOf(event);
+    return {
+      kind: "dispatch",
+      ts: Date.now(),
+      input: {
+        eventKind: event.kind,
+        ...eventKey !== void 0 ? { key: eventKey } : {},
+        modifiers: modifiersOf(event),
+        viewId: view,
+        ...world !== void 0 ? { world } : {},
+        ...r.ruleCtx !== void 0 ? { mode: r.ruleCtx.mode } : {}
+      },
+      matched: [...r.ordered, ...r.barred].map(candidateOf),
+      dropped,
+      ranked,
+      predicted,
+      fired: walked.winner?.action.id ?? null,
+      outcome
+    };
+  }
+  function resolveAll(event, ctx, resolveOpts) {
+    const evaluateShadowed = resolveOpts?.evaluateShadowed ?? false;
+    const r = rank(event, ctx, false);
+    if (r.ordered.length === 0) return [];
+    const walked = walk(r, event, ctx, null, evaluateShadowed);
+    const stepOf = new Map(walked.steps.map((s) => [s.match, s.step]));
     const verdictByAction = /* @__PURE__ */ new Map();
     let fired = false;
     const out = [];
-    for (const match of matches) {
+    for (const match of r.ordered) {
       const actionId = match.binding.actionId;
-      const action = actionMap.get(actionId);
+      const action = r.actionMap.get(actionId);
       if (!action) continue;
       let verdict = verdictByAction.get(actionId);
       if (verdict === void 0) {
-        if (fired && !resolveOpts?.evaluateShadowed) {
-          verdict = { kind: "shadowed" };
-        } else if (ruleCtx && action.eligible && !isEligible(action, ruleCtx)) {
-          verdict = { kind: "ineligible", reason: describeEligible(action.eligible) };
+        if (!r.eligible(match)) {
+          verdict = fired && !evaluateShadowed ? { kind: "shadowed" } : { kind: "ineligible", reason: describeEligible(action.eligible) };
         } else {
-          const disabled = action.enabled ? action.enabled(buildDepsFromRequires(action, ctx.depRegistry), worldPointOf(event)) : true;
-          if (disabled !== true) {
-            verdict = { kind: "disabled", reason: String(disabled) };
-          } else if (fired) {
-            verdict = { kind: "shadowed" };
-          } else {
+          const step = stepOf.get(match);
+          if (step?.kind === "would-fire") {
             verdict = { kind: "would-fire" };
             fired = true;
+          } else if (step?.kind === "declined") {
+            verdict = { kind: "disabled", reason: step.reason };
+          } else {
+            verdict = { kind: "shadowed" };
           }
         }
         verdictByAction.set(actionId, verdict);
@@ -967,7 +1402,7 @@ function createDispatcher(opts) {
         action,
         binding: match.binding,
         scope: match.scope,
-        ownerToolId: match.ownerToolId,
+        ownerId: match.ownerId,
         specificity: specificity(match.binding.spec),
         verdict
       });
@@ -975,15 +1410,21 @@ function createDispatcher(opts) {
     return out;
   }
   function resolveOnly(event, ctx) {
-    const winner = resolveAll(event, ctx).find((c) => c.verdict.kind === "would-fire");
+    const r = rank(event, ctx, false);
+    const { winner } = walk(r, event, ctx, null, false);
     if (!winner) return null;
     return {
-      actionId: winner.actionId,
+      actionId: winner.action.id,
       action: winner.action,
-      scope: winner.scope,
-      ownerToolId: winner.ownerToolId
+      scope: winner.match.scope,
+      ownerId: winner.match.ownerId
     };
   }
+  function explain(event, ctx, explainOpts) {
+    const r = rank(event, ctx, true);
+    const walked = walk(r, event, ctx, null, explainOpts?.evaluateShadowed ?? false);
+    return buildRecord(r, walked, event, ctx, true, walked.winner ? "handled" : "unhandled");
+  }
   function cancelAll(reason) {
     const stubCtx = {
       world: { x: 0, y: 0 },
@@ -1123,6 +1564,7 @@ function createDispatcher(opts) {
     handleInput: handleInputWithNotify,
     resolveOnly,
     resolveAll,
+    explain,
     cancelAll: cancelAllWithNotify,
     inFlight,
     inFlightCursor,
@@ -1213,117 +1655,17 @@ function openPointerSession(origin, down, cb, opts = {}) {
   };
 }
 
-// src/tools/routing/reflection/registry.ts
-var PREDICATE_TARGET = "predicate";
-var SPEC_KIND_TO_GESTURE = {
-  key: "keyDown",
-  "key-held": "keyHeld",
-  wheel: "wheel",
-  pinch: "pinch",
-  click: "click",
-  doubleClick: "dblTap",
-  contextMenu: "contextMenu",
-  longPress: "longPress",
-  drag: "drag",
-  pointerDown: "pointerDown",
-  multiTouch: void 0,
-  multiTouchTap: "multiTouchTap",
-  drop: "drop",
-  paste: "paste"
-};
-function buildRouteRegistry(tools) {
-  const out = [];
-  for (const tool of tools) {
-    for (const binding of tool.bindings ?? []) {
-      const entry = entryFor(tool.id, binding.spec, binding.actionId);
-      if (entry) out.push(entry);
-    }
-  }
-  return out;
-}
-function routeGestureForSpecKind(kind) {
-  const gesture = SPEC_KIND_TO_GESTURE[kind];
-  return gesture && isKnownGestureName(gesture) ? gesture : void 0;
-}
-function routesForSpec(spec) {
-  const gesture = routeGestureForSpecKind(spec.kind);
-  if (!gesture) return [];
-  const descriptor = getGestureDescriptor(gesture);
-  const modifiers = parseModSpec("mods" in spec ? spec.mods : void 0);
-  const phases = phaseAtomsForSpec("phase" in spec ? spec.phase : void 0);
-  const target = descriptor.hasTarget ? routeTargetForSpec("target" in spec ? spec.target : void 0) ?? "*" : void 0;
-  const args = descriptor.arg ? routeArgsForSpec(spec, descriptor.arg.default) : [void 0];
-  return args.map((arg) => formatRoute({ phases, gesture, arg, target, modifiers }));
-}
-function entryFor(toolId, spec, actionId) {
-  const gesture = SPEC_KIND_TO_GESTURE[spec.kind];
-  if (!gesture || !isKnownGestureName(gesture)) return null;
-  const descriptor = getGestureDescriptor(gesture);
-  return {
-    toolId,
-    actionId,
-    gesture,
-    phase: phaseOf("phase" in spec ? spec.phase : void 0),
-    modifiers: parseModSpec("mods" in spec ? spec.mods : void 0),
-    arg: descriptor.arg ? argOf(spec, descriptor.arg.default) : void 0,
-    ...descriptor.arg ? argAlternativesOf(spec, descriptor.arg.default) : {},
-    target: descriptor.hasTarget ? routeTargetForSpec("target" in spec ? spec.target : void 0) : void 0,
-    spec
-  };
-}
-function phaseOf(phase) {
-  if (phase === void 0 || phase === "*") return "any";
-  if (phase === "initial" || phase === "engaged") return phase;
-  const distinct = new Set(phase.map((atom) => atom.phase));
-  if (distinct.size !== 1) return "any";
-  const only = [...distinct][0];
-  return only === "initial" || only === "engaged" ? only : "any";
-}
-function parseModSpec(mods) {
-  if (!mods) return {};
-  const out = {};
-  for (const [name, req] of Object.entries(mods)) {
-    if (req === true) out[name] = "required";
-    else if (req === "optional") out[name] = "optional";
-  }
-  return out;
-}
-function phaseAtomsForSpec(phase) {
-  if (phase === void 0) return [{ channel: "&", phase: "*" }];
-  if (phase === "initial" || phase === "engaged" || phase === "*") {
-    return [{ channel: "&", phase }];
-  }
-  return phase;
+// src/tools/types.ts
+function isTool(entry) {
+  return !!(entry.eligibility?.focus || entry.eligibility?.offhand);
 }
-function routeTargetForSpec(target) {
-  if (target === void 0) return void 0;
-  return typeof target === "string" ? target : PREDICATE_TARGET;
-}
-function routeArgsForSpec(spec, fallback) {
-  if ("key" in spec) return Array.isArray(spec.key) ? spec.key : [spec.key];
-  if ("fingers" in spec) return [String(spec.fingers)];
-  if ("direction" in spec) return [spec.direction ?? fallback];
-  if ("types" in spec) return [spec.types?.length ? spec.types.join("|") : fallback];
-  return [fallback];
+function findConflicts(entries) {
+  return findConflictsKeyed(entries).map((k) => k.conflict);
 }
-function argOf(spec, fallback) {
-  const args = routeArgsForSpec(spec, fallback);
-  return args.length > 1 ? args.join("|") : args[0];
-}
-function argAlternativesOf(spec, fallback) {
-  const types = "types" in spec ? spec.types : void 0;
-  const alts = types?.length ? types : routeArgsForSpec(spec, fallback).filter((a) => a !== void 0);
-  return alts.length > 1 ? { argAlternatives: alts } : {};
-}
-
-// src/tools/routing/reflection/conflicts.ts
-function findConflicts(tools) {
-  return findConflictsKeyed(tools).map((k) => k.conflict);
-}
-function findConflictsKeyed(tools) {
-  const entries = buildRouteRegistry(tools);
+function findConflictsKeyed(entries, rules, modes = KIT_MODES) {
+  const rows = buildRouteRegistry(entries);
   const groups = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
+  for (const entry of rows) {
     for (const arg of argKeysOf(entry)) {
       const key = `${entry.phase}|${entry.gesture}|${arg}|${targetKey(entry)}|${canonicalModifiers(entry.modifiers)}`;
       const bucket = groups.get(key);
@@ -1332,8 +1674,11 @@ function findConflictsKeyed(tools) {
       } else groups.set(key, [entry]);
     }
   }
+  const ruleOf = (entry) => rules?.get(entry.ownerId) ?? ALWAYS;
+  const tie = (e, f) => viewsTie(e.views, f.views) && rulesCanHoldTogether(ruleOf(e), ruleOf(f), modes);
   const conflicts = [];
-  for (const [key, bucket] of groups) {
+  for (const [key, all] of groups) {
+    const bucket = all.filter((e) => all.some((f) => f !== e && tie(e, f)));
     if (bucket.length < 2) continue;
     const first = bucket[0];
     conflicts.push({
@@ -1344,12 +1689,16 @@ function findConflictsKeyed(tools) {
         arg: first.arg,
         target: first.target,
         modifiers: first.modifiers,
-        toolIds: bucket.map((e) => e.toolId)
+        ownerIds: bucket.map((e) => e.ownerId)
       }
     });
   }
   return conflicts;
 }
+function viewsTie(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  return a.some((v) => b.includes(v));
+}
 function argKeysOf(entry) {
   const alts = entry.argAlternatives;
   if (alts && alts.length > 0) return [...new Set(alts.map((a) => a.toLowerCase()))];
@@ -1372,43 +1721,67 @@ function predicateId(pred) {
   }
   return id;
 }
-function actionAsTool(action) {
+function rulesCanHoldTogether(a, b, modes) {
+  if (rulesExclusive(a, b)) return false;
+  return modes.some((m) => ruleCanHoldIn(a, m) && ruleCanHoldIn(b, m));
+}
+var KIT_MODES = DEFAULT_MODES.map(activeModeOf);
+function actionAsEntry(action) {
   return { id: action.id, eligibility: {}, bindings: actionBindings(action) };
 }
+function eligibleRule(action) {
+  const eligible = action.eligible;
+  if (eligible === void 0) return void 0;
+  return typeof eligible === "function" ? eligible.rule : eligible;
+}
 function findScopedConflicts(scopes) {
   const registry = Array.isArray(scopes.registry) ? scopes.registry : Object.values(scopes.registry);
   const actions = scopes.actions ?? [];
-  const ambientActions = actions.filter((a) => a.scope !== "hotkey").map(actionAsTool);
-  const hotkeyActions = actions.filter((a) => a.scope === "hotkey").map(actionAsTool);
-  const ambient = [...scopes.ambient ?? [], ...ambientActions];
+  const rules = /* @__PURE__ */ new Map();
+  for (const a of actions) {
+    const rule = eligibleRule(a);
+    if (rule) rules.set(a.id, rule);
+  }
+  const hotkeyActions = actions.filter((a) => a.scope === "hotkey").map(actionAsEntry);
+  const gatedActions = [];
+  const ungated = [];
+  for (const a of actions) {
+    if (a.scope === "hotkey") continue;
+    (a.eligible !== void 0 ? gatedActions : ungated).push(actionAsEntry(a));
+  }
+  const modes = scopes.modes ?? KIT_MODES;
+  const ambient = [...scopes.ambient ?? [], ...ungated];
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (keyed) => {
     for (const { key, conflict } of keyed) {
-      const dedupeKey = `${key}|${conflict.toolIds.join(",")}`;
+      const dedupeKey = `${key}|${conflict.ownerIds.join(",")}`;
       if (seen.has(dedupeKey)) continue;
       seen.add(dedupeKey);
       out.push(conflict);
     }
   };
-  for (const tool of [...registry, ...ambient, ...hotkeyActions]) add(findConflictsKeyed([tool]));
-  if (ambient.length > 1) add(findConflictsKeyed(ambient));
+  for (const tool of [...registry, ...ambient, ...gatedActions, ...hotkeyActions]) {
+    add(findConflictsKeyed([tool], rules, modes));
+  }
+  if (ambient.length > 1) add(findConflictsKeyed(ambient, rules, modes));
+  if (gatedActions.length > 1) add(findConflictsKeyed(gatedActions, rules, modes));
   const hotkey = [
     ...registry.filter((t) => t.def?.hotkey !== void 0),
     ...hotkeyActions
   ];
-  if (hotkey.length > 1) add(findConflictsKeyed(hotkey));
+  if (hotkey.length > 1) add(findConflictsKeyed(hotkey, rules, modes));
   return out;
 }
 function formatConflict(conflict) {
   const route = formatRoute({
-    phases: [{ channel: "&", phase: conflict.phase === "any" ? "*" : conflict.phase }],
+    phases: [conflict.phase === "any" ? { channel: "*", phase: "*" } : { channel: "&", phase: conflict.phase }],
     gesture: conflict.gesture,
     arg: conflict.arg,
     target: conflict.target,
     modifiers: conflict.modifiers
   });
-  return `${route} \u2014 declared by ${conflict.toolIds.join(", ")}`;
+  return `${route} \u2014 declared by ${conflict.ownerIds.join(", ")}`;
 }
 function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
   const conflicts = findScopedConflicts(scopes);
@@ -1550,6 +1923,6 @@ function dlog(namespace, ...args) {
   console.debug(`[${namespace}]`, ...args);
 }
 
-export { ALWAYS, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, INGEST_STRING_MIMES, NEVER, PREDICATE_TARGET, TOOL_OFFHAND_ID, actionBindings, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, clientToCanvas, clientToCanvasRect, createDispatcher, describeRule, dlog, evaluate, filterEligible, findConflicts, isDev, isEditableTarget, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchesKeyBinding, offhandKeyFor, openPointerSession, pointerGestureId, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routeGestureForSpecKind, routesForSpec, scopeBindings, specificity, targetConsultsAffordance, validateActionDefaultBinding, validateActionId };
-//# sourceMappingURL=chunk-VEC3ACV5.js.map
-//# sourceMappingURL=chunk-VEC3ACV5.js.map
+export { ALWAYS, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DepNode, INGEST_STRING_MIMES, NEVER, PREDICATE_TARGET, ScopeNode, TOOL_OFFHAND_ID, actionBindings, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, clientToCanvas, clientToCanvasRect, createDepRegistry, createDispatcher, depNodeOf, describeRule, dlog, evaluate, filterEligible, findConflicts, isDev, isEditableTarget, isTool, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchSortedWithBarred, matchesKeyBinding, offhandKeyFor, openPointerSession, pointerGestureId, preferContextual, publishLiveDispatch, pushOwner, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routesForSpec, ruleCanHoldIn, rulesExclusive, scopeBindings, targetConsultsAffordance, validateActionDefaultBinding, validateActionId };
+//# sourceMappingURL=chunk-Q3Y3DPKH.js.map
+//# sourceMappingURL=chunk-Q3Y3DPKH.js.map