@weasel-js/routing 1.9.4 → 1.10.1

package/dist/{chunk-Y5RURZBH.js → chunk-VCEIQ64H.js}

@@ -1,8 +1,18 @@
-import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, matchSpec, routeGestureForSpecKind, getGestureDescriptor, formatRoute, canonicalModifiers, VALID_MOD_NAMES, 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 { createEmitter } from '@weasel-js/registry';
+import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, routeGestureForSpecKind, getGestureDescriptor, formatRoute, parseTargetSpec, matchSpec, canonicalModifiers, UNKNOWN_MIME, specificity, VALID_MOD_NAMES, stylusOf } from '@weasel-js/gestures';
+export { GESTURE_DESCRIPTORS, LONG_PRESS_MS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, activatesFocusedControl, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, focusedControlOwnsKey, formatPhaseAtom, formatRoute, getGestureDescriptor, isEditableTarget, isKnownGestureName, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, parseRoute, routeGestureForSpecKind, specKindForRouteGesture, specificity } from '@weasel-js/gestures';
+import { activeModeOf, NORMAL, DEFAULT_MODES, capabilitiesAllowed } from '@weasel-js/modes';
 import { resolveCursor } from '@weasel-js/cursor';
 
+// src/interactions/actions/action.ts
+var ActionDisabledReason = {
+  SelectionRequired: "selection-required",
+  SceneEmpty: "scene-empty",
+  NotApplicable: "not-applicable",
+  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
+  PredicateThrew: "predicate-threw"
+};
+
 // src/interactions/actions/binding.ts
 function actionBindings(action) {
   const gs = action.defaultBinding;
@@ -16,6 +26,53 @@ function actionBindings(action) {
   });
 }
 
