@weasel-js/routing 1.10.0 → 1.11.0

package/dist/{chunk-4DR6AJMN.js → chunk-QBQQIFPI.js}

@@ -1,17 +1,38 @@
+import { isDev } from '@weasel-js/react';
 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';
+import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, isApplePlatform, 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';
+import { prefIsShown, prefIsEnabled, isPrefLeaf, prefAliasTarget, prefLeafAt, prefAliasedLeaf, prefNumberAt, resolvePrefUnit, prefDisplayBounds, prefUnitAccepts } from '@weasel-js/prefs';
+import { endlessAllows } from '@weasel-js/quantity';
 
-// 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/actionItems.ts
+var NO_TAGS = Object.freeze([]);
+function actionItems(action) {
+  if (action.invoker?.timing !== "immediate") return [];
+  if (!action.variants?.length) {
+    return [{ key: action.id, action, label: action.label, icon: action.icon, tags: action.tags ?? NO_TAGS }];
+  }
+  return action.variants.map((v) => ({
+    key: `${action.id}:${v.key}`,
+    action,
+    label: v.label,
+    icon: v.icon ?? action.icon,
+    tags: v.tags ? [...action.tags ?? NO_TAGS, ...v.tags] : action.tags ?? NO_TAGS,
+    params: v.params
+  }));
+}
+function actionItemTitle(item) {
+  if (item.key === item.action.id) return item.label;
+  const words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+  const head = words(item.action.label);
+  const label = words(item.label);
+  for (let i = 0; i + head.length <= label.length; i++) {
+    if (head.every((w, j) => label[i + j] === w)) return item.label;
+  }
+  return `${item.action.label}: ${item.label}`;
+}
 
 // src/interactions/actions/binding.ts
 function actionBindings(action) {
@@ -26,22 +47,60 @@ function actionBindings(action) {
   });
 }
 
-// src/devFlag.ts
-function isDev() {
-  return typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+// src/interactions/actions/actionShortcuts.ts
+function keySpecShortcut(spec) {
+  if (spec.kind !== "key" && spec.kind !== "key-held") return void 0;
+  const key = Array.isArray(spec.key) ? spec.key[0] : spec.key;
+  if (typeof key !== "string" || key.length === 0) return void 0;
+  const mods = "mods" in spec ? spec.mods : void 0;
+  return {
+    key,
+    mod: mods?.mod === true,
+    alt: mods?.alt === true,
+    shift: mods?.shift === true
+  };
+}
+function actionShortcuts(action, params) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { spec, opts } of actionBindings(action)) {
+    if (params && !paramsMatch(opts?.params, params)) continue;
+    const shortcut = keySpecShortcut(spec);
+    if (!shortcut) continue;
+    const token = `${shortcut.key}|${shortcut.mod}|${shortcut.alt}|${shortcut.shift}`;
+    if (seen.has(token)) continue;
+    seen.add(token);
+    out.push(shortcut);
+  }
+  return out;
+}
+function paramsMatch(bound, wanted) {
+  if (typeof bound !== "object" || bound === null) return false;
+  return Object.entries(wanted).every(([k, v]) => bound[k] === v);
 }
 
-// src/interactions/actions/actionEnabled.ts
+// 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"
+};
+function actionCursor(action, params) {
+  const c = action?.cursor;
+  return typeof c === "function" ? c(params) : c;
+}
 var enabledSlowWarned = /* @__PURE__ */ new Set();
 var enabledThrewWarned = /* @__PURE__ */ new Set();
 var ENABLED_BUDGET_MS = 4;
