@weasel-js/routing 1.10.1 → 1.11.1

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

@@ -1,17 +1,53 @@
+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, prefValueAtPath } 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/actionSettings.ts
+var EMPTY = { values: {} };
+function readActionSettings(action, deps) {
+  const settings = action.settings;
+  if (!settings) return null;
+  try {
+    return settings.read(deps ?? {});
+  } catch {
+    return EMPTY;
+  }
+}
+function actionSettingsParams(settings, path, value) {
+  return settings.params ? settings.params(path, value) : { [path]: value };
+}
 
 // src/interactions/actions/binding.ts
 function actionBindings(action) {
@@ -26,22 +62,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 +146,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)]);
@@ -219,13 +285,21 @@ var DepNode = class extends ScopeNode {
       };
     },
     get: (name) => {
+      const stacks = [...this.start().chain()].map((n) => n.sources.get(name) ?? []);
+      return readFrom(stacks, 0, (stacks[0]?.length ?? 0) - 1);
+    },
+    subscribe: (listener) => this.tree.listeners.subscribe(listener),
+    list: () => {
+      const found = /* @__PURE__ */ new Map();
+      let depth = 0;
       for (const n of this.start().chain()) {
-        const source = n.sources.get(name)?.at(-1);
-        if (source) return source();
+        for (const [name, stack] of n.sources) {
+          if (!found.has(name)) found.set(name, { name, depth, stacked: stack.length });
+        }
+        depth++;
       }
-      return void 0;
+      return [...found.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     },
-    subscribe: (listener) => this.tree.listeners.subscribe(listener),
     changed: () => this.changed()
   };
   constructor(parent, descends) {
@@ -233,6 +307,11 @@ var DepNode = class extends ScopeNode {
     NODES.set(this.registry, this);
   }
 };
+function readFrom(stacks, scope, index) {
+  if (scope >= stacks.length) return void 0;
+  if (index < 0) return readFrom(stacks, scope + 1, (stacks[scope + 1]?.length ?? 0) - 1);
+  return stacks[scope][index](() => readFrom(stacks, scope, index - 1));
+}
 var NODES = /* @__PURE__ */ new WeakMap();
 function depNodeOf(registry) {
   return registry ? NODES.get(registry) ?? null : null;
@@ -281,18 +360,50 @@ 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 { ...under, ...over };
-  return () => ({ ...resolveParams(under), ...resolveParams(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) => ({ ...resolveParams(params), ...given });
+  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(
@@ -307,16 +418,49 @@ 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;
-  if (invoker === action.invoker && bindings === null) return action;
+  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);
@@ -404,7 +548,8 @@ function routesForSpec(spec) {
   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 }));
+  const held = spec.kind === "hover" && spec.held !== void 0 ? { held: spec.held === true ? "required" : "optional" } : {};
+  return args.map((arg) => formatRoute({ phases, gesture, arg, target, modifiers, ...held }));
 }
 function entryFor(ownerId, spec, actionId) {
   const gesture = routeGestureForSpecKind(spec.kind);
@@ -555,11 +700,11 @@ function matchSortedWithBarred(e, bindings, isMac, engagedChannels, opts = {}) {
     const scopeBarred = [];
     for (const sb of bindings) {
       if (sb.scope !== scope) continue;
-      const admitted = admits(sb);
-      if (!admitted && !opts.collectBarred) continue;
+      const admitted2 = admits(sb);
+      if (!admitted2 && !opts.collectBarred) continue;
       const phaseCtx = { selfChannel: sb.ownerId, engagedChannels: engaged };
       if (matchSpec(e, sb.binding.spec, isMac, phaseCtx)) {
-        (admitted ? scopeMatches : scopeBarred).push({ binding: sb.binding, scope, ownerId: sb.ownerId });
+        (admitted2 ? scopeMatches : scopeBarred).push({ binding: sb.binding, scope, ownerId: sb.ownerId });
       }
     }
     scopeMatches.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
@@ -818,40 +963,13 @@ function buildRuleCtx(args) {
   };
 }
 
-// src/interactions/dispatcher/dispatchTrace.ts
-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 publishLiveDispatch(explain2) {
-  if (!DEV2 || typeof window === "undefined") return;
-  window.__weaselDispatchLive__ = explain2;
-}
-function recordModeSwitch(mode, from, to, detail) {
-  recordTrace({
-    kind: "mode",
-    ts: Date.now(),
-    mode,
-    from,
-    to,
-    ...detail !== void 0 ? { detail } : {}
-  });
-}
-
 // src/interactions/dispatcher/gestureIds.ts
 function pointerGestureId(pointerId) {
   return `pointer-${pointerId ?? "mouse"}`;
 }
+function carryGestureId(pointerId) {
+  return `carry-${pointerId ?? "mouse"}`;
+}
 function multiTouchGestureId(fingers) {
   return `multitouch-${fingers}`;
 }
@@ -868,6 +986,9 @@ function gestureIdFor(event) {
   if (event.kind === "multitouch") {
     return multiTouchGestureId(event.fingers);
   }
+  if (event.kind === "carry") {
+    return carryGestureId(event.pointerId);
+  }
   return `ongoing-${event.kind}`;
 }
 
@@ -911,6 +1032,51 @@ function assembleEntries(entries, inputs) {
     }
   };
 }