+// src/devFlag.ts
+function isDev() {
+  return typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+}
+
+// src/interactions/actions/actionEnabled.ts
+var enabledSlowWarned = /* @__PURE__ */ new Set();
+var enabledThrewWarned = /* @__PURE__ */ new Set();
+var ENABLED_BUDGET_MS = 4;
+function evaluateEnabled(action, deps) {
+  if (!action.enabled) return { enabled: true };
+  const dev = isDev();
+  const now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
+  const start = dev ? now() : 0;
+  try {
+    const result = action.enabled(deps);
+    if (dev) {
+      const elapsed = now() - start;
+      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {
+        enabledSlowWarned.add(action.id);
+        console.warn(
+          `weasel actions: enabled() for action "${action.id}" took ${elapsed.toFixed(2)}ms (budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast \u2014 see Action.enabled JSDoc.`
+        );
+      }
+    }
+    if (result === true) return { enabled: true };
+    return { enabled: false, reason: result };
+  } catch (e) {
+    if (dev && !enabledThrewWarned.has(action.id)) {
+      enabledThrewWarned.add(action.id);
+      console.warn(
+        `weasel actions: enabled() for action "${action.id}" threw; treating as disabled. The predicate must not throw \u2014 see Action.enabled JSDoc.`,
+        e
+      );
+    }
+    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };
+  }
+}
+function evaluateActive(action, deps) {
+  if (!action.active) return void 0;
+  try {
+    return action.active(deps) === true;
+  } catch {
+    return false;
+  }
+}
+
 // src/interactions/actions/buildDeps.ts
 var DEV = (() => {
   try {
@@ -43,8 +100,6 @@ 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,
@@ -52,7 +107,7 @@ var ScopeNode = class {
   constructor(parent, descends) {
     this.parent = parent;
     this.descends = descends;
-    this.tree = parent ? parent.tree : { version: 0, listeners: /* @__PURE__ */ new Set() };
+    this.tree = parent ? parent.tree : { version: 0, listeners: createEmitter() };
   }
   parent;
   descends;
@@ -62,13 +117,7 @@ var ScopeNode = class {
   /** 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);
-      }
-    }
+    this.tree.listeners.emit();
   }
   /** Join the parent's children, newest last; returns the leave. */
   mount() {
@@ -176,12 +225,7 @@ var DepNode = class extends ScopeNode {
       }
       return void 0;
     },
-    subscribe: (listener) => {
-      this.tree.listeners.add(listener);
-      return () => {
-        this.tree.listeners.delete(listener);
-      };
-    },
+    subscribe: (listener) => this.tree.listeners.subscribe(listener),
     changed: () => this.changed()
   };
   constructor(parent, descends) {
@@ -238,6 +282,47 @@ function resolveParams(params) {
   return typeof params === "function" ? params() : params;
 }
 
+// src/interactions/actions/tuning.ts
+var WRAPS = /* @__PURE__ */ new WeakMap();
+function layered(under, over) {
+  if (typeof under !== "function" && typeof over !== "function") return { ...under, ...over };
+  return () => ({ ...resolveParams(under), ...resolveParams(over) });
+}
+function wrapInvoker(invoker, params) {
+  for (let w = invoker; w; w = WRAPS.get(w)?.inner) {
+    if (WRAPS.get(w)?.params === params) return invoker;
+  }
+  const base = (given) => ({ ...resolveParams(params), ...given });
+  const wrapped = invoker.timing === "immediate" ? { timing: "immediate", run: (deps, given) => invoker.run(deps, base(given)) } : {
+    timing: "ongoing",
+    start: (ctx, opts) => invoker.start(
+      ctx.params ? { ...ctx, params: base(ctx.params) } : ctx,
+      { ...opts, params: layered(params, opts?.params) }
+    )
+  };
+  WRAPS.set(wrapped, { inner: invoker, params });
+  return wrapped;
+}
+function withBindings(own, added) {
+  const base = own === void 0 ? [] : Array.isArray(own) ? own : [own];
+  return [...base, ...added.filter((b) => !base.includes(b))];
+}
+function tuneOnce(action, tuning) {
+  const invoker = tuning.params && action.invoker ? wrapInvoker(action.invoker, tuning.params) : action.invoker;
+  const bindings = tuning.bindings?.length ? withBindings(action.defaultBinding, tuning.bindings) : null;
+  if (invoker === action.invoker && bindings === null) return action;
+  return {
+    ...action,
+    ...invoker ? { invoker } : {},
+    ...bindings ? { defaultBinding: bindings } : {}
+  };
+}
+function tuneAction(action, tunings) {
+  let out = action;
+  for (const t of tunings) out = tuneOnce(out, t);
+  return out;
+}
+
 // src/interactions/actions/toolOffhand.ts
 var TOOL_OFFHAND_ID = "tool.offhand";
 function offhandKeyFor(trigger) {
@@ -257,8 +342,12 @@ function offhandKeyFor(trigger) {
   }
 }
 function buildToolOffhandBindings(specs) {
-  return specs.map(({ toolId, key }) => ({ spec: heldKeySpec(key), opts: { params: { toolId } } }));
+  return specs.map(({ toolId, key }) => ({
+    spec: { ...heldKeySpec(key), phase: BETWEEN_GESTURES },
+    opts: { params: { toolId } }
+  }));
 }
+var BETWEEN_GESTURES = [{ channel: "*", phase: "initial" }];
 function heldKeySpec(key) {
   const isModifier = [key].flat().some((k) => MODIFIER_KEYS.has(k));
   return { kind: "key-held", key, mods: { ...isModifier ? ANY_MODS : SHIFT_OR_ALT } };
@@ -289,56 +378,95 @@ function makeToolOffhandAction(bindings) {
     requires: ["activeTool"]
   };
 }
-
-// src/contributions/eligibility.ts
-function liveScope(id, eligibility, state) {
-  const tags = eligibility.capabilities;
-  if (tags && tags.length > 0 && state.allows && !state.allows(tags)) return null;
-  if (state.engagedIds?.has(id)) return "hotkey";
-  if (eligibility.focus && state.focusedId === id) return "active";
-  if (eligibility.always || eligibility.claimed) return "ambient";
-  return null;
-}
-
-// src/contributions/assemble.ts
-function scopeBindings(entries, state) {
+var PREDICATE_TARGET = "predicate";
+function buildRouteRegistry(entries) {
   const out = [];
-  for (const entry of entries) {
-    const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
-    if (scope === null) continue;
-    for (const binding of entry.bindings ?? []) {
-      out.push({ binding, scope, ownerId: entry.id });
+  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, params, yields } = binding.opts ?? {};
+      out.push({
+        ...row,
+        ...views === void 0 ? {} : { views },
+        ...params === void 0 ? {} : { params },
+        ...yields ? { yields: true } : {}
+      });
     }
   }
   return out;
 }
-function assembleEntries(entries, inputs) {
-  const all = [...entries];
-  const ordered = [];
-  for (let i = inputs.hotkeyStack.length - 1; i >= 0; i--) {
-    const entry = all.find((e) => e.id === inputs.hotkeyStack[i]);
-    if (entry && !ordered.includes(entry)) ordered.push(entry);
-  }
-  for (const entry of all) {
-    if (!ordered.includes(entry)) ordered.push(entry);
-  }
-  const allowed = inputs.allowedCapabilities;
+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 {
-    ordered,
-    state: {
-      focusedId: inputs.focusedId,
-      engagedIds: new Set(inputs.hotkeyStack),
-      ...allowed ? { allows: (tags) => tags.every((tag) => allowed.has(tag)) } : {}
-    }
+    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
   };
 }
-
-// src/devFlag.ts
-function isDev() {
-  return typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+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 (spec.kind === "hover") return [spec.motion ?? 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/interactions/dispatcher/matcher.ts
 var SCOPE_PRIORITY = ["hotkey", "active", "ambient"];
 function targetConsultsAffordance(specTarget) {
   if (specTarget === void 0) return false;
@@ -446,89 +574,6 @@ function matchSortedWithBarred(e, bindings, isMac, engagedChannels, opts = {}) {
   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;
@@ -788,9 +833,9 @@ function recordTrace(entry) {
   traceLog.push(entry);
   if (traceLog.length > TRACE_LIMIT) traceLog.shift();
 }
-function publishLiveDispatch(explain) {
+function publishLiveDispatch(explain2) {
   if (!DEV2 || typeof window === "undefined") return;
-  window.__weaselDispatchLive__ = explain;
+  window.__weaselDispatchLive__ = explain2;
 }
 function recordModeSwitch(mode, from, to, detail) {
   recordTrace({
@@ -803,33 +848,168 @@ function recordModeSwitch(mode, from, to, detail) {
   });
 }
 
-// src/interactions/dispatcher/inputFacts.ts
-function modifiersOf(e) {
-  return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
+// src/interactions/dispatcher/gestureIds.ts
+function pointerGestureId(pointerId) {
+  return `pointer-${pointerId ?? "mouse"}`;
 }
-function worldPointOf(event) {
-  switch (event.kind) {
-    case "pointerdown":
-    case "longpress":
-    case "click":
-    case "doubleclick":
-    case "contextmenu":
-      return event.x !== void 0 && event.y !== void 0 ? { x: event.x, y: event.y } : void 0;
-    default:
-      return void 0;
-  }
+function multiTouchGestureId(fingers) {
+  return `multitouch-${fingers}`;
 }
-
-// src/interactions/dispatcher/ranking.ts
-function liveInView(binding, view) {
-  const views = binding.opts?.views;
-  return views === void 0 || views.includes(view);
+function isMultiTouchGestureId(gestureId) {
+  return gestureId.startsWith("multitouch-");
 }
-function namesView(binding, view) {
-  return binding.opts?.views?.includes(view) ?? false;
+function gestureIdFor(event) {
+  if (event.kind === "key-held") {
+    return `key-held-${event.code ?? event.key}`;
+  }
+  if (event.kind === "pointerdown" || event.kind === "pointermove" || event.kind === "pointerup" || event.kind === "pointercancel") {
+    return pointerGestureId(event.pointerId);
+  }
+  if (event.kind === "multitouch") {
+    return multiTouchGestureId(event.fingers);
+  }
+  return `ongoing-${event.kind}`;
 }
-function preferViewScoped(matches, view) {
-  const named = [];
+
+// src/contributions/eligibility.ts
+function liveScope(id, eligibility, state) {
+  const tags = eligibility.capabilities;
+  if (tags && state.allows && !state.allows(tags)) return null;
+  if (state.engagedIds?.has(id)) return "hotkey";
+  if (eligibility.focus && state.focusedId === id) return "active";
+  if (eligibility.always || eligibility.claimed) return "ambient";
+  return null;
+}
+function scopeBindings(entries, state) {
+  const out = [];
+  for (const entry of entries) {
+    const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
+    if (scope === null) continue;
+    for (const binding of entry.bindings ?? []) {
+      out.push({ binding, scope, ownerId: entry.id });
+    }
+  }
+  return out;
+}
+function assembleEntries(entries, inputs) {
+  const all = [...entries];
+  const ordered = [];
+  for (let i = inputs.hotkeyStack.length - 1; i >= 0; i--) {
+    const entry = all.find((e) => e.id === inputs.hotkeyStack[i]);
+    if (entry && !ordered.includes(entry)) ordered.push(entry);
+  }
+  for (const entry of all) {
+    if (!ordered.includes(entry)) ordered.push(entry);
+  }
+  const allowed = inputs.allowedCapabilities;
+  return {
+    ordered,
+    state: {
+      focusedId: inputs.focusedId,
+      engagedIds: new Set(inputs.hotkeyStack),
+      ...allowed ? { allows: (tags) => capabilitiesAllowed(allowed, tags) } : {}
+    }
+  };
+}
+
+// src/interactions/dispatcher/inputFacts.ts
+function modifiersOf(e) {
+  return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
+}
+function worldPointOf(event) {
+  switch (event.kind) {
+    case "pointerdown":
+    case "hover":
+    case "longpress":
+    case "click":
+    case "doubleclick":
+    case "contextmenu":
+      return event.x !== void 0 && event.y !== void 0 ? { x: event.x, y: event.y } : void 0;
+    default:
+      return void 0;
+  }
+}
+function carriedBy(event) {
+  return event.kind === "drop" || event.kind === "paste" ? { items: event.items } : void 0;
+}
+function immediateParams(event, resolved) {
+  switch (event.kind) {
+    case "wheel":
+      return {
+        deltaX: event.deltaX,
+        deltaY: event.deltaY,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        affordance: event.affordance,
+        ...resolved
+      };
+    case "pinch":
+      return {
+        scale: event.scale,
+        rotation: event.rotation,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        affordance: event.affordance,
+        ...resolved
+      };
+    case "click":
+    case "doubleclick":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        affordance: event.affordance,
+        // The press point too: an action that places geometry at the click wants it.
+        ...event.kind === "click" ? { pressX: event.pressX, pressY: event.pressY } : {},
+        mods: modifiersOf(event),
+        ...resolved
+      };
+    // Only a `stage: 'press'` pointerdown reaches an immediate invoker: the
+    // buffered copy matches `drag` specs, which are ongoing.
+    case "pointerdown":
+    case "contextmenu":
+    case "longpress":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        affordance: event.affordance,
+        bodyTarget: event.bodyTarget,
+        mods: modifiersOf(event),
+        ...resolved
+      };
+    case "hover":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        affordance: event.affordance,
+        bodyTarget: event.bodyTarget,
+        mods: modifiersOf(event),
+        ...resolved
+      };
+    case "drop":
+    case "paste":
+      return {
+        items: event.items,
+        via: event.kind,
+        ...event.kind === "drop" && event.x !== void 0 ? { worldX: event.x, worldY: event.y } : {},
+        ...resolved
+      };
+    default:
+      return resolved;
+  }
+}
+
+// src/interactions/dispatcher/ranking.ts
+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) {
     (namesView(m.binding, view) ? named : rest).push(m);
@@ -948,609 +1128,332 @@ function buildDispatchRecord(r, walked, event, ctx, predicted, outcome) {
     outcome
   };
 }
-
-// src/interactions/dispatcher/dispatcher.ts
-function pointerGestureId(pointerId) {
-  return `pointer-${pointerId ?? "mouse"}`;
-}
-var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
-function createDispatcher(opts) {
-  const inFlightHandles = /* @__PURE__ */ new Map();
-  const inFlightOwners = /* @__PURE__ */ new Map();
-  const inFlightActions = /* @__PURE__ */ new Map();
-  const dragOrigins = /* @__PURE__ */ new Map();
-  const subscribers = /* @__PURE__ */ new Set();
-  let version = 0;
-  function notify() {
-    version++;
-    for (const fn of subscribers) fn();
-  }
-  const dragPoints = /* @__PURE__ */ new Map();
-  const pinchStartSpreads = /* @__PURE__ */ new Map();
-  let uiOngoingSeq = 0;
-  const uiOngoingByAction = /* @__PURE__ */ new Map();
-  function isEmptyOngoingHandle(h) {
-    return !h.onMove && !h.onEnd && !h.overlay && !h.previewIds && !h.previewPose;
-  }
-  let routedView;
-  function buildUiInvocationCtx(deps, params) {
-    return {
-      world: { x: 0, y: 0 },
-      modifiers: { alt: false, ctrl: false, meta: false, shift: false },
-      deps,
-      ...params !== void 0 ? { params } : {}
-    };
-  }
-  function buildInvocationCtx(event, deps, gestureId) {
-    const modifiers = {
-      alt: event.altKey,
-      ctrl: event.ctrlKey,
-      meta: event.metaKey,
-      shift: event.shiftKey
-    };
-    const base = {
-      world: { x: 0, y: 0 },
-      modifiers,
-      deps,
-      ...routedView !== void 0 ? { viewId: routedView } : {}
-    };
-    const clientPoint = (ev) => {
-      const cx = ev.clientX;
-      const cy = ev.clientY;
-      return cx !== void 0 && cy !== void 0 ? { x: cx, y: cy } : void 0;
-    };
-    const screen = clientPoint(event);
-    if (screen) base.screen = screen;
-    if (event.kind === "key") {
-      base.key = { key: event.key, repeat: event.repeat ?? false };
-    } else if (event.kind === "key-held") {
-      base.key = { key: event.key, repeat: false };
-    } else if (event.kind === "wheel") {
-      base.wheel = { deltaX: event.deltaX, deltaY: event.deltaY, deltaZ: 0 };
-    } else if (event.kind === "pinch") {
-      base.pinch = { scale: event.scale, rotation: event.rotation };
-    } else if (event.kind === "pointerdown" || event.kind === "click" || event.kind === "doubleclick" || event.kind === "contextmenu") {
-      const sx = event.x ?? (event.kind === "click" ? event.pressX : void 0) ?? 0;
-      const sy = event.y ?? (event.kind === "click" ? event.pressY : void 0) ?? 0;
-      base.world = { x: sx, y: sy };
-      const affordance = event.kind === "pointerdown" ? event.affordance : void 0;
-      base.drag = {
-        start: { x: sx, y: sy },
-        current: { x: sx, y: sy },
-        delta: { x: 0, y: 0 },
-        ...affordance !== void 0 ? { affordance } : {}
-      };
-    } else if (event.kind === "pointermove" || event.kind === "pointerup") {
-      const cx = event.x;
-      const cy = event.y;
-      base.world = { x: cx, y: cy };
-      const origin = gestureId ? dragOrigins.get(gestureId) : void 0;
-      const ox = origin?.x ?? cx;
-      const oy = origin?.y ?? cy;
-      const live = gestureId ? dragPoints.get(gestureId) : void 0;
-      const points = live && event.kind === "pointerup" ? [...live] : live;
-      const eventClientX = event.clientX;
-      const eventClientY = event.clientY;
-      const hasClient = eventClientX !== void 0 && eventClientY !== void 0 && origin?.clientX !== void 0 && origin?.clientY !== void 0;
-      base.drag = {
-        start: { x: ox, y: oy },
-        current: { x: cx, y: cy },
-        delta: { x: cx - ox, y: cy - oy },
-        ...hasClient ? { screenDelta: { x: eventClientX - origin.clientX, y: eventClientY - origin.clientY } } : {},
-        ...points !== void 0 ? { points } : {}
-      };
-    } else if (event.kind === "multitouch") {
-      const centroid = event.centroid ?? { x: 0, y: 0 };
-      const spread = event.spread ?? 1;
-      const startSpread = gestureId ? pinchStartSpreads.get(gestureId) : void 0;
-      base.multiTouch = {
-        centroid,
-        spread,
-        rotation: 0,
-        ...startSpread !== void 0 && event.spread !== void 0 ? { pinch: { startSpread, currentSpread: spread, centroid } } : {}
-      };
-    }
-    return base;
-  }
-  function gestureIdFor(event) {
-    if (event.kind === "key-held") {
-      return `key-held-${event.code ?? event.key}`;
-    }
-    if (event.kind === "pointerdown" || event.kind === "pointermove" || event.kind === "pointerup" || event.kind === "pointercancel") {
-      return pointerGestureId(event.pointerId);
-    }
-    if (event.kind === "multitouch") {
-      return `multitouch-${event.fingers}`;
-    }
-    return `ongoing-${event.kind}`;
-  }
-  function assembleScopedBindings(ctx) {
-    const allowedCapabilities = ctx.getRuleCtx?.()?.allowedCapabilities;
-    const { ordered, state } = assembleEntries(ctx.entriesById.values(), {
-      focusedId: ctx.activeToolId,
-      hotkeyStack: ctx.hotkeyStack,
-      ...allowedCapabilities ? { allowedCapabilities } : {}
-    });
-    const view = ctx.viewId ?? null;
-    const result = scopeBindings(ordered, state).filter((sb) => liveInView(sb.binding, view));
-    for (const action of ctx.actions.list()) {
-      const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
-      for (const binding of actionBindings(action)) {
-        if (!liveInView(binding, view)) continue;
-        result.push({ binding, scope: targetScope, ownerId: null });
-      }
-    }
-    return result;
-  }
-  function snapshotEngagedChannels() {
-    if (inFlightOwners.size === 0) return EMPTY_ENGAGED2;
-    const out = /* @__PURE__ */ new Set();
-    for (const owner of inFlightOwners.values()) {
-      if (owner != null) out.add(owner);
-    }
-    return out;
-  }
-  function buildActionMap(registry) {
-    const map = /* @__PURE__ */ new Map();
-    for (const action of registry.list()) {
-      map.set(action.id, action);
-    }
-    return map;
-  }
-  function runOnEnd(gestureId, handle, endCtx, reason) {
-    try {
-      handle.onEnd?.(endCtx, reason);
-    } catch (err) {
-      console.error(`weasel dispatcher: gesture "${gestureId}" threw on onEnd`, err);
-    }
-  }
-  function endGesture(gestureId, event, reason) {
-    const handle = inFlightHandles.get(gestureId);
-    if (!handle) return false;
-    const endCtx = buildInvocationCtx(event, {}, gestureId);
-    inFlightHandles.delete(gestureId);
-    inFlightOwners.delete(gestureId);
-    inFlightActions.delete(gestureId);
-    dragOrigins.delete(gestureId);
-    dragPoints.delete(gestureId);
-    pinchStartSpreads.delete(gestureId);
-    runOnEnd(gestureId, handle, endCtx, reason);
-    return true;
-  }
-  function handleInput(event, ctx) {
-    routedView = ctx.viewId;
-    if (event.kind === "key-held" && event.phase === "up") {
-      const gestureId = gestureIdFor(event);
-      return endGesture(gestureId, event, "commit") ? "handled" : "unhandled";
-    }
-    if (event.kind === "key-held" && event.phase === "down") {
-      const gestureId = gestureIdFor(event);
-      if (inFlightHandles.has(gestureId)) {
-        return "handled";
-      }
-    }
-    if (event.kind === "pointermove") {
-      const gestureId = gestureIdFor(event);
-      const handle = inFlightHandles.get(gestureId);
-      if (!handle) return "unhandled";
-      const pts = dragPoints.get(gestureId);
-      if (pts) {
-        pts.push({
-          x: event.x,
-          y: event.y,
-          ...event.pressure !== void 0 ? { pressure: event.pressure } : {},
-          ...event.tiltX !== void 0 ? { tiltX: event.tiltX } : {},
-          ...event.tiltY !== void 0 ? { tiltY: event.tiltY } : {}
-        });
-      }
-      if (handle.onMove) {
-        const moveCtx = buildInvocationCtx(event, {}, gestureId);
-        handle.onMove(moveCtx);
-        return "handled";
-      }
-      return "unhandled";
-    }
-    if (event.kind === "pointerup") {
-      const gestureId = gestureIdFor(event);
-      return endGesture(gestureId, event, "commit") ? "handled" : "unhandled";
-    }
-    if (event.kind === "pointercancel") {
-      const gestureId = gestureIdFor(event);
-      return endGesture(gestureId, event, "cancel") ? "handled" : "unhandled";
-    }
-    if (event.kind === "multitouch" && event.end !== void 0) {
-      let ended = false;
-      for (const id of [...inFlightHandles.keys()]) {
-        if (id.startsWith("multitouch-")) ended = endGesture(id, event, event.end) || ended;
-      }
-      return ended ? "handled" : "unhandled";
-    }
-    if (event.kind === "multitouch" && event.centroid !== void 0) {
-      const gestureId = gestureIdFor(event);
-      const handle = inFlightHandles.get(gestureId);
-      if (handle?.onMove) {
-        const moveCtx = buildInvocationCtx(event, {}, gestureId);
-        handle.onMove(moveCtx);
-        return "handled";
-      }
-      for (const id of [...inFlightHandles.keys()]) {
-        if (id.startsWith("multitouch-") && id !== gestureId) endGesture(id, event, "cancel");
-      }
-    }
-    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(buildDispatchRecord(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";
-    }
-    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.`
-        );
-        return "misbound";
-      }
-      const gestureId = gestureIdFor(event);
+function createGestureFacts() {
+  const origins = /* @__PURE__ */ new Map();
+  const points = /* @__PURE__ */ new Map();
+  const startSpreads = /* @__PURE__ */ new Map();
+  const turns = /* @__PURE__ */ new Map();
+  return {
+    begin(gestureId, event) {
       if (event.kind === "pointerdown") {
-        dragOrigins.set(gestureId, {
+        origins.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 } : {}
-        }]);
+        points.set(gestureId, [{ x: event.x ?? 0, y: event.y ?? 0, ...stylusOf(event) }]);
       }
       if (event.kind === "multitouch" && event.spread !== void 0) {
-        pinchStartSpreads.set(gestureId, event.spread);
+        startSpreads.set(gestureId, event.spread);
       }
-      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);
-        }
-        return "empty-handle";
+      if (event.kind === "multitouch" && event.angle !== void 0) {
+        turns.set(gestureId, { last: event.angle, total: 0 });
       }
-      inFlightHandles.set(gestureId, handle);
-      inFlightOwners.set(gestureId, match.ownerId);
-      inFlightActions.set(gestureId, action);
-      return "fired";
-    }
-    return "fired";
-  }
-  function rank(event, ctx, collectBarred) {
-    const view = ctx.viewId ?? null;
-    const outcome = matchSortedWithBarred(
-      event,
-      assembleScopedBindings(ctx),
-      ctx.isMac,
-      snapshotEngagedChannels(),
-      { collectBarred }
-    );
-    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 });
+    },
+    sample(gestureId, event) {
+      points.get(gestureId)?.push({ x: event.x, y: event.y, ...stylusOf(event) });
+    },
+    turn(gestureId, event) {
+      const turn = turns.get(gestureId);
+      if (!turn || event.angle === void 0) return;
+      const step = event.angle - turn.last;
+      turn.total += step - 360 * Math.round(step / 360);
+      turn.last = event.angle;
+    },
+    of(gestureId) {
+      if (gestureId === void 0) return {};
+      const origin = origins.get(gestureId);
+      const trail = points.get(gestureId);
+      const startSpread = startSpreads.get(gestureId);
+      const turn = turns.get(gestureId);
+      return {
+        ...origin !== void 0 ? { origin } : {},
+        ...trail !== void 0 ? { points: trail } : {},
+        ...startSpread !== void 0 ? { startSpread } : {},
+        ...turn !== void 0 ? { rotation: turn.total } : {}
       };
-      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;
+    },
+    drop(gestureId) {
+      origins.delete(gestureId);
+      points.delete(gestureId);
+      startSpreads.delete(gestureId);
+      turns.delete(gestureId);
+    },
+    clear() {
+      origins.clear();
+      points.clear();
+      startSpreads.clear();
+      turns.clear();
+    }
+  };
+}
+var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
+function createInFlightGestures() {
+  const handles = /* @__PURE__ */ new Map();
+  const owners = /* @__PURE__ */ new Map();
+  const actions = /* @__PURE__ */ new Map();
+  const forget = (gestureId) => {
+    handles.delete(gestureId);
+    owners.delete(gestureId);
+    actions.delete(gestureId);
+  };
+  return {
+    handles,
+    open(gestureId, handle, ownerId, action) {
+      handles.set(gestureId, handle);
+      owners.set(gestureId, ownerId);
+      if (action) actions.set(gestureId, action);
+    },
+    take(gestureId) {
+      const handle = handles.get(gestureId);
+      forget(gestureId);
+      return handle;
+    },
+    takeAll() {
+      const all = [...handles];
+      handles.clear();
+      owners.clear();
+      actions.clear();
+      return all;
+    },
+    engagedOwners() {
+      if (owners.size === 0) return EMPTY_ENGAGED2;
+      const out = /* @__PURE__ */ new Set();
+      for (const owner of owners.values()) {
+        if (owner != null) out.add(owner);
       }
-      if (!attempt) {
-        push({ kind: "would-fire" });
-        stop = "fired";
-        winner = { match, action };
-        continue;
+      return out;
+    },
+    cursor() {
+      let cursor = null;
+      for (const [id, handle] of handles) {
+        const action = actions.get(id);
+        const spec = handle.cursor?.() ?? action?.activeCursor ?? action?.cursor;
+        if (spec !== void 0 && resolveCursor(spec)) cursor = spec;
       }
-      const result = attempt(match, action, deps);
-      if (result === "empty-handle") {
-        push({ kind: "empty-handle" });
-        continue;
+      return cursor;
+    },
+    latest() {
+      let lastId = null;
+      let lastHandle = null;
+      for (const [id, handle] of handles) {
+        lastId = id;
+        lastHandle = handle;
       }
-      push({ kind: result === "fired" ? "fired" : "misbound" });
-      stop = result;
-      winner = { match, action };
+      if (lastHandle === null) return { kind: null, id: null };
+      return { kind: lastHandle.kind ?? null, id: lastId };
     }
-    return { steps, stop, winner };
-  }
-  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 r.ordered) {
-      const actionId = match.binding.actionId;
-      const action = r.actionMap.get(actionId);
-      if (!action) continue;
-      let verdict = verdictByAction.get(actionId);
-      if (verdict === void 0) {
-        if (!r.eligible(match)) {
-          verdict = fired && !evaluateShadowed ? { kind: "shadowed" } : { kind: "ineligible", reason: describeEligible(action.eligible) };
-        } 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);
-      } else if (verdict.kind === "would-fire") {
-        verdict = { kind: "shadowed" };
-      }
-      out.push({
-        actionId,
-        action,
-        binding: match.binding,
-        scope: match.scope,
-        ownerId: match.ownerId,
-        specificity: specificity(match.binding.spec),
-        verdict
-      });
+  };
+}
+function isEmptyOngoingHandle(h) {
+  return !h.onMove && !h.onEnd && !h.overlay && !h.previewIds && !h.previewPose;
+}
+
+// src/interactions/dispatcher/invocationCtx.ts
+function uiInvocationCtx(deps, params) {
+  return {
+    world: { x: 0, y: 0 },
+    modifiers: { alt: false, ctrl: false, meta: false, shift: false },
+    deps,
+    ...params !== void 0 ? { params } : {}
+  };
+}
+function clientPoint(ev) {
+  const cx = ev.clientX;
+  const cy = ev.clientY;
+  return cx !== void 0 && cy !== void 0 ? { x: cx, y: cy } : void 0;
+}
+function pressDrag(event) {
+  const sx = event.x ?? (event.kind === "click" ? event.pressX : void 0) ?? 0;
+  const sy = event.y ?? (event.kind === "click" ? event.pressY : void 0) ?? 0;
+  const affordance = event.kind === "pointerdown" ? event.affordance : void 0;
+  return {
+    world: { x: sx, y: sy },
+    drag: {
+      start: { x: sx, y: sy },
+      current: { x: sx, y: sy },
+      delta: { x: 0, y: 0 },
+      ...affordance !== void 0 ? { affordance } : {}
     }
-    return out;
-  }
-  function resolveOnly(event, ctx) {
-    const r = rank(event, ctx, false);
-    const { winner } = walk(r, event, ctx, null, false);
-    if (!winner) return null;
-    return {
-      actionId: winner.action.id,
-      action: winner.action,
-      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 buildDispatchRecord(r, walked, event, ctx, true, walked.winner ? "handled" : "unhandled");
-  }
-  function cancelAll(reason) {
-    const stubCtx = {
-      world: { x: 0, y: 0 },
-      modifiers: { alt: false, ctrl: false, meta: false, shift: false },
-      deps: {}
-    };
-    const ending = [...inFlightHandles];
-    inFlightHandles.clear();
-    inFlightOwners.clear();
-    inFlightActions.clear();
-    uiOngoingByAction.clear();
-    dragOrigins.clear();
-    dragPoints.clear();
-    pinchStartSpreads.clear();
-    for (const [gestureId, handle] of ending) runOnEnd(gestureId, handle, stubCtx, reason);
-  }
-  function inFlight() {
-    return inFlightHandles;
-  }
-  function inFlightCursor() {
-    let cursor = null;
-    for (const action of inFlightActions.values()) {
-      const spec = action.activeCursor ?? action.cursor;
-      if (spec !== void 0 && resolveCursor(spec)) cursor = spec;
+  };
+}
+function pumpDrag(event, facts) {
+  const cx = event.x;
+  const cy = event.y;
+  const origin = facts.origin;
+  const ox = origin?.x ?? cx;
+  const oy = origin?.y ?? cy;
+  const live = facts.points;
+  const points = live && event.kind === "pointerup" ? [...live] : live;
+  const eventClientX = event.clientX;
+  const eventClientY = event.clientY;
+  const hasClient = eventClientX !== void 0 && eventClientY !== void 0 && origin?.clientX !== void 0 && origin?.clientY !== void 0;
+  return {
+    world: { x: cx, y: cy },
+    drag: {
+      start: { x: ox, y: oy },
+      current: { x: cx, y: cy },
+      delta: { x: cx - ox, y: cy - oy },
+      ...hasClient ? { screenDelta: { x: eventClientX - origin.clientX, y: eventClientY - origin.clientY } } : {},
+      ...points !== void 0 ? { points } : {}
     }
-    return cursor;
-  }
-  function getInFlightHandles() {
-    return inFlightHandles.values();
-  }
-  function subscribe(fn) {
-    subscribers.add(fn);
-    return () => {
-      subscribers.delete(fn);
-    };
-  }
-  function getVersion() {
-    return version;
+  };
+}
+function multiTouchOf(event, facts) {
+  const centroid = event.centroid ?? { x: 0, y: 0 };
+  const spread = event.spread ?? 1;
+  const { startSpread } = facts;
+  return {
+    centroid,
+    spread,
+    rotation: facts.rotation ?? 0,
+    // Pinch geometry, on a move of a running gesture.
+    ...startSpread !== void 0 && event.spread !== void 0 ? { pinch: { startSpread, currentSpread: spread, centroid } } : {}
+  };
+}
+function buildInvocationCtx(event, deps, viewId, facts = {}) {
+  const base = {
+    world: { x: 0, y: 0 },
+    modifiers: { alt: event.altKey, ctrl: event.ctrlKey, meta: event.metaKey, shift: event.shiftKey },
+    deps,
+    ...viewId !== void 0 ? { viewId } : {}
+  };
+  const screen = clientPoint(event);
+  if (screen) base.screen = screen;
+  if (event.kind === "key") {
+    base.key = { key: event.key, repeat: event.repeat ?? false };
+  } else if (event.kind === "key-held") {
+    base.key = { key: event.key, repeat: false };
+  } else if (event.kind === "wheel") {
+    base.wheel = { deltaX: event.deltaX, deltaY: event.deltaY, deltaZ: 0 };
+  } else if (event.kind === "pinch") {
+    base.pinch = { scale: event.scale, rotation: event.rotation };
+  } else if (event.kind === "pointerdown" || event.kind === "click" || event.kind === "doubleclick" || event.kind === "contextmenu") {
+    Object.assign(base, pressDrag(event));
+  } else if (event.kind === "pointermove" || event.kind === "pointerup") {
+    Object.assign(base, pumpDrag(event, facts));
+  } else if (event.kind === "multitouch") {
+    base.multiTouch = multiTouchOf(event, facts);
+  }
+  return base;
+}
+
+// src/interactions/dispatcher/gestureRun.ts
+var ctxFor = (run, event, deps, gestureId) => buildInvocationCtx(event, deps, run.viewId(), run.facts.of(gestureId));
+function runOnEnd(gestureId, handle, endCtx, reason) {
+  try {
+    handle.onEnd?.(endCtx, reason);
+  } catch (err) {
+    console.error(`weasel dispatcher: gesture "${gestureId}" threw on onEnd`, err);
   }
-  function getActiveAction() {
-    let lastId = null;
-    let lastHandle = null;
-    for (const [id, handle] of inFlightHandles) {
-      lastId = id;
-      lastHandle = handle;
+}
+function endGesture(run, gestureId, event, reason) {
+  if (!run.inFlight.handles.has(gestureId)) return false;
+  const endCtx = ctxFor(run, event, {}, gestureId);
+  const handle = run.inFlight.take(gestureId);
+  run.facts.drop(gestureId);
+  runOnEnd(gestureId, handle, endCtx, reason);
+  return true;
+}
+function endMultiTouch(run, event, reason, except) {
+  let ended = false;
+  for (const id of [...run.inFlight.handles.keys()]) {
+    if (isMultiTouchGestureId(id) && id !== except) ended = endGesture(run, id, event, reason) || ended;
+  }
+  return ended;
+}
+function endAllGestures(run, reason) {
+  const stubCtx = uiInvocationCtx({});
+  const ending = run.inFlight.takeAll();
+  run.facts.clear();
+  for (const [gestureId, handle] of ending) runOnEnd(gestureId, handle, stubCtx, reason);
+}
+function pumpGesture(run, event) {
+  const { inFlight } = run;
+  const ended = (reason) => endGesture(run, gestureIdFor(event), event, reason) ? "handled" : "unhandled";
+  if (event.kind === "key-held" && event.phase === "up") return ended("commit");
+  if (event.kind === "key-held" && event.phase === "down") {
+    return inFlight.handles.has(gestureIdFor(event)) ? "handled" : void 0;
+  }
+  if (event.kind === "pointermove") {
+    const gestureId = gestureIdFor(event);
+    const handle = inFlight.handles.get(gestureId);
+    if (!handle) return "unhandled";
+    run.facts.sample(gestureId, event);
+    if (!handle.onMove) return "unhandled";
+    handle.onMove(ctxFor(run, event, {}, gestureId));
+    return "handled";
+  }
+  if (event.kind === "pointerup") return ended("commit");
+  if (event.kind === "pointercancel") return ended("cancel");
+  if (event.kind === "multitouch" && event.end !== void 0) {
+    return endMultiTouch(run, event, event.end) ? "handled" : "unhandled";
+  }
+  if (event.kind === "multitouch" && event.centroid !== void 0) {
+    const gestureId = gestureIdFor(event);
+    const handle = inFlight.handles.get(gestureId);
+    if (handle?.onMove) {
+      run.facts.turn(gestureId, event);
+      handle.onMove(ctxFor(run, event, {}, gestureId));
+      return "handled";
     }
-    if (lastHandle === null) return { kind: null, id: null };
-    return { kind: lastHandle.kind ?? null, id: lastId };
+    endMultiTouch(run, event, "cancel", gestureId);
   }
-  const handleInputWithNotify = (event, ctx) => {
-    const before = inFlightHandles.size;
-    try {
-      return handleInput(event, ctx);
-    } finally {
-      if (before > 0 || inFlightHandles.size > 0) notify();
-    }
-  };
-  const cancelAllWithNotify = (reason) => {
-    const before = inFlightHandles.size;
+  return void 0;
+}
+function invokeAction(run, event, match, action, deps) {
+  if (action.invoker?.timing === "immediate") {
     try {
-      cancelAll(reason);
-    } finally {
-      if (before > 0) notify();
+      const params = immediateParams(event, resolveParams(match.binding.opts?.params));
+      action.invoker.run(deps, params);
+    } catch (err) {
+      console.error(`weasel dispatcher: action "${action.id}" invoker threw`, err);
     }
-  };
-  function beginUiOngoing(actionId, deps, params) {
-    const getAction = opts?.getAction;
-    if (!getAction) {
-      console.warn("weasel dispatcher: beginUiOngoing called but no getAction was provided to createDispatcher");
-      return null;
+    return "fired";
+  }
+  if (action.invoker?.timing === "ongoing") {
+    if (event.kind === "hover" || event.kind === "pointerdown" && event.stage === "press") {
+      const spec = event.kind === "hover" ? "hover spec, which has no press to own" : "pointerDown spec, which fires at press time";
+      console.error(
+        `weasel dispatcher: action "${action.id}" has an ongoing invoker but is bound to a ${spec}. Bind it to a drag spec, or give the action an immediate invoker.`
+      );
+      return "misbound";
     }
-    const action = getAction(actionId);
-    if (!action || !action.invoker || action.invoker.timing !== "ongoing") {
-      return null;
+    const gestureId = gestureIdFor(event);
+    run.facts.begin(gestureId, event);
+    const handle = action.invoker.start(ctxFor(run, event, deps, gestureId), match.binding.opts);
+    if (isEmptyOngoingHandle(handle)) {
+      run.facts.drop(gestureId);
+      return "empty-handle";
     }
-    const prevGestureId = uiOngoingByAction.get(actionId);
-    if (prevGestureId !== void 0) {
-      const prevHandle = inFlightHandles.get(prevGestureId);
-      if (prevHandle?.onEnd) {
-        try {
-          prevHandle.onEnd(buildUiInvocationCtx(deps), "commit");
-        } catch (e) {
-          console.error(`weasel dispatcher: prior UI handle for "${actionId}" threw on auto-commit`, e);
-        }
+    run.inFlight.open(gestureId, handle, match.ownerId, action);
+    return "fired";
+  }
+  return "fired";
+}
+
+// src/interactions/dispatcher/uiOngoing.ts
+function createUiOngoing(inFlight, notify, getAction) {
+  let seq = 0;
+  const byAction = /* @__PURE__ */ new Map();
+  function commitPrior(actionId, deps) {
+    const prevGestureId = byAction.get(actionId);
+    if (prevGestureId === void 0) return;
+    const prevHandle = inFlight.handles.get(prevGestureId);
+    if (prevHandle?.onEnd) {
+      try {
+        prevHandle.onEnd(uiInvocationCtx(deps), "commit");
+      } catch (e) {
+        console.error(`weasel dispatcher: prior UI handle for "${actionId}" threw on auto-commit`, e);
       }
-      inFlightHandles.delete(prevGestureId);
-      inFlightOwners.delete(prevGestureId);
-      uiOngoingByAction.delete(actionId);
-    }
-    const gestureId = `ui-${actionId}-${++uiOngoingSeq}`;
-    let handle;
-    try {
-      handle = action.invoker.start(buildUiInvocationCtx(deps, params), { params });
-    } catch (e) {
-      console.error(`weasel dispatcher: action "${actionId}" threw on start`, e);
-      return null;
-    }
-    if (isEmptyOngoingHandle(handle)) {
-      return null;
     }
-    inFlightHandles.set(gestureId, handle);
-    inFlightOwners.set(gestureId, null);
-    uiOngoingByAction.set(actionId, gestureId);
-    notify();
+    inFlight.take(prevGestureId);
+    byAction.delete(actionId);
+  }
+  function control(actionId, gestureId, handle, deps) {
     let ended = false;
-    const live = () => !ended && inFlightHandles.get(gestureId) === handle;
+    const live = () => !ended && inFlight.handles.get(gestureId) === handle;
     return {
       gestureId,
       get active() {
@@ -1560,7 +1463,7 @@ function createDispatcher(opts) {
         if (!live()) return;
         if (!handle.onMove) return;
         try {
-          handle.onMove(buildUiInvocationCtx(deps, nextParams));
+          handle.onMove(uiInvocationCtx(deps, nextParams));
         } catch (e) {
           console.error(`weasel dispatcher: action "${actionId}" threw on onMove`, e);
         }
@@ -1574,43 +1477,302 @@ function createDispatcher(opts) {
         ended = true;
         if (handle.onEnd) {
           try {
-            handle.onEnd(buildUiInvocationCtx(deps), reason);
+            handle.onEnd(uiInvocationCtx(deps), reason);
           } catch (e) {
             console.error(`weasel dispatcher: action "${actionId}" threw on onEnd`, e);
           }
         }
-        inFlightHandles.delete(gestureId);
-        inFlightOwners.delete(gestureId);
-        inFlightActions.delete(gestureId);
-        if (uiOngoingByAction.get(actionId) === gestureId) {
-          uiOngoingByAction.delete(actionId);
-        }
+        inFlight.take(gestureId);
+        if (byAction.get(actionId) === gestureId) byAction.delete(actionId);
         notify();
       }
     };
   }
+  return {
+    begin(actionId, deps, params) {
+      if (!getAction) {
+        console.warn("weasel dispatcher: beginUiOngoing called but no getAction was provided to createDispatcher");
+        return null;
+      }
+      const action = getAction(actionId);
+      if (!action || !action.invoker || action.invoker.timing !== "ongoing") {
+        return null;
+      }
+      commitPrior(actionId, deps);
+      const gestureId = `ui-${actionId}-${++seq}`;
+      let handle;
+      try {
+        handle = action.invoker.start(uiInvocationCtx(deps, params), { params });
+      } catch (e) {
+        console.error(`weasel dispatcher: action "${actionId}" threw on start`, e);
+        return null;
+      }
+      if (isEmptyOngoingHandle(handle)) return null;
+      inFlight.open(gestureId, handle, null);
+      byAction.set(actionId, gestureId);
+      notify();
+      return control(actionId, gestureId, handle, deps);
+    },
+    clear: () => {
+      byAction.clear();
+    }
+  };
+}
+
+// src/interactions/dispatcher/walk.ts
+function assembleScopedBindings(ctx) {
+  const allowedCapabilities = ctx.getRuleCtx?.()?.allowedCapabilities;
+  const { ordered, state } = assembleEntries(ctx.entriesById.values(), {
+    focusedId: ctx.activeToolId,
+    hotkeyStack: ctx.hotkeyStack,
+    ...allowedCapabilities ? { allowedCapabilities } : {}
+  });
+  const view = ctx.viewId ?? null;
+  const result = scopeBindings(ordered, state).filter((sb) => liveInView(sb.binding, view));
+  for (const action of ctx.actions.list()) {
+    const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
+    for (const binding of actionBindings(action)) {
+      if (!liveInView(binding, view)) continue;
+      result.push({ binding, scope: targetScope, ownerId: null });
+    }
+  }
+  return result;
+}
+function buildActionMap(registry) {
+  const map = /* @__PURE__ */ new Map();
+  for (const action of registry.list()) {
+    map.set(action.id, action);
+  }
+  return map;
+}
+function rank(event, ctx, engaged, collectBarred) {
+  const view = ctx.viewId ?? null;
+  const outcome = matchSortedWithBarred(
+    event,
+    assembleScopedBindings(ctx),
+    ctx.isMac,
+    engaged,
+    { collectBarred }
+  );
+  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), carriedBy(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 verdictsOf(r, walked, 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 r.ordered) {
+    const actionId = match.binding.actionId;
+    const action = r.actionMap.get(actionId);
+    if (!action) continue;
+    let verdict = verdictByAction.get(actionId);
+    if (verdict === void 0) {
+      if (!r.eligible(match)) {
+        verdict = fired && !evaluateShadowed ? { kind: "shadowed" } : { kind: "ineligible", reason: describeEligible(action.eligible) };
+      } 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);
+    } else if (verdict.kind === "would-fire") {
+      verdict = { kind: "shadowed" };
+    }
+    out.push({
+      actionId,
+      action,
+      binding: match.binding,
+      scope: match.scope,
+      ownerId: match.ownerId,
+      specificity: specificity(match.binding.spec),
+      verdict
+    });
+  }
+  return out;
+}
+
+// src/interactions/dispatcher/predict.ts
+function resolveAll(event, ctx, engaged, opts) {
+  const evaluateShadowed = opts?.evaluateShadowed ?? false;
+  const r = rank(event, ctx, engaged, false);
+  if (r.ordered.length === 0) return [];
+  return verdictsOf(r, walk(r, event, ctx, null, evaluateShadowed), evaluateShadowed);
+}
+function resolveOnly(event, ctx, engaged) {
+  const r = rank(event, ctx, engaged, false);
+  const { winner } = walk(r, event, ctx, null, false);
+  if (!winner) return null;
+  return {
+    actionId: winner.action.id,
+    action: winner.action,
+    scope: winner.match.scope,
+    ownerId: winner.match.ownerId
+  };
+}
+function explain(event, ctx, engaged, opts) {
+  const r = rank(event, ctx, engaged, true);
+  const walked = walk(r, event, ctx, null, opts?.evaluateShadowed ?? false);
+  return buildDispatchRecord(r, walked, event, ctx, true, walked.winner ? "handled" : "unhandled");
+}
+
+// src/interactions/dispatcher/dispatcher.ts
+function createDispatcher(opts) {
+  const inFlight = createInFlightGestures();
+  const facts = createGestureFacts();
+  const changed = createEmitter();
+  let version = 0;
+  function notify() {
+    version++;
+    changed.emit();
+  }
+  const uiOngoing = createUiOngoing(inFlight, notify, opts?.getAction);
+  let routedView;
+  const run = { inFlight, facts, viewId: () => routedView };
+  const invoking = (event) => (match, action, deps) => invokeAction(run, event, match, action, deps);
+  function handleInput(event, ctx) {
+    routedView = ctx.viewId;
+    const pumped = pumpGesture(run, event);
+    if (pumped !== void 0) return pumped;
+    if (event.kind === "hover") return hover(event, ctx);
+    const r = rank(event, ctx, inFlight.engagedOwners(), DEV2);
+    const walked = walk(r, event, ctx, invoking(event), false);
+    const outcome = walked.stop === "fired" ? "handled" : "unhandled";
+    if (DEV2) recordTrace(buildDispatchRecord(r, walked, event, ctx, false, outcome));
+    return outcome;
+  }
+  function hover(event, ctx) {
+    let fired = false;
+    const invoke = invoking(event);
+    walk(rank(event, ctx, inFlight.engagedOwners(), false), event, ctx, (match, action, deps) => {
+      if (invoke(match, action, deps) === "fired") fired = true;
+      return "empty-handle";
+    }, false);
+    return fired ? "handled" : "unhandled";
+  }
+  function cancelAll(reason) {
+    uiOngoing.clear();
+    endAllGestures(run, reason);
+  }
+  const handleInputWithNotify = (event, ctx) => {
+    const before = inFlight.handles.size;
+    try {
+      return handleInput(event, ctx);
+    } finally {
+      if (before > 0 || inFlight.handles.size > 0) notify();
+    }
+  };
+  const cancelAllWithNotify = (reason) => {
+    const before = inFlight.handles.size;
+    try {
+      cancelAll(reason);
+    } finally {
+      if (before > 0) notify();
+    }
+  };
   return {
     handleInput: handleInputWithNotify,
-    resolveOnly,
-    resolveAll,
-    explain,
+    resolveOnly: (event, ctx) => resolveOnly(event, ctx, inFlight.engagedOwners()),
+    resolveAll: (event, ctx, resolveOpts) => resolveAll(event, ctx, inFlight.engagedOwners(), resolveOpts),
+    explain: (event, ctx, explainOpts) => explain(event, ctx, inFlight.engagedOwners(), explainOpts),
     cancelAll: cancelAllWithNotify,
-    inFlight,
-    inFlightCursor,
-    getInFlightHandles,
-    subscribe,
-    getVersion,
-    getActiveAction,
-    beginUiOngoing
+    inFlight: () => inFlight.handles,
+    inFlightCursor: inFlight.cursor,
+    getInFlightHandles: () => inFlight.handles.values(),
+    subscribe: changed.subscribe,
+    getVersion: () => version,
+    getActiveAction: inFlight.latest,
+    beginUiOngoing: uiOngoing.begin
   };
 }
-
-// src/interactions/dispatcher/longPressState.ts
-var LONG_PRESS_MS = 500;
+var LONG_PRESS_HAPTIC_MS = 15;
 var nowMs = () => typeof performance !== "undefined" ? performance.now() : Date.now();
 function createLongPressStore() {
   let current = null;
-  const listeners = /* @__PURE__ */ new Set();
+  const changed = createEmitter();
   return {
     get: () => current,
     progress: (now = nowMs()) => {
@@ -1619,16 +1781,11 @@ function createLongPressStore() {
       const t = (now - current.startedAt) / current.duration;
       return t <= 0 ? 0 : t >= 1 ? 1 : t;
     },
-    subscribe: (fn) => {
-      listeners.add(fn);
-      return () => {
-        listeners.delete(fn);
-      };
-    },
+    subscribe: changed.subscribe,
     set: (next) => {
       if (next === current) return;
       current = next;
-      for (const fn of [...listeners]) fn();
+      changed.emit();
     }
   };
 }
@@ -1716,47 +1873,29 @@ function openPointerSession(origin, down, cb, opts = {}) {
 function isTool(entry) {
   return !!(entry.eligibility?.focus || entry.eligibility?.offhand);
 }
-function findConflicts(entries) {
-  return findConflictsKeyed(entries).map((k) => k.conflict);
-}
-function findConflictsKeyed(entries, rules, modes = KIT_MODES) {
-  const rows = buildRouteRegistry(entries);
-  const groups = /* @__PURE__ */ new Map();
-  for (const entry of rows) {
-    for (const arg of argKeysOf(entry)) {
-      const base = `${entry.phase}|${entry.gesture}|${arg}|${targetKey(entry)}`;
-      for (const state of modifierTieKeys(entry)) {
-        const key = `${base}|${state}`;
-        const bucket = groups.get(key);
-        if (bucket) {
-          if (!bucket.members.includes(entry)) bucket.members.push(entry);
-        } else groups.set(key, { base, members: [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 = /* @__PURE__ */ new Map();
-  for (const { base, members } of groups.values()) {
-    const bucket = members.filter((e) => members.some((f) => f !== e && tie(e, f)));
-    if (bucket.length < 2) continue;
-    const first = bucket[0];
-    const key = `${base}|${bucket.map((e) => `${objectId(e.spec)}:${canonicalModifiers(e.modifiers)}`).join(";")}`;
-    if (conflicts.has(key)) continue;
-    conflicts.set(key, {
-      phase: first.phase,
-      gesture: first.gesture,
-      arg: first.arg,
-      target: first.target,
-      modifiers: first.modifiers,
-      ownerIds: bucket.map((e) => e.ownerId)
-    });
-  }
-  return [...conflicts].map(([key, conflict]) => ({ key, conflict }));
+
+// src/tools/routing/reflection/conflictKeys.ts
+var PLATFORMS = ["mac", "other"];
+function resolveMod(mods, platform) {
+  if (mods.mod === void 0) return mods;
+  const { mod, meta: _meta, ctrl: _ctrl, ...rest } = mods;
+  return { ...rest, [platform === "mac" ? "meta" : "ctrl"]: mod };
+}
+function sameOutcome(entries) {
+  const first = entries[0];
+  return entries.every((e) => e.ownerId === first.ownerId && e.actionId === first.actionId && sameParams(e.params, first.params));
+}
+function sameParams(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 keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((k) => sameParams(a[k], b[k]));
 }
-function modifierTieKeys(entry) {
-  const optional = VALID_MOD_NAMES.filter((k) => entry.modifiers[k] === "optional");
-  const required = VALID_MOD_NAMES.filter((k) => entry.modifiers[k] === "required");
+function modifierTieKeys(entry, platform) {
+  const mods = resolveMod(entry.modifiers, platform);
+  const optional = VALID_MOD_NAMES.filter((k) => mods[k] === "optional");
+  const required = VALID_MOD_NAMES.filter((k) => mods[k] === "required");
   const keys = [];
   for (let bits = 0; bits < 1 << optional.length; bits++) {
     const held = [...required, ...optional.filter((_, i) => (bits & 1 << i) !== 0)].sort();
@@ -1790,6 +1929,57 @@ function objectId(obj) {
   }
   return id;
 }
+
+// src/tools/routing/reflection/conflicts.ts
+function findConflicts(entries) {
+  return findConflictsKeyed(entries).map((k) => k.conflict);
+}
+function findConflictsKeyed(entries, rules, modes = KIT_MODES) {
+  const rows = buildRouteRegistry(entries);
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of rows) {
+    for (const arg of argKeysOf(entry)) {
+      const base = `${entry.phase}|${entry.gesture}|${arg}|${targetKey(entry)}`;
+      for (const platform of PLATFORMS) {
+        for (const state of modifierTieKeys(entry, platform)) {
+          const key = `${platform}|${base}|${state}`;
+          const bucket = groups.get(key);
+          if (bucket) {
+            if (!bucket.members.includes(entry)) bucket.members.push(entry);
+          } else groups.set(key, { base, platform, members: [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 = /* @__PURE__ */ new Map();
+  for (const { base, platform, members } of groups.values()) {
+    const ties = (e, i, f, j) => i !== j && !(i < j ? e : f).yields && tie(e, f);
+    const bucket = members.filter((e, i) => members.some((f, j) => ties(e, i, f, j)));
+    if (bucket.length < 2) continue;
+    const first = bucket[0];
+    const key = `${base}|${bucket.map((e) => `${objectId(e.spec)}:${canonicalModifiers(e.modifiers)}`).join(";")}`;
+    const found = conflicts.get(key);
+    if (found) {
+      found.platforms.add(platform);
+      continue;
+    }
+    conflicts.set(key, {
+      conflict: {
+        phase: first.phase,
+        gesture: first.gesture,
+        arg: first.arg,
+        target: first.target,
+        modifiers: first.modifiers,
+        ownerIds: bucket.map((e) => e.ownerId)
+      },
+      bucket,
+      platforms: /* @__PURE__ */ new Set([platform])
+    });
+  }
+  return [...conflicts].filter(([, c]) => c.platforms.size === PLATFORMS.length || !sameOutcome(c.bucket)).map(([key, { conflict }]) => ({ key, conflict }));
+}
 function rulesCanHoldTogether(a, b, modes) {
   if (rulesExclusive(a, b)) return false;
   return modes.some((m) => ruleCanHoldIn(a, m) && ruleCanHoldIn(b, m));
@@ -1862,38 +2052,6 @@ function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
   }
   return conflicts;
 }
-
-// src/interactions/keyHelpers.ts
-function isEditableTarget(target) {
-  if (!target || !(target instanceof Element)) return false;
-  const tag = target.tagName;
-  if (tag === "INPUT" || tag === "TEXTAREA") return true;
-  if (target.isContentEditable) return true;
-  const ce = target.getAttribute("contenteditable");
-  return ce === "true" || ce === "";
-}
-var ACTIVATED_BY_KEY = [
-  "button",
-  "a[href]",
-  "summary",
-  "select",
-  'input[type="button"]',
-  'input[type="submit"]',
-  'input[type="reset"]',
-  'input[type="checkbox"]',
-  'input[type="radio"]',
-  '[role="button"]',
-  '[role="link"]',
-  '[role="checkbox"]',
-  '[role="switch"]',
-  '[role="menuitem"]',
-  '[role="tab"]',
-  '[role="option"]'
-].join(", ");
-function activatesFocusedControl(e) {
-  if (e.key !== " " && e.key !== "Enter") return false;
-  return e.target instanceof Element && e.target.matches(ACTIVATED_BY_KEY);
-}
 function keyMatches(eventKey, spec) {
   const want = typeof spec === "string" ? [spec] : spec;
   const ek = eventKey.toLowerCase();
@@ -1921,8 +2079,6 @@ function historyKey(e) {
     return "redo";
   return null;
 }
-
-// src/ingestion/ingestItems.ts
 var INGEST_STRING_MIMES = /* @__PURE__ */ new Set([
   "text/plain",
   "text/html",
@@ -1967,6 +2123,16 @@ function itemsFromDataTransfer(dt) {
   }
   return Promise.all(reads).then(() => [...files, ...strings]);
 }
+function itemTypesFromDataTransfer(dt) {
+  const mimes = [];
+  for (const item of Array.from(dt.items ?? [])) {
+    const mime = item.type ? normalizeMime(item.type) : "";
+    if (item.kind === "file") mimes.push(mime && mime !== "application/x-moz-file" ? mime : UNKNOWN_MIME);
+    else if (INGEST_STRING_MIMES.has(mime)) mimes.push(mime);
+  }
+  if (mimes.length === 0 && Array.from(dt.types ?? []).includes("Files")) mimes.push(UNKNOWN_MIME);
+  return mimes.map((mime) => ({ mime }));
+}
 function itemsFromClipboardData(cd) {
   const out = [];
   for (const file of Array.from(cd.files ?? [])) {
@@ -2025,6 +2191,6 @@ function dwarn(namespace, ...args) {
   console.warn(`[${namespace}]`, ...args);
 }
 
-export { ALWAYS, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DepNode, INGEST_STRING_MIMES, LONG_PRESS_MS, NEVER, PREDICATE_TARGET, ScopeNode, TOOL_OFFHAND_ID, actionBindings, activatesFocusedControl, assembleEntries, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, clientToCanvas, clientToCanvasRect, createDepRegistry, createDispatcher, createLongPressStore, depNodeOf, describeRule, dlog, dwarn, evaluate, findConflicts, heldKeySpec, historyKey, isDebugEnabled, isDev, isEditableTarget, isTool, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchSortedWithBarred, matchesKeyBinding, offhandKeyFor, openPointerSession, pointerGestureId, publishLiveDispatch, pushOwner, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routesForSpec, ruleCanHoldIn, rulesExclusive, scopeBindings, targetConsultsAffordance, validateActionDefaultBinding, validateActionId };
-//# sourceMappingURL=chunk-Y5RURZBH.js.map
-//# sourceMappingURL=chunk-Y5RURZBH.js.map
+export { ALWAYS, ActionDisabledReason, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DEV2 as DEV, DepNode, INGEST_STRING_MIMES, LONG_PRESS_HAPTIC_MS, NEVER, PREDICATE_TARGET, ScopeNode, TOOL_OFFHAND_ID, actionBindings, assembleEntries, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, clientToCanvas, clientToCanvasRect, createDepRegistry, createDispatcher, createLongPressStore, depNodeOf, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, findConflicts, heldKeySpec, historyKey, isDebugEnabled, isDev, isTool, itemTypesFromDataTransfer, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchSortedWithBarred, matchesKeyBinding, multiTouchGestureId, offhandKeyFor, openPointerSession, pointerGestureId, publishLiveDispatch, pushOwner, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routesForSpec, ruleCanHoldIn, rulesExclusive, scopeBindings, targetConsultsAffordance, tuneAction, validateActionDefaultBinding, validateActionId };
+//# sourceMappingURL=chunk-VCEIQ64H.js.map
+//# sourceMappingURL=chunk-VCEIQ64H.js.map