@weasel-js/routing 1.5.0

package/dist/chunk-Y5FHAA4U.js

@@ -0,0 +1,1504 @@
+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 { resolveCursor } from '@weasel-js/cursor';
+
+// src/interactions/actions/binding.ts
+function actionBindings(action) {
+  const gs = action.defaultBinding;
+  if (!gs) return [];
+  const raw = Array.isArray(gs) ? gs : [gs];
+  return raw.map((entry) => {
+    const isBoundObj = !("kind" in entry);
+    const spec = isBoundObj ? entry.spec : entry;
+    const opts = isBoundObj ? entry.opts : void 0;
+    return { spec, actionId: action.id, ...opts !== void 0 ? { opts } : {} };
+  });
+}
+
+// src/interactions/actions/buildDeps.ts
+var DEV = (() => {
+  try {
+    return Boolean(import.meta.env?.DEV);
+  } catch {
+    return false;
+  }
+})();
+function buildDepsFromRequires(action, depRegistry) {
+  const requires = action.requires ?? [];
+  const entries = requires.map((name) => [name, depRegistry.get(name)]);
+  const deps = Object.fromEntries(entries);
+  if (DEV) {
+    const declared = new Set(requires);
+    return new Proxy(deps, {
+      get(target, prop, receiver) {
+        if (typeof prop === "string" && !declared.has(prop) && prop !== "then") {
+          const message = `[weasel:dispatcher] action "${action.id}" read deps.${prop} but did not declare it in \`requires\`. Add \`requires: [...'${prop}']\` to the descriptor or the dep will be undefined at runtime.`;
+          console.warn(message);
+          throw new Error(message);
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  return deps;
+}
+
+// src/interactions/actions/registry.ts
+function validateActionId(id) {
+  if (id.length === 0) {
+    throw new Error(`weasel: action id may not be empty`);
+  }
+  if (RESERVED_ID_PREFIXES.has(id[0])) {
+    throw new Error(
+      `weasel: action id "${id}" starts with reserved sigil "${id[0]}" (reserved set: ${[...RESERVED_ID_PREFIXES].join(" ")})`
+    );
+  }
+  if (RESERVED_ID_NAMES.has(id)) {
+    throw new Error(
+      `weasel: action id "${id}" collides with a reserved phase keyword (reserved: ${[...RESERVED_ID_NAMES].join(", ")})`
+    );
+  }
+}
+function validateActionDefaultBinding(action) {
+  const gs = action.defaultBinding;
+  if (!gs) return;
+  const entries = Array.isArray(gs) ? gs : [gs];
+  for (const entry of entries) {
+    const spec = "kind" in entry ? entry : entry.spec;
+    const phase = spec.phase;
+    if (phase === void 0) continue;
+    const atoms = Array.isArray(phase) ? phase : [{ channel: "&", phase }];
+    for (const atom of atoms) {
+      if (atom.channel === "&") {
+        throw new Error(
+          `weasel: action "${action.id}" defaultBinding uses '&' channel which has no owning tool to resolve to. Use a named tool channel (e.g. '[rect:engaged]') or '*' instead, or move this binding to the tool's own Tool.bindings.`
+        );
+      }
+    }
+  }
+}
+
+// src/interactions/actions/invoker.ts
+function resolveParams(params) {
+  if (params === void 0) return void 0;
+  return typeof params === "function" ? params() : params;
+}
+
+// src/interactions/actions/toolOffhand.ts
+var TOOL_OFFHAND_ID = "tool.offhand";
+function offhandKeyFor(trigger) {
+  switch (trigger) {
+    case "space":
+      return " ";
+    case "alt":
+      return "Alt";
+    case "ctrl":
+      return "Control";
+    case "meta":
+      return "Meta";
+    case "shift":
+      return "Shift";
+  }
+}
+function buildToolOffhandBindings(specs) {
+  return specs.map(({ toolId, key }) => ({
+    spec: { kind: "key-held", key },
+    opts: { params: { toolId } }
+  }));
+}
+function makeToolOffhandAction(bindings) {
+  return {
+    id: TOOL_OFFHAND_ID,
+    label: "Engage tool (offhand)",
+    defaultBinding: bindings,
+    scope: "hotkey",
+    invoker: {
+      timing: "ongoing",
+      start: (ctx, opts) => {
+        const activeTool = ctx.deps.activeTool;
+        const toolId = resolveParams(opts?.params)?.toolId;
+        if (!activeTool || !toolId) return {};
+        activeTool.pushHotkey(toolId);
+        return {
+          onEnd: () => {
+            activeTool.popHotkey(toolId);
+          }
+        };
+      }
+    },
+    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.offhand && state.heldTriggers.has(eligibility.offhand)) 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) {
+  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, ownerToolId: entry.id });
+    }
+  }
+  return out;
+}
+
+// src/devFlag.ts
+function isDev() {
+  return typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+}
+
+// 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);
+  if (form === null) return false;
+  switch (form.form) {
+    case "predicate":
+      return form.kindOf.readsAffordance !== false;
+    case "affordance":
+      return true;
+    case "body":
+      return false;
+    case "kind":
+      return false;
+    default: {
+      return false;
+    }
+  }
+}
+function specTargetOf(spec) {
+  return "target" in spec ? spec.target : void 0;
+}
+function claimOf(e) {
+  return "affordance" in e ? e.affordance : void 0;
+}
+function claimGestureOf(e) {
+  switch (e.kind) {
+    case "pointerdown":
+    case "click":
+      return "pointer";
+    case "doubleclick":
+      return "doubleClick";
+    case "contextmenu":
+      return "contextMenu";
+    case "longpress":
+      return "longPress";
+    case "wheel":
+      return "wheel";
+    default:
+      return null;
+  }
+}
+function isExclusiveClaim(e) {
+  const claim = claimOf(e);
+  if (claim?.strength !== "exclusive") return false;
+  const gesture = claimGestureOf(e);
+  if (gesture === null) return false;
+  return claim.claimedKinds === void 0 || claim.claimedKinds.includes(gesture);
+}
+var warnedDeadClaims = /* @__PURE__ */ new Set();
+function reportDeadClaim(owner, warn) {
+  if (!isDev()) return;
+  const key = String(owner);
+  if (warnedDeadClaims.has(key)) return;
+  warnedDeadClaims.add(key);
+  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);
+  for (let i = 0; i < sa.length; i++) {
+    if (sa[i] !== sb[i]) return sb[i] - sa[i];
+  }
+  return 0;
+}
+function matchBest(e, bindings, isMac, engagedChannels) {
+  const sorted = matchSorted(e, bindings, isMac, engagedChannels);
+  return sorted.length > 0 ? sorted[0] : null;
+}
+function matchSorted(e, bindings, isMac, engagedChannels, warn = (m) => console.warn(m)) {
+  const out = [];
+  const engaged = engagedChannels ?? EMPTY_ENGAGED;
+  const exclusive = isExclusiveClaim(e);
+  const pool = exclusive ? bindings.filter((sb) => targetConsultsAffordance(specTargetOf(sb.binding.spec))) : bindings;
+  for (const scope of SCOPE_PRIORITY) {
+    const scopeMatches = [];
+    for (const sb of pool) {
+      if (sb.scope !== scope) continue;
+      const phaseCtx = { selfChannel: sb.ownerToolId, engagedChannels: engaged };
+      if (matchSpec(e, sb.binding.spec, isMac, phaseCtx)) {
+        scopeMatches.push({ binding: sb.binding, scope, ownerToolId: sb.ownerToolId });
+      }
+    }
+    scopeMatches.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
+    out.push(...scopeMatches);
+  }
+  if (exclusive && out.length === 0 && bindings.length > 0) {
+    reportDeadClaim(claimOf(e)?.owner, warn);
+  }
+  return out;
+}
+var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
+
+// src/eligibility/deviceProfile.ts
+var COARSE_TARGET_SCALE = 1.75;
+function resolveDeviceProfile(detected, overrides) {
+  const coarsePointer = overrides?.coarsePointer ?? detected.coarsePointer;
+  const canHover = overrides?.canHover ?? detected.canHover;
+  const dpr = overrides?.dpr ?? detected.dpr;
+  const targetScale = overrides?.targetScale ?? (coarsePointer ? COARSE_TARGET_SCALE : 1);
+  return { coarsePointer, canHover, dpr, targetScale };
+}
+var DEFAULT_DEVICE_PROFILE = resolveDeviceProfile({
+  coarsePointer: false,
+  canHover: true,
+  dpr: 1
+});
+
+// src/eligibility/rule.ts
+var ALWAYS = { all: [] };
+var NEVER = { any: [] };
+function isAllRule(r) {
+  return typeof r === "object" && r !== null && "all" in r;
+}
+function isAnyRule(r) {
+  return typeof r === "object" && r !== null && "any" in r;
+}
+function isNotRule(r) {
+  return typeof r === "object" && r !== null && "not" in r;
+}
+function isWhenRule(r) {
+  return typeof r === "object" && r !== null && "when" in r;
+}
+function checkSelection(s, ctx) {
+  if (s.empty !== void 0 && ctx.selection.length === 0 !== s.empty) return false;
+  if (s.is !== void 0 && ctx.selection.length !== s.is) return false;
+  if (s.atLeast !== void 0 && ctx.selection.length < s.atLeast) return false;
+  return true;
+}
+function checkMode(m, ctx) {
+  if (typeof m === "string") return ctx.mode === m;
+  if ("not" in m) return ctx.mode !== m.not;
+  if ("in" in m) return m.in.includes(ctx.mode);
+  return false;
+}
+function checkCapability(c, ctx) {
+  if (typeof c === "string") return ctx.allowedCapabilities.has(c);
+  if (Array.isArray(c)) return c.every((tag) => ctx.allowedCapabilities.has(tag));
+  if ("in" in c) return c.in.some((tag) => ctx.allowedCapabilities.has(tag));
+  if ("not" in c) return !ctx.allowedCapabilities.has(c.not);
+  return false;
+}
+function evaluateSelector(s, ctx) {
+  if (s.selection !== void 0 && !checkSelection(s.selection, ctx)) return false;
+  if (s.mode !== void 0 && !checkMode(s.mode, ctx)) return false;
+  if (s.capability !== void 0 && !checkCapability(s.capability, ctx)) return false;
+  if (s.gesturing !== void 0 && ctx.action.kind !== null !== s.gesturing) return false;
+  if (s.actionIs !== void 0 && ctx.action.kind !== s.actionIs) return false;
+  if (s.modifierHeld !== void 0 && !ctx.modifiers[s.modifierHeld]) return false;
+  if (s.focused !== void 0 && ctx.focused !== s.focused) return false;
+  if (s.hovering !== void 0 && ctx.hover !== null !== s.hovering) return false;
+  if (s.hoveringSelected !== void 0) {
+    const isHovSel = ctx.hover !== null && ctx.selection.includes(ctx.hover);
+    if (isHovSel !== s.hoveringSelected) return false;
+  }
+  if (s.editingAnchors !== void 0 && (ctx.editingAnchors ?? false) !== s.editingAnchors) return false;
+  if (s.zoomAtLeast !== void 0) {
+    if (ctx.zoom === void 0 || ctx.zoom < s.zoomAtLeast) return false;
+  }
+  if (s.resizable !== void 0) {
+    const resizable = ctx.selectionResizable ?? true;
+    if (resizable !== s.resizable) return false;
+  }
+  if (s.coarsePointer !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.coarsePointer !== s.coarsePointer) return false;
+  }
+  if (s.canHover !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.canHover !== s.canHover) return false;
+  }
+  return true;
+}
+var MAX_RULE_DEPTH = 10;
+function describeValue(value, depth) {
+  if (depth > MAX_RULE_DEPTH) return "\u2026";
+  if (value === null || typeof value !== "object") return String(value);
+  if (Array.isArray(value)) return value.map((v) => describeValue(v, depth + 1)).join("+");
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length === 1 && keys[0] === "not") return `not(${describeValue(obj.not, depth + 1)})`;
+  if (keys.length === 1 && keys[0] === "in") return `in(${describeValue(obj.in, depth + 1)})`;
+  return keys.map((k) => `${k}=${describeValue(obj[k], depth + 1)}`).join(",");
+}
+function describeSelector(s, depth) {
+  const keys = Object.keys(s);
+  if (keys.length === 0) return "*";
+  return keys.map((k) => `${k}:${describeValue(s[k], depth + 1)}`).join(" & ");
+}
+function describeAt(rule, depth) {
+  if (depth > MAX_RULE_DEPTH) return "\u2026";
+  if (isAllRule(rule)) return `all(${rule.all.map((r) => describeAt(r, depth + 1)).join(", ")})`;
+  if (isAnyRule(rule)) return `any(${rule.any.map((r) => describeAt(r, depth + 1)).join(", ")})`;
+  if (isNotRule(rule)) return `not(${describeAt(rule.not, depth + 1)})`;
+  if (isWhenRule(rule)) return `when(${rule.when.name || "\u0192"})`;
+  return describeSelector(rule, depth);
+}
+function describeRule(rule) {
+  return describeAt(rule, 0);
+}
+function evaluate(rule, ctx) {
+  if (isAllRule(rule)) return rule.all.every((r) => evaluate(r, ctx));
+  if (isAnyRule(rule)) return rule.any.some((r) => evaluate(r, ctx));
+  if (isNotRule(rule)) return !evaluate(rule.not, ctx);
+  if (isWhenRule(rule)) return rule.when(ctx);
+  return evaluateSelector(rule, ctx);
+}
+var DEFAULT_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
+  ...NORMAL.allows,
+  ...IMPLICIT_TAGS
+]);
+function buildRuleCtx(args) {
+  return {
+    focused: args.focused,
+    selection: args.selection,
+    multiActive: args.multiActive,
+    modifiers: args.modifiers,
+    action: args.action,
+    hover: args.hover,
+    zoom: args.zoom,
+    mode: args.mode,
+    allowedCapabilities: args.allowedCapabilities,
+    selectionResizable: args.selectionResizable,
+    editingAnchors: args.editingAnchors,
+    device: args.device
+  };
+}
+function pointerGestureId(pointerId) {
+  return `pointer-${pointerId ?? "mouse"}`;
+}
+var DEV2 = (() => {
+  try {
+    return Boolean(import.meta.env?.DEV);
+  } catch {
+    return false;
+  }
+})();
+var TRACE_LIMIT = 200;
+var traceLog = DEV2 && typeof window !== "undefined" ? window.__weaselDispatchLog__ ??= [] : [];
+function recordTrace(entry) {
+  if (!DEV2) return;
+  traceLog.push(entry);
+  if (traceLog.length > TRACE_LIMIT) traceLog.shift();
+}
+function recordModeSwitch(mode, from, to, detail) {
+  recordTrace({
+    kind: "mode",
+    ts: Date.now(),
+    mode,
+    from,
+    to,
+    ...detail !== void 0 ? { detail } : {}
+  });
+}
+function eligibleToRule(eligible) {
+  return typeof eligible === "function" ? eligible.rule : eligible;
+}
+function isEligible(action, ruleCtx) {
+  if (!action.eligible) return true;
+  return evaluate(eligibleToRule(action.eligible), ruleCtx);
+}
+function describeEligible(eligible) {
+  return describeRule(eligibleToRule(eligible));
+}
+function filterEligible(matches, actionLookup, ruleCtx) {
+  return matches.filter((m) => {
+    const action = actionLookup(m.binding.actionId);
+    if (!action) return true;
+    return isEligible(action, ruleCtx);
+  });
+}
+var EMPTY_TRIGGERS = /* @__PURE__ */ new Set();
+var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
+function modifiersOf(e) {
+  return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
+}
+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;
+  }
+  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
+    };
+    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 === "pointerdown" || event.kind === "click") {
+      const sx = event.kind === "pointerdown" ? event.x ?? 0 : event.worldX ?? event.pressX ?? 0;
+      const sy = event.kind === "pointerdown" ? event.y ?? 0 : event.worldY ?? event.pressY ?? 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 points = gestureId ? dragPoints.get(gestureId) : void 0;
+      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.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 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);
+    }
+    for (const tool of ctx.toolsById.values()) {
+      if (!ordered.includes(tool)) ordered.push(tool);
+    }
+    const capsCtx = ctx.getRuleCtx?.();
+    const allows = capsCtx ? (tags) => tags.every((tag) => capsCtx.allowedCapabilities.has(tag)) : void 0;
+    const result = scopeBindings(ordered, {
+      focusedId: ctx.activeToolId,
+      heldTriggers: EMPTY_TRIGGERS,
+      engagedIds: new Set(ctx.hotkeyStack),
+      ...allows ? { allows } : {}
+    });
+    for (const action of ctx.actions.list()) {
+      const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
+      for (const binding of actionBindings(action)) {
+        result.push({ binding, scope: targetScope, ownerToolId: 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 handleInput(event, ctx) {
+    if (event.kind === "key-held" && event.phase === "up") {
+      const gestureId = gestureIdFor(event);
+      const handle = inFlightHandles.get(gestureId);
+      if (handle) {
+        const stubCtx = buildInvocationCtx(event, {}, gestureId);
+        handle.onEnd?.(stubCtx, "commit");
+        inFlightHandles.delete(gestureId);
+        inFlightOwners.delete(gestureId);
+        inFlightActions.delete(gestureId);
+        dragOrigins.delete(gestureId);
+      }
+      return handle ? "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);
+      const handle = inFlightHandles.get(gestureId);
+      if (handle) {
+        const endCtx = buildInvocationCtx(event, {}, gestureId);
+        handle.onEnd?.(endCtx, "commit");
+        inFlightHandles.delete(gestureId);
+        inFlightOwners.delete(gestureId);
+        inFlightActions.delete(gestureId);
+        dragOrigins.delete(gestureId);
+        dragPoints.delete(gestureId);
+      }
+      return handle ? "handled" : "unhandled";
+    }
+    if (event.kind === "pointercancel") {
+      const gestureId = gestureIdFor(event);
+      const handle = inFlightHandles.get(gestureId);
+      if (handle) {
+        const endCtx = buildInvocationCtx(event, {}, gestureId);
+        handle.onEnd?.(endCtx, "cancel");
+        inFlightHandles.delete(gestureId);
+        inFlightOwners.delete(gestureId);
+        inFlightActions.delete(gestureId);
+        dragOrigins.delete(gestureId);
+        dragPoints.delete(gestureId);
+      }
+      return handle ? "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, other] of [...inFlightHandles]) {
+        if (!id.startsWith("multitouch-") || id === gestureId) continue;
+        other.onEnd?.(buildInvocationCtx(event, {}, id), "cancel");
+        inFlightHandles.delete(id);
+        inFlightOwners.delete(id);
+        inFlightActions.delete(id);
+        pinchStartSpreads.delete(id);
+      }
+    }
+    const scopedBindings = assembleScopedBindings(ctx);
+    const engagedChannels = snapshotEngagedChannels();
+    const rawMatches = matchSorted(event, scopedBindings, ctx.isMac, engagedChannels);
+    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 = ctx.getRuleCtx?.();
+    const matches = ruleCtx ? filterEligible(rawMatches, (id) => actionMap.get(id), ruleCtx) : rawMatches;
+    if (matches.length === 0) {
+      finishTrace(null, "unhandled");
+      return "unhandled";
+    }
+    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)`
+        );
+        continue;
+      }
+      const deps = buildDepsFromRequires(action, ctx.depRegistry);
+      if (action.enabled) {
+        const result = action.enabled(deps);
+        if (result !== true) {
+          traceCandidates.push({ actionId: action.id, scope: match.scope, enabledResult: String(result) });
+          continue;
+        }
+      }
+      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 === "click" || event.kind === "doubleclick") {
+            params = {
+              worldX: event.worldX,
+              worldY: event.worldY,
+              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.kind === "contextmenu" ? event.worldX : event.x,
+              worldY: event.kind === "contextmenu" ? event.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 (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);
+        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);
+        }
+        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;
+        }
+        inFlightHandles.set(gestureId, handle);
+        inFlightOwners.set(gestureId, match.ownerToolId);
+        inFlightActions.set(gestureId, action);
+        finishTrace(action.id, "handled");
+        return "handled";
+      }
+      finishTrace(action.id, "handled");
+      return "handled";
+    }
+    finishTrace(null, "unhandled");
+    return "unhandled";
+  }
+  function resolveAll(event, ctx, resolveOpts) {
+    const scopedBindings = assembleScopedBindings(ctx);
+    const engagedChannels = snapshotEngagedChannels();
+    const matches = matchSorted(event, scopedBindings, ctx.isMac, engagedChannels);
+    if (matches.length === 0) return [];
+    const actionMap = buildActionMap(ctx.actions);
+    const ruleCtx = ctx.getRuleCtx?.();
+    const verdictByAction = /* @__PURE__ */ new Map();
+    let fired = false;
+    const out = [];
+    for (const match of matches) {
+      const actionId = match.binding.actionId;
+      const action = 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) };
+        } else {
+          const disabled = action.enabled ? action.enabled(buildDepsFromRequires(action, ctx.depRegistry)) : true;
+          if (disabled !== true) {
+            verdict = { kind: "disabled", reason: String(disabled) };
+          } else if (fired) {
+            verdict = { kind: "shadowed" };
+          } else {
+            verdict = { kind: "would-fire" };
+            fired = true;
+          }
+        }
+        verdictByAction.set(actionId, verdict);
+      } else if (verdict.kind === "would-fire") {
+        verdict = { kind: "shadowed" };
+      }
+      out.push({
+        actionId,
+        action,
+        binding: match.binding,
+        scope: match.scope,
+        ownerToolId: match.ownerToolId,
+        specificity: specificity(match.binding.spec),
+        verdict
+      });
+    }
+    return out;
+  }
+  function resolveOnly(event, ctx) {
+    const winner = resolveAll(event, ctx).find((c) => c.verdict.kind === "would-fire");
+    if (!winner) return null;
+    return {
+      actionId: winner.actionId,
+      action: winner.action,
+      scope: winner.scope,
+      ownerToolId: winner.ownerToolId
+    };
+  }
+  function cancelAll(reason) {
+    const stubCtx = {
+      world: { x: 0, y: 0 },
+      modifiers: { alt: false, ctrl: false, meta: false, shift: false },
+      deps: {}
+    };
+    for (const handle of inFlightHandles.values()) {
+      handle.onEnd?.(stubCtx, reason);
+    }
+    inFlightHandles.clear();
+    inFlightOwners.clear();
+    inFlightActions.clear();
+    uiOngoingByAction.clear();
+    dragOrigins.clear();
+    dragPoints.clear();
+    pinchStartSpreads.clear();
+  }
+  function inFlight() {
+    return inFlightHandles;
+  }
+  function inFlightCursor() {
+    let cursor = null;
+    for (const action of inFlightActions.values()) {
+      const c = resolveCursor(action.activeCursor ?? action.cursor);
+      if (c) cursor = c;
+    }
+    return cursor;
+  }
+  function getInFlightHandles() {
+    return inFlightHandles.values();
+  }
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => {
+      subscribers.delete(fn);
+    };
+  }
+  function getVersion() {
+    return version;
+  }
+  function getActiveAction() {
+    let lastId = null;
+    let lastHandle = null;
+    for (const [id, handle] of inFlightHandles) {
+      lastId = id;
+      lastHandle = handle;
+    }
+    if (lastHandle === null) return { kind: null, id: null };
+    return { kind: lastHandle.kind ?? null, id: lastId };
+  }
+  const handleInputWithNotify = (event, ctx) => {
+    const out = handleInput(event, ctx);
+    notify();
+    return out;
+  };
+  const cancelAllWithNotify = (reason) => {
+    cancelAll(reason);
+    notify();
+  };
+  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;
+    }
+    const action = getAction(actionId);
+    if (!action || !action.invoker || action.invoker.timing !== "ongoing") {
+      return null;
+    }
+    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);
+        }
+      }
+      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();
+    let ended = false;
+    const live = () => !ended && inFlightHandles.get(gestureId) === handle;
+    return {
+      gestureId,
+      update(nextParams) {
+        if (!live()) return;
+        if (!handle.onMove) return;
+        try {
+          handle.onMove(buildUiInvocationCtx(deps, nextParams));
+        } catch (e) {
+          console.error(`weasel dispatcher: action "${actionId}" threw on onMove`, e);
+        }
+        notify();
+      },
+      end(reason) {
+        if (!live()) {
+          ended = true;
+          return;
+        }
+        ended = true;
+        if (handle.onEnd) {
+          try {
+            handle.onEnd(buildUiInvocationCtx(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);
+        }
+        notify();
+      }
+    };
+  }
+  return {
+    handleInput: handleInputWithNotify,
+    resolveOnly,
+    resolveAll,
+    cancelAll: cancelAllWithNotify,
+    inFlight,
+    inFlightCursor,
+    getInFlightHandles,
+    subscribe,
+    getVersion,
+    getActiveAction,
+    beginUiOngoing
+  };
+}
+
+// src/interactions/pointerSession/pointerSession.ts
+var LOST_CAPTURE_EVENT = "lostpointercapture";
+function reportsButtons(down) {
+  return !!down.buttons;
+}
+function isMissedRelease(move) {
+  return move.buttons === 0;
+}
+function openPointerSession(origin, down, cb, opts = {}) {
+  const pointerId = down.pointerId;
+  const doc = origin.ownerDocument ?? document;
+  const buttonsReported = reportsButtons(down);
+  let active = true;
+  const teardown = () => {
+    active = false;
+    doc.removeEventListener("pointermove", onMove, true);
+    doc.removeEventListener("pointerup", onUp, true);
+    doc.removeEventListener("pointercancel", onPointerCancel, true);
+    doc.removeEventListener("pointerdown", onRepress, true);
+    origin.removeEventListener(LOST_CAPTURE_EVENT, onLostCapture);
+    if (opts.capture !== false) {
+      try {
+        origin.releasePointerCapture?.(pointerId);
+      } catch {
+      }
+    }
+  };
+  const mine = (e) => e.pointerId === pointerId;
+  const end = (e) => {
+    if (!active) return;
+    teardown();
+    cb.onEnd?.(e);
+  };
+  const abort = (reason) => {
+    if (!active) return;
+    teardown();
+    cb.onCancel?.(reason);
+  };
+  function onMove(e) {
+    if (!active || !mine(e)) return;
+    if (buttonsReported && isMissedRelease(e)) {
+      end(e);
+      return;
+    }
+    cb.onMove?.(e);
+  }
+  function onUp(e) {
+    if (mine(e)) end(e);
+  }
+  function onPointerCancel(e) {
+    if (mine(e)) abort("pointercancel");
+  }
+  function onRepress(e) {
+    if (mine(e)) abort("superseded");
+  }
+  function onLostCapture(e) {
+    if (e.pointerId !== pointerId) return;
+    if (!origin.isConnected) abort("lostcapture");
+  }
+  if (opts.capture !== false) {
+    try {
+      origin.setPointerCapture?.(pointerId);
+    } catch {
+    }
+  }
+  doc.addEventListener("pointermove", onMove, true);
+  doc.addEventListener("pointerup", onUp, true);
+  doc.addEventListener("pointercancel", onPointerCancel, true);
+  doc.addEventListener("pointerdown", onRepress, true);
+  origin.addEventListener(LOST_CAPTURE_EVENT, onLostCapture);
+  return {
+    pointerId,
+    get active() {
+      return active;
+    },
+    cancel: () => abort("aborted")
+  };
+}
+
+// src/tools/routing/reflection/registry.ts
+var PREDICATE_TARGET = "predicate";
+var SPEC_KIND_TO_GESTURE = {
+  key: "keyDown",
+  "key-held": "keyHeld",
+  wheel: "wheel",
+  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;
+}
+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/tools/routing/reflection/conflicts.ts
+function findConflicts(tools) {
+  return findConflictsKeyed(tools).map((k) => k.conflict);
+}
+function findConflictsKeyed(tools) {
+  const entries = buildRouteRegistry(tools);
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const arg of argKeysOf(entry)) {
+      const key = `${entry.phase}|${entry.gesture}|${arg}|${targetKey(entry)}|${canonicalModifiers(entry.modifiers)}`;
+      const bucket = groups.get(key);
+      if (bucket) {
+        if (!bucket.includes(entry)) bucket.push(entry);
+      } else groups.set(key, [entry]);
+    }
+  }
+  const conflicts = [];
+  for (const [key, bucket] of groups) {
+    if (bucket.length < 2) continue;
+    const first = bucket[0];
+    conflicts.push({
+      key,
+      conflict: {
+        phase: first.phase,
+        gesture: first.gesture,
+        arg: first.arg,
+        target: first.target,
+        modifiers: first.modifiers,
+        toolIds: bucket.map((e) => e.toolId)
+      }
+    });
+  }
+  return conflicts;
+}
+function argKeysOf(entry) {
+  const alts = entry.argAlternatives;
+  if (alts && alts.length > 0) return [...new Set(alts.map((a) => a.toLowerCase()))];
+  return [(entry.arg ?? "").toLowerCase()];
+}
+function targetKey(entry) {
+  if (entry.target !== PREDICATE_TARGET) return entry.target ?? "";
+  const spec = entry.spec;
+  const pred = spec.target;
+  if (typeof pred !== "object" || pred === null) return PREDICATE_TARGET;
+  return `${PREDICATE_TARGET}#${predicateId(pred)}`;
+}
+var PREDICATE_IDS = /* @__PURE__ */ new WeakMap();
+var nextPredicateId = 0;
+function predicateId(pred) {
+  let id = PREDICATE_IDS.get(pred);
+  if (id === void 0) {
+    id = nextPredicateId++;
+    PREDICATE_IDS.set(pred, id);
+  }
+  return id;
+}
+function actionAsTool(action) {
+  return { id: action.id, eligibility: {}, bindings: actionBindings(action) };
+}
+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 out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (keyed) => {
+    for (const { key, conflict } of keyed) {
+      const dedupeKey = `${key}|${conflict.toolIds.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));
+  const hotkey = [
+    ...registry.filter((t) => t.def?.hotkey !== void 0),
+    ...hotkeyActions
+  ];
+  if (hotkey.length > 1) add(findConflictsKeyed(hotkey));
+  return out;
+}
+function formatConflict(conflict) {
+  const route = formatRoute({
+    phases: [{ channel: "&", phase: conflict.phase === "any" ? "*" : conflict.phase }],
+    gesture: conflict.gesture,
+    arg: conflict.arg,
+    target: conflict.target,
+    modifiers: conflict.modifiers
+  });
+  return `${route} \u2014 declared by ${conflict.toolIds.join(", ")}`;
+}
+function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
+  const conflicts = findScopedConflicts(scopes);
+  for (const c of conflicts) {
+    warn(
+      `[weasel] route conflict: two bindings declare the same (phase, gesture, arg, target, modifiers) tuple in the same scope, so declaration order alone decides which one fires.
+  ${formatConflict(c)}`
+    );
+  }
+  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 === "";
+}
+function keyMatches(eventKey, spec) {
+  const want = typeof spec === "string" ? [spec] : spec;
+  const ek = eventKey.toLowerCase();
+  return want.some((k) => k.toLowerCase() === ek);
+}
+function matchesKeyBinding(e, b) {
+  if (!keyMatches(e.key, b.key)) return false;
+  const wantsMod = b.mod === true;
+  const hasMod = e.metaKey || e.ctrlKey;
+  if (wantsMod !== hasMod) return false;
+  const wantsAlt = b.alt === true;
+  if (wantsAlt !== e.altKey) return false;
+  const shift = b.shift;
+  if (shift === void 0 || shift === false) {
+    if (e.shiftKey) return false;
+  } else if (shift === true) {
+    if (!e.shiftKey) return false;
+  }
+  return true;
+}
+
+// src/ingestion/ingestItems.ts
+var INGEST_STRING_MIMES = /* @__PURE__ */ new Set([
+  "text/plain",
+  "text/html",
+  "text/uri-list"
+]);
+var FALLBACK_MIME = "application/octet-stream";
+function normalizeMime(raw) {
+  const bare = raw.split(";")[0].trim().toLowerCase();
+  return bare || FALLBACK_MIME;
+}
+function itemsFromFiles(files) {
+  return files.map((file) => ({ kind: "file", mime: normalizeMime(file.type), file }));
+}
+function itemsFromDataTransfer(dt) {
+  const files = [];
+  const strings = [];
+  const reads = [];
+  for (const item of Array.from(dt.items ?? [])) {
+    if (item.kind === "file") {
+      const file = item.getAsFile();
+      if (file) files.push({ kind: "file", mime: normalizeMime(file.type), file });
+    } else if (item.kind === "string") {
+      const mime = normalizeMime(item.type);
+      if (INGEST_STRING_MIMES.has(mime)) {
+        const slot = strings.length;
+        strings.push(null);
+        reads.push(
+          new Promise((resolve) => {
+            item.getAsString((text) => {
+              strings[slot] = { kind: "string", mime, text };
+              resolve();
+            });
+          })
+        );
+      }
+    }
+  }
+  if (files.length === 0 && reads.length === 0) {
+    for (const file of Array.from(dt.files ?? [])) {
+      files.push({ kind: "file", mime: normalizeMime(file.type), file });
+    }
+  }
+  return Promise.all(reads).then(() => [...files, ...strings]);
+}
+function itemsFromClipboardData(cd) {
+  const out = [];
+  for (const file of Array.from(cd.files ?? [])) {
+    out.push({ kind: "file", mime: normalizeMime(file.type), file });
+  }
+  for (const mime of INGEST_STRING_MIMES) {
+    const text = cd.getData(mime);
+    if (text) out.push({ kind: "string", mime, text });
+  }
+  return out;
+}
+
+// src/viewport/clientToCanvas.ts
+function clientToCanvas(canvas, clientX, clientY) {
+  const rect = canvas.getBoundingClientRect();
+  return [clientX - rect.left, clientY - rect.top];
+}
+function clientToCanvasRect(rect, clientX, clientY) {
+  return [clientX - rect.left, clientY - rect.top];
+}
+
+// src/dlog.ts
+var KEYS = ["weasel.debug", "weaseldraw.debug"];
+var cached = null;
+function read() {
+  const empty = { all: false, set: /* @__PURE__ */ new Set() };
+  if (typeof localStorage === "undefined") return empty;
+  try {
+    for (const k of KEYS) {
+      const v = localStorage.getItem(k);
+      if (v == null || v === "") continue;
+      if (v === "1" || v === "true" || v === "*") return { all: true, set: /* @__PURE__ */ new Set() };
+      return { all: false, set: new Set(v.split(/[\s,]+/).filter(Boolean)) };
+    }
+    return empty;
+  } catch {
+    return empty;
+  }
+}
+function get() {
+  if (cached === null) cached = read();
+  return cached;
+}
+function isDebugEnabled(namespace) {
+  const c = get();
+  if (c.all) return true;
+  if (namespace === void 0) return c.set.size > 0;
+  return c.set.has(namespace);
+}
+function dlog(namespace, ...args) {
+  if (!isDebugEnabled(namespace)) return;
+  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-Y5FHAA4U.js.map
+//# sourceMappingURL=chunk-Y5FHAA4U.js.map