-function evaluateEnabled(action, deps) {
+function evaluateEnabled(action, deps, at) {
   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);
+    const result = action.enabled(deps, at);
     if (dev) {
       const elapsed = now() - start;
       if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {
@@ -72,15 +131,7 @@ function evaluateActive(action, deps) {
     return false;
   }
 }
-
-// src/interactions/actions/buildDeps.ts
-var DEV = (() => {
-  try {
-    return Boolean(import.meta.env?.DEV);
-  } catch {
-    return false;
-  }
-})();
+var DEV = isDev();
 function buildDepsFromRequires(action, depRegistry) {
   const requires = action.requires ?? [];
   const entries = requires.map((name) => [name, depRegistry.get(name)]);
@@ -281,6 +332,112 @@ function resolveParams(params) {
   if (params === void 0) return void 0;
   return typeof params === "function" ? params() : params;
 }
+function keysHeld(keys, modifiers, isMac) {
+  return keys.some((k) => {
+    if (k === "mod") return isMac ? modifiers.meta : modifiers.ctrl;
+    return modifiers[k];
+  });
+}
+function roleKeysOf(roles, rebinds) {
+  if (!roles) return void 0;
+  const out = {};
+  for (const id of Object.keys(roles)) out[id] = rebinds?.[id] ?? roles[id].keys;
+  return out;
+}
+function platformRoleKeys(keys, isMac) {
+  const out = {};
+  for (const id of Object.keys(keys)) out[id] = keys[id].map((k) => k === "mod" ? isMac ? "meta" : "ctrl" : k);
+  return out;
+}
+function resolveRoles(keys, modifiers, isMac) {
+  const out = {};
+  for (const id of Object.keys(keys)) out[id] = keysHeld(keys[id], modifiers, isMac);
+  return out;
+}
+function rebindRoles(roles, rebinds) {
+  const out = {};
+  for (const id of Object.keys(roles)) {
+    out[id] = rebinds[id] ? { ...roles[id], keys: rebinds[id] } : roles[id];
+  }
+  return out;
+}
+function roleReader(roles) {
+  return (ctx, id) => ctx.roles?.[id] ?? keysHeld(roles[id].keys, ctx.modifiers, isApplePlatform());
+}
+
+// src/interactions/actions/tuning.ts
+var WRAPS = /* @__PURE__ */ new WeakMap();
+function layered(under, over) {
+  if (typeof under !== "function" && typeof over !== "function") return tunedParams([{ params: under }], over);
+  return () => tunedParams([{ params: 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) => tunedParams([{ 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))];
+}
+var CURSOR_WRAPS = /* @__PURE__ */ new WeakMap();
+function wrapCursor(cursor, params) {
+  if (typeof cursor !== "function") return cursor;
+  for (let w = cursor; typeof w === "function"; w = CURSOR_WRAPS.get(w)?.inner) {
+    if (CURSOR_WRAPS.get(w)?.params === params) return cursor;
+  }
+  const wrapped = (given) => cursor(tunedParams([{ params }], given));
+  CURSOR_WRAPS.set(wrapped, { inner: cursor, params });
+  return wrapped;
+}
+var PREVIEW_WRAPS = /* @__PURE__ */ new WeakMap();
+function wrapPreview(preview, params) {
+  if (!preview) return preview;
+  for (let w = preview; w; w = PREVIEW_WRAPS.get(w)?.inner) {
+    if (PREVIEW_WRAPS.get(w)?.params === params) return preview;
+  }
+  const wrapped = (deps, given) => preview(deps, tunedParams([{ params }], given));
+  PREVIEW_WRAPS.set(wrapped, { inner: preview, params });
+  return wrapped;
+}
+function tuneOnce(action, tuning) {
+  const invoker = tuning.params && action.invoker ? wrapInvoker(action.invoker, tuning.params) : action.invoker;
+  const cursor = tuning.params ? wrapCursor(action.cursor, tuning.params) : action.cursor;
+  const preview = tuning.params ? wrapPreview(action.preview, tuning.params) : action.preview;
+  const bindings = tuning.bindings?.length ? withBindings(action.defaultBinding, tuning.bindings) : null;
+  const modifierRoles = tuning.roles && action.modifierRoles ? rebindRoles(action.modifierRoles, tuning.roles) : null;
+  if (invoker === action.invoker && cursor === action.cursor && preview === action.preview && bindings === null && modifierRoles === null) {
+    return action;
+  }
+  return {
+    ...action,
+    ...modifierRoles ? { modifierRoles } : {},
+    ...invoker ? { invoker } : {},
+    ...cursor ? { cursor } : {},
+    ...preview ? { preview } : {},
+    ...bindings ? { defaultBinding: bindings } : {}
+  };
+}
+function tunedParams(tunings, given) {
+  let out = {};
+  for (const t of tunings) out = { ...out, ...resolveParams(t.params) };
+  return { ...out, ...given };
+}
+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";
@@ -301,8 +458,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 } };
@@ -409,6 +570,7 @@ 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];
 }
@@ -771,15 +933,7 @@ function buildRuleCtx(args) {
     device: args.device
   };
 }
