@weasel-js/routing 1.13.0 → 1.14.0

package/dist/chunk-EUCNVGJV.js

@@ -0,0 +1,1103 @@
+import { isDev } from '@weasel-js/react';
+import { createEmitter } from '@weasel-js/registry';
+import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, isApplePlatform, bindingSpec } from '@weasel-js/gestures';
+export { RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, VALID_MOD_NAMES, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, parseRoute } from '@weasel-js/gestures';
+import { isPrefLeaf, isPrefSection, prefScopeIn, prefScopeUnder, prefConditionHolds, isBuiltinPref, prefAliasTarget, prefLeafAt, prefAliasedLeaf, PREF_SCOPE, prefLeaves, prefHoldsValue, prefVariantOf, prefVariantDefault, prefNumberAt, resolvePrefUnit, prefDisplayBounds, prefUnitAccepts, prefObjectBase, prefValueAtPath } from '@weasel-js/prefs';
+import { endlessAllows } from '@weasel-js/quantity';
+
+// 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) {
+  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/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/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, 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, at);
+    if (dev) {
+      const elapsed = now() - start;
+      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {
+        enabledSlowWarned.add(action.id);
+        console.warn(
+          `weasel actions: enabled() for action "${action.id}" took ${elapsed.toFixed(2)}ms (budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast \u2014 see Action.enabled JSDoc.`
+        );
+      }
+    }
+    if (result === true) return { enabled: true };
+    return { enabled: false, reason: result };
+  } catch (e) {
+    if (dev && !enabledThrewWarned.has(action.id)) {
+      enabledThrewWarned.add(action.id);
+      console.warn(
+        `weasel actions: enabled() for action "${action.id}" threw; treating as disabled. The predicate must not throw \u2014 see Action.enabled JSDoc.`,
+        e
+      );
+    }
+    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };
+  }
+}
+function evaluateActive(action, deps) {
+  if (!action.active) return void 0;
+  try {
+    return action.active(deps) === true;
+  } catch {
+    return false;
+  }
+}
+var DEV = isDev();
+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;
+}
+var ScopeNode = class {
+  /** `descends`: whether reads made here answer from the active child down —
+   *  true for a root or a yoke, which chrome reads through; false for a scope,
+   *  which answers for itself even with a scope nested inside it. */
+  constructor(parent, descends) {
+    this.parent = parent;
+    this.descends = descends;
+    this.tree = parent ? parent.tree : { version: 0, listeners: createEmitter() };
+  }
+  parent;
+  descends;
+  tree;
+  children = [];
+  activeChild = null;
+  /** Bump the tree's version and tell every listener in it. */
+  changed() {
+    this.tree.version++;
+    this.tree.listeners.emit();
+  }
+  /** Join the parent's children, newest last; returns the leave. */
+  mount() {
+    const parent = this.parent;
+    if (!parent) return () => {
+    };
+    parent.children.push(this);
+    this.changed();
+    let left = false;
+    return () => {
+      if (left) return;
+      left = true;
+      const i = parent.children.lastIndexOf(this);
+      if (i !== -1) parent.children.splice(i, 1);
+      if (parent.activeChild === this) parent.activeChild = null;
+      this.changed();
+    };
+  }
+  /** Make this node the one its ancestors resolve through. */
+  activate() {
+    let moved = false;
+    for (let n = this; n.parent; n = n.parent) {
+      if (n.parent.activeChild !== n) {
+        n.parent.activeChild = n;
+        moved = true;
+      }
+    }
+    if (moved) this.changed();
+  }
+  /** The node a lookup made here starts from: down the active children, or the
+   *  newest where nothing has been activated yet. A yoke with no members yet
+   *  is passed over — there is no canvas behind it to answer. */
+  leaf() {
+    let n = this;
+    for (; ; ) {
+      const next = n.activeChild ?? n.newestMember();
+      if (!next) return n;
+      n = next;
+    }
+  }
+  newestMember() {
+    for (let i = this.children.length - 1; i >= 0; i--) {
+      const c = this.children[i];
+      if (!(c.descends && c.children.length === 0)) return c;
+    }
+    return null;
+  }
+  /** Where a read made through this node starts. */
+  start() {
+    return this.descends ? this.leaf() : this;
+  }
+  /** Whether this node is on the path a read from the root takes. */
+  isActive() {
+    let root = this;
+    while (root.parent) root = root.parent;
+    for (const n of root.leaf().chain()) if (n === this) return true;
+    return false;
+  }
+  /** This node, then each ancestor up to the root. */
+  *chain() {
+    for (let n = this; n; n = n.parent) yield n;
+  }
+};
+function pushOwner(stack, value) {
+  if (value === null) return () => {
+  };
+  stack.push(value);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const i = stack.lastIndexOf(value);
+    if (i !== -1) stack.splice(i, 1);
+  };
+}
+
+// src/interactions/actions/depNode.ts
+var DepNode = class extends ScopeNode {
+  sources = /* @__PURE__ */ new Map();
+  registry = {
+    register: (name, source) => {
+      const key = name;
+      const entry = source;
+      const stack = this.sources.get(key);
+      if (stack) stack.push(entry);
+      else this.sources.set(key, [entry]);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const cur = this.sources.get(key);
+        if (!cur) return;
+        const i = cur.lastIndexOf(entry);
+        if (i === -1) return;
+        cur.splice(i, 1);
+        if (cur.length === 0) this.sources.delete(key);
+        this.changed();
+      };
+    },
+    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()) {
+        for (const [name, stack] of n.sources) {
+          if (!found.has(name)) found.set(name, { name, depth, stacked: stack.length });
+        }
+        depth++;
+      }
+      return [...found.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    },
+    changed: () => this.changed()
+  };
+  constructor(parent, descends) {
+    super(parent, descends);
+    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;
+}
+function createDepRegistry() {
+  return new DepNode(null, true).registry;
+}
+
+// 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;
+}
+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)) } : {
+    ...invoker,
+    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;
+}
+var NO_OVERRIDES = /* @__PURE__ */ new Map();
+function bindingId(b, ownerId, index) {
+  return b.opts?.id ?? (ownerId === null ? `${b.actionId}@${index}` : `${ownerId}#${index}`);
+}
+function resolveBindingOverrides(maps) {
+  if (maps.length === 0) return NO_OVERRIDES;
+  const out = /* @__PURE__ */ new Map();
+  for (const map of maps) {
+    for (const [id, input] of Object.entries(map)) {
+      try {
+        out.set(id, bindingSpec(input));
+      } catch (err) {
+        console.warn(`weasel: binding override "${id}" is not a route: ${err.message}`);
+      }
+    }
+  }
+  return out;
+}
+function overridden(b, id, overrides) {
+  if (!overrides.has(id)) return b;
+  const spec = overrides.get(id);
+  return spec === null ? null : { ...b, spec };
+}
+function overriddenBindings(bindings, ownerId, overrides = NO_OVERRIDES) {
+  const out = [];
+  bindings.forEach((b, i) => {
+    const next = overridden(b, bindingId(b, ownerId, i), overrides);
+    if (next) out.push(next);
+  });
+  return out;
+}
+function overrideActionBindings(action, overrides) {
+  if (overrides.size === 0 || action.defaultBinding === void 0) return action;
+  const declared = actionBindings(action);
+  if (!declared.some((b, i) => overrides.has(bindingId(b, null, i)))) return action;
+  const kept = [];
+  declared.forEach((b, i) => {
+    const id = bindingId(b, null, i);
+    const next = overridden(b, id, overrides);
+    if (next) kept.push({ spec: next.spec, opts: { ...next.opts, id } });
+  });
+  return { ...action, defaultBinding: kept };
+}
+
+// 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 noop = () => {
+};
+var sep = (key) => ({ kind: "separator", key });
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function pathSegment(key) {
+  return key.replace(/[\\.]/g, "\\$&");
+}
+function pathSegments(path) {
+  const out = [];
+  let seg = "";
+  for (let i = 0; i < path.length; i++) {
+    const ch = path[i];
+    if (ch === "\\" && i + 1 < path.length) seg += path[++i];
+    else if (ch === ".") {
+      out.push(seg);
+      seg = "";
+    } else seg += ch;
+  }
+  out.push(seg);
+  return out;
+}
+function setIn(container, segs, value) {
+  const [head, ...rest] = segs;
+  if (head === void 0) return value;
+  if (Array.isArray(container)) {
+    const out = [...container];
+    out[Number(head)] = setIn(container[Number(head)], rest, value);
+    return out;
+  }
+  const base = isRecord(container) ? container : {};
+  const next = setIn(base[head], rest, value);
+  if (next !== void 0) return { ...base, [head]: next };
+  const { [head]: _dropped, ...kept } = base;
+  return kept;
+}
+function below(outer, path, held, writable) {
+  const inside = (p) => p.startsWith(`${path}.`);
+  const rel = (p) => p.slice(path.length + 1);
+  const values = (p) => {
+    if (!inside(p)) return outer.values(p);
+    let cur = held();
+    for (const seg of pathSegments(rel(p))) cur = cur !== null && typeof cur === "object" ? cur[seg] : void 0;
+    return cur;
+  };
+  const { onChange } = outer;
+  if (!onChange || false) return { values };
+  return {
+    values,
+    onChange: (p, v) => inside(p) ? onChange(path, setIn(held(), pathSegments(rel(p)), v)) : onChange(p, v)
+  };
+}
+function submenu(key, leaf, entries) {
+  if (entries.length === 0) return [];
+  return [{
+    kind: "submenu",
+    key,
+    label: leaf.name,
+    entries,
+    ...leaf.icon ? { icon: leaf.icon } : {},
+    ...leaf.access ? { access: leaf.access } : {}
+  }];
+}
+function objectRows(draw, leaf, key, path, off) {
+  const held = () => prefObjectBase(leaf, draw.access.values(path));
+  const access = below(draw.access, path, held);
+  return submenu(key, leaf, draw.fields(leaf.children, path, access, off || leaf.readout === true));
+}
+function removeRows(key, name, labels, off, drop) {
+  return {
+    kind: "submenu",
+    key,
+    label: `Remove ${name}`,
+    ...off ? { disabled: true } : {},
+    entries: labels.map((label, i) => ({ kind: "item", key: `${key}/${i}`, label, disabled: off, run: () => drop(i) }))
+  };
+}
+function listRows(draw, leaf, key, path, off) {
+  const held = () => {
+    const v = draw.access.values(path);
+    return Array.isArray(v) ? v : Array.isArray(leaf.default) ? leaf.default : [];
+  };
+  const frozen = off || leaf.readout === true;
+  const access = below(draw.access, path, held);
+  const name = leaf.item.name || leaf.name;
+  const items = held();
+  const rows = items.flatMap((_, i) => draw.leaf({ ...leaf.item, name: `${name} ${i + 1}` }, `${path}.${i}`, access, frozen, `${path}.${i}`));
+  const { onChange } = draw.access;
+  if (onChange && !leaf.readout) {
+    const n = items.length;
+    rows.push(sep(`${path}/\xB1`), {
+      kind: "item",
+      key: `${path}/+`,
+      label: `Add ${name}`,
+      disabled: frozen || leaf.maxItems !== void 0 && n >= leaf.maxItems,
+      run: () => onChange(path, [...held(), leaf.item.default])
+    });
+    if (n > 0) {
+      rows.push(removeRows(
+        `${path}/-`,
+        name,
+        items.map((_, i) => `${name} ${i + 1}`),
+        frozen || n <= (leaf.minItems ?? 0),
+        (i) => onChange(path, held().filter((_, j) => j !== i))
+      ));
+    }
+  }
+  return submenu(key, leaf, rows);
+}
+function mapRows(draw, leaf, key, path, off) {
+  const held = () => {
+    const v = draw.access.values(path);
+    return isRecord(v) ? v : isRecord(leaf.default) ? leaf.default : {};
+  };
+  const frozen = off || leaf.readout === true;
+  const access = below(draw.access, path, held);
+  const keys = Object.keys(held());
+  const rows = keys.flatMap((k) => {
+    const at = `${path}.${pathSegment(k)}`;
+    return draw.leaf({ ...leaf.item, name: k }, at, access, frozen, at);
+  });
+  const { onChange } = draw.access;
+  if (onChange && !leaf.readout) {
+    const name = leaf.item.name || leaf.name;
+    rows.push(sep(`${path}/\xB1`), {
+      kind: "text",
+      key: `${path}/+`,
+      label: `Add ${name}`,
+      value: void 0,
+      ...frozen ? { disabled: true } : {},
+      set: (k) => {
+        const now = held();
+        if (k !== "" && !Object.hasOwn(now, k)) onChange(path, { ...now, [k]: leaf.item.default });
+      }
+    });
+    if (keys.length > 0) {
+      rows.push(removeRows(`${path}/-`, name, keys, frozen, (i) => {
+        const { [keys[i]]: _dropped, ...kept } = held();
+        onChange(path, kept);
+      }));
+    }
+  }
+  return submenu(key, leaf, rows);
+}
+function unionRows(draw, leaf, key, path, off) {
+  const frozen = off || leaf.readout === true;
+  const current = prefVariantOf(leaf, draw.access.values(path)) ?? prefVariantOf(leaf, leaf.default);
+  const { onChange } = draw.access;
+  const choices = Object.entries(leaf.variants).map(([v2, variant2]) => ({
+    kind: "item",
+    key: `${path}/${v2}`,
+    label: variant2.name,
+    checked: v2 === current?.[0],
+    disabled: frozen || !onChange,
+    run: onChange ? () => onChange(path, prefVariantDefault(leaf, v2)) : noop
+  }));
+  if (!current) return submenu(key, leaf, choices);
+  const [v, variant] = current;
+  const held = () => {
+    const now = draw.access.values(path);
+    return prefVariantOf(leaf, now)?.[0] === v ? now : prefVariantDefault(leaf, v);
+  };
+  const fields = draw.fields(variant.children, path, below(draw.access, path, held), frozen);
+  return submenu(key, leaf, fields.length ? [...choices, sep(`${path}/|`), ...fields] : choices);
+}
+function fieldRows(draw, leaf, key, path, off) {
+  const held = draw.access.values(path);
+  const { onChange } = draw.access;
+  const rows = [];
+  for (const [p, l] of prefLeaves(draw.root)) {
+    if (p === path || !prefHoldsValue(l) || leaf.kinds && !leaf.kinds.includes(l.kind)) continue;
+    rows.push({
+      kind: "item",
+      key: `${path}/${p}`,
+      label: l.name || p,
+      checked: held === p,
+      disabled: off || leaf.readout === true || !onChange,
+      run: onChange ? () => onChange(path, p) : noop
+    });
+  }
+  return submenu(key, leaf, rows);
+}
+function paintRows(draw, leaf, key, path, off) {
+  const held = draw.access.values(path);
+  const access = leaf.access ? { access: leaf.access } : {};
+  const solid = isRecord(held) && (held.kind === void 0 || held.kind === "solid") && typeof held.color === "string";
+  if (held != null && !solid) {
+    const kind = isRecord(held) && typeof held.kind === "string" ? held.kind : "\u2014";
+    return [{ kind: "item", key, label: `${leaf.name}: ${kind}`, ...access, disabled: true, run: noop }];
+  }
+  const { onChange } = draw.access;
+  return [{
+    kind: "color",
+    key,
+    label: leaf.name,
+    ...access,
+    ...off ? { disabled: true } : {},
+    value: solid ? held.color : void 0,
+    ...leaf.alpha ? { alpha: true } : {},
+    ...leaf.readout || !onChange ? {} : {
+      set: (color) => onChange(path, { ...isRecord(held) ? held : {}, color })
+    }
+  }];
+}
+
+// src/menus/resolveMenu.ts
+var SUBMENU_AS = /* @__PURE__ */ new Set(["menu", "page", "tab", "panel"]);
+var noop2 = () => {
+};
+var withAccess = (access) => access ? { access } : {};
+var sep2 = (key) => ({ kind: "separator", key });
+function itemOf(ctx, it, key, label, off, access) {
+  const deps = ctx.src.depsFor(it.action);
+  const point = ctx.at ? { world: ctx.at } : {};
+  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.children, "", ROOT)) : [];
+  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: noop2 }];
+  }
+  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 ? noop2 : () => 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: noop2 }];
+  }
+  const write = (v) => leaf.encoding ? leaf.encoding.write(v, siblingsOf(ctx, path)) : v;
+  return [
+    sep2(`${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))
+    })),
+    sep2(`${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) {
+  const { values, onChange } = ctx.src;
+  if (!values) return [];
+  return [{
+    kind: "color",
+    key,
+    label: leaf.name,
+    ...withAccess(leaf.access),
+    ...off ? { disabled: true } : {},
+    value: textAt(ctx, path),
+    ...leaf.alpha ? { alpha: true } : {},
+    ...leaf.readout || !onChange ? {} : { set: (color) => onChange(path, color) }
+  }];
+}
+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: noop2 }];
+  }
+  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 "object":
+      return objectRows(drawIn(ctx), leaf, key, path, off);
+    case "list":
+      return listRows(drawIn(ctx), leaf, key, path, off);
+    case "map":
+      return mapRows(drawIn(ctx), leaf, key, path, off);
+    case "union":
+      return unionRows(drawIn(ctx), leaf, key, path, off);
+    case "field":
+      return fieldRows(drawIn(ctx), leaf, key, path, off);
+    case "paint":
+      return paintRows(drawIn(ctx), leaf, key, path, off);
+    case "separator":
+      return [sep2(key)];
+    case "label":
+      return [{ kind: "item", key, label: leaf.name, ...withAccess(leaf.access), disabled: true, run: noop2 }];
+    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: {
+      const { values, onChange, customRows } = ctx.src;
+      if (isBuiltinPref(leaf) || !customRows || !values) return [];
+      return [...customRows(leaf, { key, path, disabled: off, values, ...onChange ? { onChange } : {} })];
+    }
+  }
+}
+function through(ctx, access, entry = ctx.entry) {
+  const { values, onChange } = access;
+  const { onChange: _outer, ...src } = ctx.src;
+  return {
+    ...ctx,
+    src: { ...src, values, ...onChange ? { onChange } : {} },
+    entry,
+    read: (p, from) => from === "item" ? entry === void 0 ? void 0 : values(`${entry}.${p}`) : values(p)
+  };
+}
+function drawIn(ctx) {
+  const { values, onChange } = ctx.src;
+  return {
+    root: ctx.src.over ?? ctx.root,
+    access: { values, ...onChange ? { onChange } : {} },
+    leaf: (leaf, key, access, off, entry) => leafRows(through(ctx, access, entry), leaf, key, key, off),
+    fields: (fields, prefix, access, off) => {
+      const scope = { ...PREF_SCOPE, enabled: !off };
+      const inner = through(ctx, access);
+      return tidy(groupRows(inner, fields, prefix, { node: {}, scope, above: scope, ...inner.entry ? { entry: inner.entry } : {} }));
+    }
+  };
+}
+var ROOT = { node: {}, scope: PREF_SCOPE, above: PREF_SCOPE };
+function groupRows(ctx, children, prefix, owner) {
+  const { read } = ctx;
+  const holds = (condition) => read === void 0 || prefConditionHolds(condition, read);
+  const out = [];
+  for (const [k, node] of Object.entries(children)) {
+    const key = prefix ? `${prefix}.${k}` : k;
+    const path = !isPrefLeaf(node) && isPrefSection(node) ? prefix : key;
+    const sits = isPrefLeaf(node) ? prefScopeIn(owner, path, holds) : owner.scope;
+    const scope = prefScopeUnder(sits, node, holds);
+    if (!scope.shown) continue;
+    const disabled = !scope.enabled;
+    const inner = { node, scope, above: sits, ...owner.entry ? { entry: owner.entry } : {} };
+    if (isPrefLeaf(node)) {
+      out.push(...leafRows(ctx, node, path, path, disabled));
+      continue;
+    }
+    const kids = isPrefSection(node) ? node.members : node.children;
+    if (SUBMENU_AS.has(node.as)) {
+      const entries = tidy(groupRows(ctx, kids, path, inner));
+      if (entries.length) {
+        out.push({ kind: "submenu", key, label: node.name, ...node.icon ? { icon: node.icon } : {}, ...withAccess(node.access), entries });
+      }
+    } else {
+      out.push(sep2(`${key}/<`), ...groupRows(ctx, kids, path, inner), sep2(`${key}/>`));
+    }
+  }
+  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.children, "", ROOT));
+}
+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 } : {},
+        ...req.side ? { side: req.side } : {},
+        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 { ActionDisabledReason, DepNode, NO_OVERRIDES, ScopeNode, actionBindings, actionCursor, actionItemTitle, actionItems, actionSettingsParams, actionShortcuts, bindingId, buildDepsFromRequires, createDepRegistry, createMenuHost, depNodeOf, evaluateActive, evaluateEnabled, keySpecShortcut, keysHeld, mergeMenuDefs, overriddenBindings, overrideActionBindings, paramsMatch, pickMenu, platformRoleKeys, pushOwner, readActionSettings, resolveBindingOverrides, resolveMenu, resolveParams, resolveRoles, resolveSchemaMenu, roleKeysOf, roleReader, tuneAction, tunedParams, validateActionDefaultBinding, validateActionId };
+//# sourceMappingURL=chunk-EUCNVGJV.js.map
+//# sourceMappingURL=chunk-EUCNVGJV.js.map