+function createTraceRing(limit = 200, dev = isDev()) {
+  const entries = [];
+  const pushed = createEmitter();
+  let total = 0;
+  let watchers = 0;
+  const recording = () => dev || watchers > 0;
+  return {
+    recording,
+    push(entry) {
+      if (!recording()) return;
+      entries.push(entry);
+      if (entries.length > limit) entries.shift();
+      total++;
+      pushed.emit();
+    },
+    since(cursor) {
+      const first = total - entries.length;
+      return { entries: entries.slice(Math.max(cursor, first) - first), cursor: total };
+    },
+    watch() {
+      watchers++;
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        watchers--;
+      };
+    },
+    subscribe: pushed.subscribe
+  };
+}
+function createDispatchTrace(limit, dev) {
+  const ring = createTraceRing(limit, dev);
+  let explain2 = null;
+  return {
+    ...ring,
+    recordModeSwitch(mode, from, to, detail) {
+      ring.push({ kind: "mode", ts: Date.now(), mode, from, to, ...detail !== void 0 ? { detail } : {} });
+    },
+    setLive(next) {
+      explain2 = next;
+    },
+    live: () => explain2?.() ?? null
+  };
+}
 
 // src/interactions/dispatcher/inputFacts.ts
 function modifiersOf(e) {
@@ -925,11 +1091,14 @@ 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;
   }
 }
 function carriedBy(event) {
+  if (event.kind === "carry") return { items: [], carry: { type: event.type, value: event.value } };
   return event.kind === "drop" || event.kind === "paste" ? { items: event.items } : void 0;
 }
 function immediateParams(event, resolved) {
@@ -965,8 +1134,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,
@@ -985,6 +1165,20 @@ function immediateParams(event, resolved) {
         affordance: event.affordance,
         bodyTarget: event.bodyTarget,
         mods: modifiersOf(event),
+        held: event.held === true,
+        ...resolved
+      };
+    case "carry":
+      return {
+        worldX: event.x,
+        worldY: event.y,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        carry: { type: event.type, value: event.value },
+        affordance: event.affordance,
+        bodyTarget: event.bodyTarget,
+        bodyKind: event.bodyKind,
+        mods: modifiersOf(event),
         ...resolved
       };
     case "drop":
@@ -1005,16 +1199,20 @@ function liveInView(binding, view) {
   const views = binding.opts?.views;
   return views === void 0 || views.includes(view);
 }
+function liveForKeys(binding, reach) {
+  if (reach === void 0) return true;
+  return binding.opts?.over ? reach.over : reach.held;
+}
 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?.();
@@ -1030,7 +1228,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 = () => {
@@ -1041,7 +1239,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);
@@ -1133,8 +1331,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,
@@ -1167,7 +1367,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 } : {},
@@ -1179,12 +1381,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();
     }
   };
 }