-
-// src/interactions/dispatcher/dispatchTrace.ts
-var DEV2 = (() => {
-  try {
-    return Boolean(import.meta.env?.DEV);
-  } catch {
-    return false;
-  }
-})();
+var DEV2 = isDev();
 var TRACE_LIMIT = 200;
 var traceLog = DEV2 && typeof window !== "undefined" ? window.__weaselDispatchLog__ ??= [] : [];
 function recordTrace(entry) {
@@ -822,6 +976,9 @@ function gestureIdFor(event) {
   if (event.kind === "multitouch") {
     return multiTouchGestureId(event.fingers);
   }
+  if (event.kind === "carry") {
+    return `carry-${event.pointerId ?? "mouse"}`;
+  }
   return `ongoing-${event.kind}`;
 }
 
@@ -879,6 +1036,8 @@ function worldPointOf(event) {
     case "doubleclick":
     case "contextmenu":
       return event.x !== void 0 && event.y !== void 0 ? { x: event.x, y: event.y } : void 0;
+    case "carry":
+      return { x: event.x, y: event.y };
     default:
       return void 0;
   }
@@ -919,8 +1078,19 @@ function immediateParams(event, resolved) {
       };
     // Only a `stage: 'press'` pointerdown reaches an immediate invoker: the
     // buffered copy matches `drag` specs, which are ongoing.
-    case "pointerdown":
     case "contextmenu":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        affordance: event.affordance,
+        bodyTarget: event.bodyTarget,
+        bodyKind: event.bodyKind,
+        mods: modifiersOf(event),
+        ...resolved
+      };
+    case "pointerdown":
     case "longpress":
       return {
         worldX: event.x,
@@ -941,6 +1111,16 @@ function immediateParams(event, resolved) {
         mods: modifiersOf(event),
         ...resolved
       };
+    case "carry":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        carry: { type: event.type, value: event.value },
+        mods: modifiersOf(event),
+        ...resolved
+      };
     case "drop":
     case "paste":
       return {
@@ -962,13 +1142,13 @@ function liveInView(binding, view) {
 function namesView(binding, view) {
   return binding.opts?.views?.includes(view) ?? false;
 }
-function preferViewScoped(matches, view) {
+function preferViewScoped(matches2, view) {
   const named = [];
   const rest = [];
-  for (const m of matches) {
+  for (const m of matches2) {
     (namesView(m.binding, view) ? named : rest).push(m);
   }
-  return named.length === 0 ? [...matches] : [...named, ...rest];
+  return named.length === 0 ? [...matches2] : [...named, ...rest];
 }
 function ruleCtxOf(ctx) {
   const r = ctx.getRuleCtx?.();
@@ -984,7 +1164,7 @@ function isEligible(action, ruleCtx) {
 function describeEligible(eligible) {
   return describeRule(eligibleToRule(eligible));
 }
-function preferContextual(matches, actionLookup, holds, view) {
+function preferContextual(matches2, actionLookup, holds, view) {
   const out = [];
   let run = [];
   const flush = () => {
@@ -995,7 +1175,7 @@ function preferContextual(matches, actionLookup, holds, view) {
     out.push(...gated, ...run.filter((m) => !gated.includes(m)));
     run = [];
   };
-  for (const m of matches) {
+  for (const m of matches2) {
     const head = run[0];
     if (head && (head.scope !== m.scope || namesView(head.binding, view) !== namesView(m.binding, view) || !sameSpecificity(head.binding.spec, m.binding.spec))) flush();
     run.push(m);
@@ -1087,8 +1267,10 @@ function createGestureFacts() {
   const points = /* @__PURE__ */ new Map();
   const startSpreads = /* @__PURE__ */ new Map();
   const turns = /* @__PURE__ */ new Map();
+  const roles = /* @__PURE__ */ new Map();
   return {
-    begin(gestureId, event) {
+    begin(gestureId, event, roleKeys) {
+      if (roleKeys) roles.set(gestureId, roleKeys);
       if (event.kind === "pointerdown") {
         origins.set(gestureId, {
           x: event.x ?? 0,
@@ -1121,7 +1303,9 @@ function createGestureFacts() {
       const trail = points.get(gestureId);
       const startSpread = startSpreads.get(gestureId);
       const turn = turns.get(gestureId);
+      const roleKeys = roles.get(gestureId);
       return {
+        ...roleKeys !== void 0 ? { roleKeys } : {},
         ...origin !== void 0 ? { origin } : {},
         ...trail !== void 0 ? { points: trail } : {},
         ...startSpread !== void 0 ? { startSpread } : {},
@@ -1133,12 +1317,14 @@ function createGestureFacts() {
       points.delete(gestureId);
       startSpreads.delete(gestureId);
       turns.delete(gestureId);
+      roles.delete(gestureId);
     },
     clear() {
       origins.clear();
       points.clear();
       startSpreads.clear();
       turns.clear();
+      roles.clear();
     }
   };
 }
@@ -1181,8 +1367,9 @@ function createInFlightGestures() {
     },
     cursor() {
       let cursor = null;
-      for (const action of actions.values()) {
-        const spec = action.activeCursor ?? action.cursor;
+      for (const [id, handle] of handles) {
+        const action = actions.get(id);
+        const spec = handle.cursor?.() ?? action?.activeCursor ?? actionCursor(action);
         if (spec !== void 0 && resolveCursor(spec)) cursor = spec;
       }
       return cursor;
@@ -1274,6 +1461,7 @@ function buildInvocationCtx(event, deps, viewId, facts = {}) {
   };
   const screen = clientPoint(event);
   if (screen) base.screen = screen;
+  if (facts.roleKeys) base.roles = resolveRoles(facts.roleKeys, base.modifiers, false);
   if (event.kind === "key") {
     base.key = { key: event.key, repeat: event.repeat ?? false };
   } else if (event.kind === "key-held") {
@@ -1288,6 +1476,9 @@ function buildInvocationCtx(event, deps, viewId, facts = {}) {
     Object.assign(base, pumpDrag(event, facts));
   } else if (event.kind === "multitouch") {
     base.multiTouch = multiTouchOf(event, facts);
+  } else if (event.kind === "carry") {
+    base.world = { x: event.x, y: event.y };
+    base.carry = { type: event.type, value: event.value };
   }
   return base;
 }
@@ -1338,6 +1529,13 @@ function pumpGesture(run, event) {
     handle.onMove(ctxFor(run, event, {}, gestureId));
     return "handled";
   }
+  if (event.kind === "wheel") {
+    for (const [gestureId, handle] of [...inFlight.handles].reverse()) {
+      if (handle.onWheel?.(ctxFor(run, event, {}, gestureId)) === true) return "handled";
+    }
+    return void 0;
+  }
+  if (event.kind === "carry") return pumpCarry(run, event);
   if (event.kind === "pointerup") return ended("commit");
   if (event.kind === "pointercancel") return ended("cancel");
   if (event.kind === "multitouch" && event.end !== void 0) {
@@ -1355,7 +1553,23 @@ function pumpGesture(run, event) {
   }
   return void 0;
 }
+function pumpCarry(run, event) {
+  if (event.stage === "enter") return void 0;
+  const gestureId = gestureIdFor(event);
+  const handle = run.inFlight.handles.get(gestureId);
+  if (!handle) return event.stage === "drop" ? void 0 : "unhandled";
+  if (event.stage === "move") {
+    handle.onMove?.(ctxFor(run, event, {}, gestureId));
+    return "handled";
+  }
+  return endGesture(run, gestureId, event, event.stage === "drop" ? "commit" : "cancel") ? "handled" : "unhandled";
+}
+function carryStageFits(event, timing) {
+  if (event.kind !== "carry") return true;
+  return event.stage === (timing === "immediate" ? "drop" : "enter");
+}
 function invokeAction(run, event, match, action, deps) {
+  if (action.invoker && !carryStageFits(event, action.invoker.timing)) return "empty-handle";
   if (action.invoker?.timing === "immediate") {
     try {
       const params = immediateParams(event, resolveParams(match.binding.opts?.params));
@@ -1374,7 +1588,8 @@ function invokeAction(run, event, match, action, deps) {
       return "misbound";
     }
     const gestureId = gestureIdFor(event);
-    run.facts.begin(gestureId, event);
+    const roleKeys = roleKeysOf(action.modifierRoles, match.binding.opts?.roles);
+    run.facts.begin(gestureId, event, roleKeys && platformRoleKeys(roleKeys, run.isMac()));
     const handle = action.invoker.start(ctxFor(run, event, deps, gestureId), match.binding.opts);
     if (isEmptyOngoingHandle(handle)) {
       run.facts.drop(gestureId);
@@ -1643,9 +1858,14 @@ function resolveOnly(event, ctx, engaged) {
     actionId: winner.action.id,
     action: winner.action,
     scope: winner.match.scope,
-    ownerId: winner.match.ownerId
+    ownerId: winner.match.ownerId,
+    ...paramsOf(winner.match.binding)
   };
 }
+function paramsOf(binding) {
+  const params = resolveParams(binding.opts?.params);
+  return params ? { params } : {};
+}
 function explain(event, ctx, engaged, opts) {
   const r = rank(event, ctx, engaged, true);
   const walked = walk(r, event, ctx, null, opts?.evaluateShadowed ?? false);
@@ -1664,10 +1884,12 @@ function createDispatcher(opts) {
   }
   const uiOngoing = createUiOngoing(inFlight, notify, opts?.getAction);
   let routedView;
-  const run = { inFlight, facts, viewId: () => routedView };
+  let routedIsMac = false;
+  const run = { inFlight, facts, viewId: () => routedView, isMac: () => routedIsMac };
   const invoking = (event) => (match, action, deps) => invokeAction(run, event, match, action, deps);
   function handleInput(event, ctx) {
     routedView = ctx.viewId;
+    routedIsMac = ctx.isMac;
     const pumped = pumpGesture(run, event);
     if (pumped !== void 0) return pumped;
     if (event.kind === "hover") return hover(event, ctx);
@@ -1822,6 +2044,75 @@ function openPointerSession(origin, down, cb, opts = {}) {
   };
 }
 
+// src/interactions/carry/carry.ts
+var surfaces = /* @__PURE__ */ new Set();
+function addCarrySurface(surface) {
+  surfaces.add(surface);
+  return () => {
+    surfaces.delete(surface);
+  };
+}
+function contains(r, x, y) {
+  return x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
+}
+function surfaceAt(doc, x, y) {
+  const hit = typeof doc.elementFromPoint === "function" ? doc.elementFromPoint(x, y) : null;
+  let best = null;
+  for (const s of surfaces) {
+    if (!contains(s.element.getBoundingClientRect(), x, y)) continue;
+    if (hit && !s.element.contains(hit)) continue;
+    if (best && s.element.contains(best.element)) continue;
+    best = s;
+  }
+  return best;
+}
+function startCarry(origin, down, payload, cb = {}) {
+  const doc = origin.ownerDocument ?? document;
+  const pointerId = down.pointerId;
+  let over = null;
+  const leave = (at) => {
+    const was = over;
+    over = null;
+    if (was && surfaces.has(was)) was.receive("leave", payload, at, pointerId);
+  };
+  const step = (at) => {
+    const next = surfaceAt(doc, at.clientX, at.clientY);
+    if (next === over) {
+      over?.receive("move", payload, at, pointerId);
+      return;
+    }
+    leave(at);
+    over = next;
+    next?.receive("enter", payload, at, pointerId);
+  };
+  let last = down;
+  const session = openPointerSession(origin, down, {
+    onMove: (e) => {
+      last = e;
+      step(e);
+      cb.onMove?.(e);
+    },
+    onEnd: (e) => {
+      step(e);
+      const on = over;
+      over = null;
+      const taken = on !== null && surfaces.has(on) && on.receive("drop", payload, e, pointerId) === "handled";
+      cb.onEnd?.({ taken, event: e });
+    },
+    onCancel: (reason) => {
+      leave(last);
+      cb.onCancel?.(reason);
+    }
+  });
+  return {
+    pointerId,
+    get active() {
+      return session.active;
+    },
+    cancel: () => session.cancel()
+  };
+}
+
 // src/tools/types.ts
 function isTool(entry) {
   return !!(entry.eligibility?.focus || entry.eligibility?.offhand);
@@ -2144,6 +2435,291 @@ function dwarn(namespace, ...args) {
   console.warn(`[${namespace}]`, ...args);
 }
 
-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, validateActionDefaultBinding, validateActionId };
-//# sourceMappingURL=chunk-4DR6AJMN.js.map
-//# sourceMappingURL=chunk-4DR6AJMN.js.map
+// src/menus/pickMenu.ts
+var oneOf = (want, got) => want === void 0 || (Array.isArray(want) ? want.includes(got) : want === got);
+function matches(when, hit) {
+  return oneOf(when.bodyTarget, hit.bodyTarget) && oneOf(when.bodyKind, hit.bodyKind);
+}
+function mergeMenuDefs(defs, activeTool) {
+  const live = [
+    ...defs.filter((d) => d.owner === null),
+    ...defs.filter((d) => d.owner !== null && d.owner === activeTool)
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const { def } of live) {
+    const prev = byId.get(def.id);
+    if (!prev) {
+      byId.set(def.id, { def: { ...def, menu: { ...def.menu, children: { ...def.menu.children } } }, parts: 1 });
+      continue;
+    }
+    const n = prev.parts++;
+    const children = prev.def.menu.children;
+    children[`~sep${n}`] = { kind: "separator", name: "", description: "", default: void 0 };
+    for (const [k, node] of Object.entries(def.menu.children)) {
+      children[Object.hasOwn(children, k) ? `${k}~${n}` : k] = node;
+    }
+    if (!prev.def.when && def.when) prev.def.when = def.when;
+  }
+  return [...byId.values()].map((m) => m.def);
+}
+function pickMenu(defs, hit) {
+  return defs.find((d) => d.when !== void 0 && matches(d.when, hit));
+}
+var SUBMENU_AS = /* @__PURE__ */ new Set(["menu", "page", "tab", "panel"]);
+var noop = () => {
+};
+var withAccess = (access) => access ? { access } : {};
+var sep = (key) => ({ kind: "separator", key });
+function itemOf(ctx, it, key, label, off, access) {
+  const deps = ctx.src.depsFor(it.action);
+  const point = ctx.at ? { worldX: ctx.at.x, worldY: ctx.at.y } : {};
+  return {
+    kind: "item",
+    key,
+    label,
+    ...withAccess(access),
+    icon: it.icon,
+    shortcut: actionShortcuts(it.action, it.params)[0],
+    disabled: off || !evaluateEnabled(it.action, deps, ctx.at).enabled,
+    checked: evaluateActive(it.action, deps),
+    run: () => {
+      ctx.src.trigger(it.action.id, { ...ctx.params, ...it.params, ...point });
+    }
+  };
+}
+function itemsNamed(ctx, name) {
+  const action = ctx.byId.get(name);
+  if (action) return actionItems(action);
+  const colon = name.indexOf(":");
+  const owner = colon > 0 ? ctx.byId.get(name.slice(0, colon)) : void 0;
+  return owner ? actionItems(owner).filter((it) => it.key === name) : [];
+}
+function actionRows(ctx, leaf, key, off) {
+  const own = leaf.label || leaf.name;
+  if (leaf.action === void 0) {
+    if (!own) return [];
+    if (isDev()) console.warn(`weasel: menu row "${key}" names no registered action, so it does nothing`);
+    return [{ kind: "item", key, label: own, disabled: true, run: noop }];
+  }
+  const items = itemsNamed(ctx, leaf.action);
+  if (items.length === 1) return [itemOf(ctx, items[0], key, own || items[0].label, off, leaf.access)];
+  return items.map((it) => itemOf(ctx, it, `${key}/${it.key}`, it.label, off));
+}
+function siblingsOf(ctx, path) {
+  const dot = path.lastIndexOf(".");
+  const parent = dot < 0 ? void 0 : ctx.src.values(path.slice(0, dot));
+  return parent && typeof parent === "object" ? parent : void 0;
+}
+function booleanRows(ctx, leaf, key, path, off) {
+  const { values, onChange } = ctx.src;
+  if (!values || !onChange) return [];
+  const stored = values(path);
+  const on = leaf.encoding ? leaf.encoding.read(stored, siblingsOf(ctx, path)) : stored === true;
+  const write = (v) => leaf.encoding ? leaf.encoding.write(v, siblingsOf(ctx, path)) : v;
+  return [{
+    kind: "item",
+    key,
+    label: leaf.name,
+    ...withAccess(leaf.access),
+    checked: on,
+    disabled: off || leaf.readout === true,
+    run: leaf.readout ? noop : () => onChange(path, write(!on))
+  }];
+}
+function enumRows(ctx, leaf, key, path, off) {
+  const { values, onChange } = ctx.src;
+  if (!values || !onChange) return [];
+  const stored = values(path);
+  const current = leaf.encoding ? leaf.encoding.read(stored, siblingsOf(ctx, path)) : stored;
+  if (leaf.readout) {
+    const shown = leaf.options.find((o) => o.value === current)?.label ?? "\u2014";
+    return [{ kind: "item", key, label: `${leaf.name}: ${shown}`, disabled: true, run: noop }];
+  }
+  const write = (v) => leaf.encoding ? leaf.encoding.write(v, siblingsOf(ctx, path)) : v;
+  return [
+    sep(`${key}/<`),
+    ...leaf.options.map((o) => ({
+      kind: "item",
+      key: `${key}/${o.value}`,
+      label: o.label,
+      checked: o.value === current,
+      disabled: off || o.disabled === true,
+      run: () => onChange(path, write(o.value))
+    })),
+    sep(`${key}/>`)
+  ];
+}
+function numberRows(ctx, given, key, path, off) {
+  const { values, onChange } = ctx.src;
+  if (!values || !onChange) return [];
+  const leaf = prefNumberAt(given, values);
+  const unit = leaf.unit && resolvePrefUnit(leaf.unit);
+  const stored = values(path);
+  const { min, max, step, endless } = prefDisplayBounds(leaf);
+  const disabled = off || leaf.readout === true;
+  return [{
+    kind: "number",
+    key,
+    label: leaf.name,
+    ...withAccess(leaf.access),
+    ...leaf.icon ? { icon: leaf.icon } : {},
+    ...disabled ? { disabled } : {},
+    value: typeof stored === "number" && (Number.isFinite(stored) || endlessAllows(leaf.endless, stored)) ? unit ? unit.toDisplay(stored) : stored : void 0,
+    ...min === void 0 ? {} : { min },
+    ...max === void 0 ? {} : { max },
+    step,
+    ...unit?.suffix === void 0 ? {} : { suffix: unit.suffix },
+    ...leaf.display ? { display: leaf.display } : {},
+    ...endless ? { endless } : {},
+    ...leaf.infinity === void 0 ? {} : { infinity: leaf.infinity },
+    ...unit ? { accepts: prefUnitAccepts(unit) } : {},
+    set: (shown) => onChange(path, unit ? unit.fromDisplay(shown) : shown)
+  }];
+}
+var textAt = (ctx, path) => {
+  const v = ctx.src.values?.(path);
+  return typeof v === "string" && v !== "" ? v : void 0;
+};
+function colorRows(ctx, leaf, key, path, off) {
+  if (!ctx.src.values) return [];
+  return [{ kind: "color", key, label: leaf.name, ...withAccess(leaf.access), ...off ? { disabled: true } : {}, value: textAt(ctx, path) }];
+}
+function stringRows(ctx, leaf, key, path) {
+  if (!ctx.src.values) return [];
+  return [{ kind: "item", key, label: `${leaf.name}: ${textAt(ctx, path) ?? "\u2014"}`, ...withAccess(leaf.access), disabled: true, run: noop }];
+}
+function leafRows(ctx, leaf, key, path, off) {
+  switch (leaf.kind) {
+    case "action":
+      return actionRows(ctx, leaf, key, off);
+    case "actions": {
+      const group = leaf.group;
+      return ctx.src.actions().filter((a) => a.group === group).flatMap((a) => actionItems(a).map((it) => itemOf(ctx, it, `${key}/${it.key}`, it.label, off)));
+    }
+    case "boolean":
+      return booleanRows(ctx, leaf, key, path, off);
+    case "enum":
+      return enumRows(ctx, leaf, key, path, off);
+    case "number":
+      return numberRows(ctx, leaf, key, path, off);
+    case "color":
+      return colorRows(ctx, leaf, key, path, off);
+    case "string":
+      return stringRows(ctx, leaf, key, path);
+    case "separator":
+      return [sep(key)];
+    case "label":
+      return [{ kind: "item", key, label: leaf.name, ...withAccess(leaf.access), disabled: true, run: noop }];
+    case "alias": {
+      const alias = leaf;
+      const target = prefAliasTarget(alias, (p) => prefLeafAt(ctx.src.over ?? ctx.root, p));
+      return target ? leafRows(ctx, prefAliasedLeaf(alias, target.leaf), key, target.path, off) : [];
+    }
+    default:
+      return [];
+  }
+}
+function groupRows(ctx, group, prefix, off) {
+  const out = [];
+  for (const [k, node] of Object.entries(group.children)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    if (ctx.read && !prefIsShown(node, ctx.read)) continue;
+    const disabled = off || ctx.read !== void 0 && !prefIsEnabled(node, ctx.read);
+    if (isPrefLeaf(node)) {
+      out.push(...leafRows(ctx, node, path, path, disabled));
+    } else if (node.as !== void 0 && SUBMENU_AS.has(node.as)) {
+      const entries = tidy(groupRows(ctx, node, path, disabled));
+      if (entries.length) {
+        out.push({ kind: "submenu", key: path, label: node.name, ...node.icon ? { icon: node.icon } : {}, ...withAccess(node.access), entries });
+      }
+    } else {
+      out.push(sep(`${path}/<`), ...groupRows(ctx, node, path, disabled), sep(`${path}/>`));
+    }
+  }
+  return out;
+}
+function tidy(entries) {
+  const out = [];
+  for (const e of entries) {
+    if (e.kind === "separator" && (!out.length || out[out.length - 1].kind === "separator")) continue;
+    out.push(e);
+  }
+  if (out[out.length - 1]?.kind === "separator") out.pop();
+  return out;
+}
+function resolveSchemaMenu(schema, src, at, params) {
+  const values = src.values;
+  const ctx = {
+    src,
+    byId: new Map(src.actions().map((a) => [a.id, a])),
+    root: schema,
+    read: values ? (path, from) => from === "item" ? void 0 : values(path) : void 0,
+    at,
+    params
+  };
+  return tidy(groupRows(ctx, schema, "", false));
+}
+function resolveMenu(def, src, at, params) {
+  return resolveSchemaMenu(def.menu, src, at, params);
+}
+
+// src/menus/menuHost.ts
+function createMenuHost(src) {
+  const defs = [];
+  const listeners = /* @__PURE__ */ new Set();
+  let open = null;
+  let seq = 0;
+  const emit = () => {
+    for (const fn of listeners) fn();
+  };
+  const close = () => {
+    if (!open) return;
+    open = null;
+    emit();
+  };
+  const resolve = (req) => {
+    const live = mergeMenuDefs(defs, src.activeTool());
+    const def = req.menu !== void 0 ? live.find((d) => d.id === req.menu) : req.hit ? pickMenu(live, req.hit) : void 0;
+    return def ? resolveMenu(def, src, req.world, req.params) : [];
+  };
+  return {
+    define(def, owner = null) {
+      const entry = { def, owner };
+      defs.push(entry);
+      return () => {
+        const i = defs.indexOf(entry);
+        if (i >= 0) defs.splice(i, 1);
+      };
+    },
+    open(req) {
+      const entries = resolve(req);
+      if (!entries.length) {
+        close();
+        return false;
+      }
+      open = {
+        seq: ++seq,
+        entries,
+        client: req.client,
+        world: req.world,
+        ...req.under ? { under: req.under } : {},
+        source: req.source ?? "pointer"
+      };
+      emit();
+      return true;
+    },
+    has: (req) => resolve(req).length > 0,
+    close,
+    current: () => open,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}
+
+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, actionCursor, actionItemTitle, actionItems, actionShortcuts, addCarrySurface, assembleEntries, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, clientToCanvas, clientToCanvasRect, createDepRegistry, createDispatcher, createLongPressStore, createMenuHost, depNodeOf, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, findConflicts, gestureIdFor, heldKeySpec, historyKey, isDebugEnabled, isTool, itemTypesFromDataTransfer, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, keySpecShortcut, keysHeld, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchSortedWithBarred, matchesKeyBinding, mergeMenuDefs, multiTouchGestureId, offhandKeyFor, openPointerSession, pickMenu, pointerGestureId, publishLiveDispatch, pushOwner, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveMenu, resolveParams, resolveSchemaMenu, roleReader, routesForSpec, ruleCanHoldIn, rulesExclusive, scopeBindings, startCarry, targetConsultsAffordance, tuneAction, tunedParams, validateActionDefaultBinding, validateActionId };
+//# sourceMappingURL=chunk-QBQQIFPI.js.map
+//# sourceMappingURL=chunk-QBQQIFPI.js.map