@@ -1229,7 +1433,7 @@ function createInFlightGestures() {
       let cursor = null;
       for (const [id, handle] of handles) {
         const action = actions.get(id);
-        const spec = handle.cursor?.() ?? action?.activeCursor ?? action?.cursor;
+        const spec = handle.cursor?.() ?? action?.activeCursor ?? actionCursor(action);
         if (spec !== void 0 && resolveCursor(spec)) cursor = spec;
       }
       return cursor;
@@ -1321,6 +1525,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") {
@@ -1335,6 +1540,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;
 }
@@ -1385,6 +1593,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) {
@@ -1402,7 +1617,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 === "leave" ? "unhandled" : void 0;
+  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 timing === "immediate" ? event.stage === "drop" : event.stage === "enter" || event.stage === "move";
+}
 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));
@@ -1421,7 +1652,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);
@@ -1528,16 +1760,20 @@ function assembleScopedBindings(ctx) {
     ...allowedCapabilities ? { allowedCapabilities } : {}
   });
   const view = ctx.viewId ?? null;
-  const result = scopeBindings(ordered, state).filter((sb) => liveInView(sb.binding, view));
+  const live = (b) => liveInView(b, view) && liveForKeys(b, ctx.keyReach);
+  const result = scopeBindings(ordered, state).filter((sb) => live(sb.binding));
   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;
+      if (!live(binding)) continue;
       result.push({ binding, scope: targetScope, ownerId: null });
     }
   }
   return result;
 }
+function anyBinding(ctx, test) {
+  return assembleScopedBindings(ctx).some((sb) => test(sb.binding.spec));
+}
 function buildActionMap(registry) {
   const map = /* @__PURE__ */ new Map();
   for (const action of registry.list()) {
@@ -1690,9 +1926,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);
@@ -1711,17 +1952,20 @@ 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);
-    const r = rank(event, ctx, inFlight.engagedOwners(), DEV2);
+    const trace = ctx.trace?.recording() ? ctx.trace : null;
+    const r = rank(event, ctx, inFlight.engagedOwners(), trace !== null);
     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));
+    trace?.push(buildDispatchRecord(r, walked, event, ctx, false, outcome));
     return outcome;
   }
   function hover(event, ctx) {
@@ -1869,6 +2113,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);
@@ -2089,6 +2402,20 @@ function normalizeMime(raw) {
   const bare = raw.split(";")[0].trim().toLowerCase();
   return bare || FALLBACK_MIME;
 }
+var admitted = /* @__PURE__ */ new Map();
+function admitIngestMime(mime) {
+  const key = normalizeMime(mime);
+  admitted.set(key, (admitted.get(key) ?? 0) + 1);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const n = (admitted.get(key) ?? 1) - 1;
+    if (n > 0) admitted.set(key, n);
+    else admitted.delete(key);
+  };
+}
+var keepsString = (mime) => INGEST_STRING_MIMES.has(mime) || admitted.has(mime);
 function itemsFromFiles(files) {
   return files.map((file) => ({ kind: "file", mime: normalizeMime(file.type), file }));
 }
@@ -2102,7 +2429,7 @@ function itemsFromDataTransfer(dt) {
       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)) {
+      if (keepsString(mime)) {
         const slot = strings.length;
         strings.push(null);
         reads.push(
@@ -2128,7 +2455,7 @@ function itemTypesFromDataTransfer(dt) {
   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);
+    else if (keepsString(mime)) mimes.push(mime);
   }
   if (mimes.length === 0 && Array.from(dt.types ?? []).includes("Files")) mimes.push(UNKNOWN_MIME);
   return mimes.map((mime) => ({ mime }));
@@ -2138,7 +2465,7 @@ function itemsFromClipboardData(cd) {
   for (const file of Array.from(cd.files ?? [])) {
     out.push({ kind: "file", mime: normalizeMime(file.type), file });
   }
-  for (const mime of INGEST_STRING_MIMES) {
+  for (const mime of /* @__PURE__ */ new Set([...INGEST_STRING_MIMES, ...admitted.keys()])) {
     const text = cd.getData(mime);
     if (text) out.push({ kind: "string", mime, text });
   }
@@ -2191,6 +2518,332 @@ 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, tuneAction, validateActionDefaultBinding, validateActionId };
-//# sourceMappingURL=chunk-VCEIQ64H.js.map
-//# sourceMappingURL=chunk-VCEIQ64H.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 } : {};
+  if (it.action.settings) return settingsOf(ctx, it, key, label, off || !evaluateEnabled(it.action, deps, ctx.at).enabled, access);
+  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 settingsOf(ctx, it, key, label, off, access) {
+  const settings = it.action.settings;
+  const state = off ? null : readActionSettings(it.action, ctx.src.depsFor(it.action));
+  const mixed = new Set(state?.mixed ?? []);
+  const values = (path) => mixed.has(path) ? void 0 : prefValueAtPath(state?.values, path);
+  const onChange = (path, value) => {
+    const params = actionSettingsParams(settings, path, value);
+    if (params) ctx.src.trigger(it.action.id, { ...ctx.params, ...it.params, ...params });
+  };
+  const form = {
+    ...ctx,
+    src: { ...ctx.src, values, onChange, over: settings.schema },
+    root: settings.schema,
+    read: (path, from) => from === "item" ? void 0 : values(path)
+  };
+  const entries = state ? tidy(groupRows(form, settings.schema, "", false)) : [];
+  return {
+    kind: "submenu",
+    key,
+    label,
+    ...it.icon ? { icon: it.icon } : {},
+    ...withAccess(access),
+    ...entries.length === 0 ? { disabled: true } : {},
+    entries
+  };
+}
+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, off) {
+  const { values, onChange } = ctx.src;
+  if (!values) return [];
+  if (leaf.readout || !onChange) {
+    return [{ kind: "item", key, label: `${leaf.name}: ${textAt(ctx, path) ?? "\u2014"}`, ...withAccess(leaf.access), disabled: true, run: noop }];
+  }
+  const stored = values(path);
+  return [{
+    kind: "text",
+    key,
+    label: leaf.name,
+    ...withAccess(leaf.access),
+    ...leaf.icon ? { icon: leaf.icon } : {},
+    ...off ? { disabled: true } : {},
+    value: typeof stored === "string" ? stored : void 0,
+    set: (text) => onChange(path, text)
+  }];
+}
+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, off);
+    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, DepNode, INGEST_STRING_MIMES, LONG_PRESS_HAPTIC_MS, NEVER, PREDICATE_TARGET, ScopeNode, TOOL_OFFHAND_ID, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, actionShortcuts, addCarrySurface, admitIngestMime, anyBinding, assembleEntries, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, carryGestureId, clientToCanvas, clientToCanvasRect, createDepRegistry, createDispatchTrace, createDispatcher, createLongPressStore, createMenuHost, createTraceRing, depNodeOf, describeRule, dlog, dwarn, evaluate, evaluateActive, evaluateEnabled, findConflicts, heldKeySpec, historyKey, isDebugEnabled, isTool, itemTypesFromDataTransfer, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, keySpecShortcut, keysHeld, liveScope, makeToolOffhandAction, matchBest, matchSorted, matchSortedWithBarred, matchesKeyBinding, mergeMenuDefs, multiTouchGestureId, offhandKeyFor, openPointerSession, pickMenu, pointerGestureId, pushOwner, readActionSettings, reportRouteConflicts, resolveDeviceProfile, resolveMenu, resolveParams, resolveSchemaMenu, roleReader, routesForSpec, ruleCanHoldIn, rulesExclusive, scopeBindings, startCarry, targetConsultsAffordance, tuneAction, tunedParams, validateActionDefaultBinding, validateActionId };
+//# sourceMappingURL=chunk-KLBH7VFF.js.map
+//# sourceMappingURL=chunk-KLBH7VFF.js.map