@weasel-js/core 1.10.1 → 1.11.0

package/dist/features/chrome-caps/buildChromeCtx.js

@@ -1,16 +1,18 @@
 //#region src/features/chrome-caps/buildChromeCtx.ts
-function e(e) {
+/** Gather the current canvas state into the context that chrome-visibility
+*  rules are evaluated against. Rebuilt per frame. */
+function buildChromeCtx(args) {
 	return {
-		focused: e.focused,
-		selection: e.selection,
-		multiActive: e.multiActive,
-		modifiers: e.modifiers,
-		action: e.action,
-		hover: e.hover,
-		view: e.view
+		focused: args.focused,
+		selection: args.selection,
+		multiActive: args.multiActive,
+		modifiers: args.modifiers,
+		action: args.action,
+		hover: args.hover,
+		view: args.view
 	};
 }
-//#endregion
-export { e as buildChromeCtx };
 
+//#endregion
+export { buildChromeCtx };
 //# sourceMappingURL=buildChromeCtx.js.map

package/dist/features/chrome-caps/buildChromeCtx.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildChromeCtx.js","names":["buildChromeCtx","args"],"sources":["../../../src/features/chrome-caps/buildChromeCtx.ts"],"sourcesContent":["/**\n * Pure assembler for {@link ChromeCtx}. Sources are passed as plain values\n * rather than the live objects they come from, which keeps `chrome-caps`\n * from depending on React or the dispatcher's concrete type.\n */\n\nimport type { NodeId } from '../../core/scene/types';\nimport type { ModifierState } from '../../interactions/gestures/types';\nimport type { View } from '../../core/viewport/view';\nimport type { ChromeCtx } from './types';\n\n/** The pieces of live canvas state a `ChromeCtx` is assembled from. */\nexport interface BuildChromeCtxArgs {\n  focused: boolean;\n  selection: readonly NodeId[];\n  multiActive: boolean;\n  modifiers: ModifierState;\n  action: { kind: string | null; id: string | null };\n  hover: NodeId | null;\n  view: View;\n}\n\n/** Gather the current canvas state into the context that chrome-visibility\n *  rules are evaluated against. Rebuilt per frame. */\nexport function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx {\n  return {\n    focused: args.focused,\n    selection: args.selection,\n    multiActive: args.multiActive,\n    modifiers: args.modifiers,\n    action: args.action,\n    hover: args.hover,\n    view: args.view,\n  };\n}\n"],"mappings":";AAwBA,SAAgBA,EAAe,GAAqC;CAClE,OAAO;EACL,SAASC,EAAK;EACd,WAAWA,EAAK;EAChB,aAAaA,EAAK;EAClB,WAAWA,EAAK;EAChB,QAAQA,EAAK;EACb,OAAOA,EAAK;EACZ,MAAMA,EAAK;CACb;AACF"}
+{"version":3,"file":"buildChromeCtx.js","names":[],"sources":["../../../src/features/chrome-caps/buildChromeCtx.ts"],"sourcesContent":["/**\n * Pure assembler for {@link ChromeCtx}. Sources are passed as plain values\n * rather than the live objects they come from, which keeps `chrome-caps`\n * from depending on React or the dispatcher's concrete type.\n */\n\nimport type { NodeId } from '../../core/scene/types';\nimport type { ModifierState } from '../../interactions/gestures/types';\nimport type { View } from '../../core/viewport/view';\nimport type { ChromeCtx } from './types';\n\n/** The pieces of live canvas state a `ChromeCtx` is assembled from. */\nexport interface BuildChromeCtxArgs {\n  focused: boolean;\n  selection: readonly NodeId[];\n  multiActive: boolean;\n  modifiers: ModifierState;\n  action: { kind: string | null; id: string | null };\n  hover: NodeId | null;\n  view: View;\n}\n\n/** Gather the current canvas state into the context that chrome-visibility\n *  rules are evaluated against. Rebuilt per frame. */\nexport function buildChromeCtx(args: BuildChromeCtxArgs): ChromeCtx {\n  return {\n    focused: args.focused,\n    selection: args.selection,\n    multiActive: args.multiActive,\n    modifiers: args.modifiers,\n    action: args.action,\n    hover: args.hover,\n    view: args.view,\n  };\n}\n"],"mappings":";;;AAwBA,SAAgB,eAAe,MAAqC;CAClE,OAAO;EACL,SAAS,KAAK;EACd,WAAW,KAAK;EAChB,aAAa,KAAK;EAClB,WAAW,KAAK;EAChB,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,MAAM,KAAK;CACb;AACF"}

package/dist/features/chrome-caps/conditions.js

@@ -1,36 +1,114 @@
-import { ALWAYS as e, NEVER as t, evaluate as n } from "@weasel-js/routing";
+import { ALWAYS, NEVER, evaluate } from "@weasel-js/routing";
+
 //#region src/features/chrome-caps/conditions.ts
-function r(e) {
-	let t = (t) => n(e, t);
-	return t.rule = e, t.and = (t) => r(a(e, i(t))), t.or = (t) => r(o(e, i(t))), t.andNot = (t) => r(a(e, { not: i(t) })), t.orNot = (t) => r(o(e, { not: i(t) })), t;
+/**
+* Promote a Rule tree to a fluent Condition.
+*
+* **Chain semantics: strict left-to-right.** No boolean precedence.
+* `focused.or(hovering).and(selectionIs(1))` evaluates
+* `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use
+* the top-level `or` / `and` / `not` helpers or name intermediates.
+*
+* Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`
+* produces `{ all: [a, b, c] }`.
+*/
+function cond(rule) {
+	const fn = (ctx) => evaluate(rule, ctx);
+	const condition = fn;
+	condition.rule = rule;
+	condition.and = (other) => cond(combineAll(rule, asRule(other)));
+	condition.or = (other) => cond(combineAny(rule, asRule(other)));
+	condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));
+	condition.orNot = (other) => cond(combineAny(rule, { not: asRule(other) }));
+	return condition;
 }
-function i(e) {
-	return typeof e == "function" ? e.rule : e;
+function asRule(value) {
+	return typeof value === "function" ? value.rule : value;
 }
-function a(e, t) {
-	let n = "all" in e ? e.all : [e], r = "all" in t ? t.all : [t];
-	return { all: [...n, ...r] };
+function combineAll(a, b) {
+	const left = "all" in a ? a.all : [a];
+	const right = "all" in b ? b.all : [b];
+	return { all: [...left, ...right] };
 }
-function o(e, t) {
-	let n = "any" in e ? e.any : [e], r = "any" in t ? t.any : [t];
-	return { any: [...n, ...r] };
+function combineAny(a, b) {
+	const left = "any" in a ? a.any : [a];
+	const right = "any" in b ? b.any : [b];
+	return { any: [...left, ...right] };
 }
-function s(e) {
-	return r({ when: e });
+/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */
+function when(fn) {
+	return cond({ when: fn });
 }
-function c(...e) {
-	return r({ all: e.map(i) });
+/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right
+*  semantics ambiguous. */
+function and(...cs) {
+	return cond({ all: cs.map(asRule) });
 }
-function l(...e) {
-	return r({ any: e.map(i) });
+/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with
+*  `.and` to make grouping explicit. */
+function or(...cs) {
+	return cond({ any: cs.map(asRule) });
 }
-function u(e) {
-	return r({ not: i(e) });
+/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`
+*  instead; this is for the lead-with-negation case. */
+function not(c) {
+	return cond({ not: asRule(c) });
 }
-var d = r(e), f = r(t), p = r({ focused: !0 }), m = r({ gesturing: !0 });
-r({ editingAnchors: !0 }), r({ resizable: !0 });
-var h = (e) => r({ actionIs: e }), g = r({ selection: { empty: !0 } }), _ = (e) => r({ selection: { is: e } }), v = (e) => r({ selection: { atLeast: e } }), y = r({ when: (e) => e.multiActive }), b = r({ hovering: !0 }), x = r({ hoveringSelected: !0 }), S = (e) => r({ modifierHeld: e }), C = (e) => r({ zoomAtLeast: e }), w = (e) => r({ mode: e }), T = (e) => r({ mode: { in: e } }), E = (e) => r({ mode: { not: e } }), D = (e) => r({ capability: e }), O = (e) => r({ capability: { in: e } }), k = (e) => r({ capability: [...e] }), A = (e) => r({ capability: { not: e } }), j = r({ coarsePointer: !0 }), M = r({ canHover: !0 });
-//#endregion
-export { h as actionIs, d as always, c as and, M as canHover, k as capabilityAll, O as capabilityIn, D as capabilityIs, A as capabilityNot, j as coarsePointer, r as cond, p as focused, m as gesturing, b as hovering, x as hoveringSelected, T as modeIn, w as modeIs, E as modeNot, S as modifierHeld, y as multiActive, f as never, u as not, l as or, v as selectionAtLeast, g as selectionEmpty, _ as selectionIs, s as when, C as zoomAtLeast };
+/** Always true. The fallback for any chrome id without a registered rule. */
+var always = cond(ALWAYS);
+/** Always false. Useful for "turn this chrome off entirely":
+*  `chromeVisibility={{ 'snap.guides': never }}`. */
+var never = cond(NEVER);
+/** Canvas surface currently focused. */
+var focused = cond({ focused: true });
+/** Any action currently in flight (read: user is gesturing). */
+var gesturing = cond({ gesturing: true });
+/** A path is currently in anchor-edit mode. */
+var editingAnchors = cond({ editingAnchors: true });
+/** Current selection is resizable (every selected node passes the consumer's
+*  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */
+var resizable = cond({ resizable: true });
+/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */
+var actionIs = (kind) => cond({ actionIs: kind });
+/** Nothing selected. */
+var selectionEmpty = cond({ selection: { empty: true } });
+/** Exactly `n` items selected. */
+var selectionIs = (n) => cond({ selection: { is: n } });
+/** At least `n` items selected. `selectionAtLeast(1)` is the common
+*  "something is selected" check. */
+var selectionAtLeast = (n) => cond({ selection: { atLeast: n } });
+/** Multi-mode handle behavior active (single shared union-bounds
+*  handle vs per-item handles). */
+var multiActive = cond({ when: (c) => c.multiActive });
+/** Pointer is hovering some node. */
+var hovering = cond({ hovering: true });
+/** Pointer is hovering a node that is currently selected. */
+var hoveringSelected = cond({ hoveringSelected: true });
+/** Named modifier key currently held. */
+var modifierHeld = (m) => cond({ modifierHeld: m });
+/** View scale (uniform or geometric mean for non-uniform) is at least
+*  `z`. Useful for "hide hairline chrome at low zoom" rules. */
+var zoomAtLeast = (z) => cond({ zoomAtLeast: z });
+/** Active mode equals `m`. */
+var modeIs = (m) => cond({ mode: m });
+/** Active mode is one of `modes`. */
+var modeIn = (modes) => cond({ mode: { in: modes } });
+/** Active mode is NOT `m`. */
+var modeNot = (m) => cond({ mode: { not: m } });
+/** Active mode's `allows` includes capability `cap`. */
+var capabilityIs = (cap) => cond({ capability: cap });
+/** Active mode's `allows` includes ANY of `caps` (OR). */
+var capabilityIn = (caps) => cond({ capability: { in: caps } });
+/** Active mode's `allows` includes ALL of `caps` (AND). */
+var capabilityAll = (caps) => cond({ capability: [...caps] });
+/** Active mode's `allows` does NOT include capability `cap`. */
+var capabilityNot = (cap) => cond({ capability: { not: cap } });
+/** Primary pointer is imprecise (touch, most styluses). Absent device
+*  profile → false. */
+var coarsePointer = cond({ coarsePointer: true });
+/** Primary pointer can hover. Absent device profile → true. */
+var canHover = cond({ canHover: true });
 
+//#endregion
+export { actionIs, always, and, canHover, capabilityAll, capabilityIn, capabilityIs, capabilityNot, coarsePointer, cond, editingAnchors, focused, gesturing, hovering, hoveringSelected, modeIn, modeIs, modeNot, modifierHeld, multiActive, never, not, or, selectionAtLeast, selectionEmpty, selectionIs, when, zoomAtLeast };
 //# sourceMappingURL=conditions.js.map

package/dist/features/chrome-caps/conditions.js.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.js","names":["cond","condition","evaluate","rule","ctx","combineAll","asRule","other","combineAny","value","left","a","right","b","when","fn","and","cs","or","not","c","always","ALWAYS","never","NEVER","focused","gesturing","actionIs","kind","selectionEmpty","selectionIs","n","selectionAtLeast","multiActive","hovering","hoveringSelected","modifierHeld","m","zoomAtLeast","z","modeIs","modeIn","modes","modeNot","capabilityIs","cap","capabilityIn","caps","capabilityAll","capabilityNot","coarsePointer","canHover"],"sources":["../../../src/features/chrome-caps/conditions.ts"],"sourcesContent":["import type { Condition } from './types';\nimport type { Rule } from '@weasel-js/routing';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { evaluate, ALWAYS, NEVER } from '@weasel-js/routing';\nimport type { ModifierState } from '../../interactions/gestures/types';\n\n/**\n * Promote a Rule tree to a fluent Condition.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use\n * the top-level `or` / `and` / `not` helpers or name intermediates.\n *\n * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`\n * produces `{ all: [a, b, c] }`.\n */\nexport function cond(rule: Rule): Condition {\n  const fn = (ctx: RuleCtx) => evaluate(rule, ctx);\n  const condition = fn as Condition;\n  (condition as { rule: Rule }).rule = rule;\n  condition.and    = (other) => cond(combineAll(rule, asRule(other)));\n  condition.or     = (other) => cond(combineAny(rule, asRule(other)));\n  condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));\n  condition.orNot  = (other) => cond(combineAny(rule, { not: asRule(other) }));\n  return condition;\n}\n\nfunction asRule(value: Condition | Rule): Rule {\n  return typeof value === 'function' ? (value as Condition).rule : value;\n}\n\nfunction combineAll(a: Rule, b: Rule): Rule {\n  const left = 'all' in a ? a.all : [a];\n  const right = 'all' in b ? b.all : [b];\n  return { all: [...left, ...right] };\n}\n\nfunction combineAny(a: Rule, b: Rule): Rule {\n  const left = 'any' in a ? a.any : [a];\n  const right = 'any' in b ? b.any : [b];\n  return { any: [...left, ...right] };\n}\n\n/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */\nexport function when(fn: (ctx: RuleCtx) => boolean): Condition {\n  return cond({ when: fn });\n}\n\n// ─── Variadic helpers (for grouped expressions) ─────────────────────\n\n/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right\n *  semantics ambiguous. */\nexport function and(...cs: (Condition | Rule)[]): Condition {\n  return cond({ all: cs.map(asRule) });\n}\n\n/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with\n *  `.and` to make grouping explicit. */\nexport function or(...cs: (Condition | Rule)[]): Condition {\n  return cond({ any: cs.map(asRule) });\n}\n\n/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`\n *  instead; this is for the lead-with-negation case. */\nexport function not(c: Condition | Rule): Condition {\n  return cond({ not: asRule(c) });\n}\n\n// ─── Constant atoms ─────────────────────────────────────────────────\n\n/** Always true. The fallback for any chrome id without a registered rule. */\nexport const always: Condition = cond(ALWAYS);\n\n/** Always false. Useful for \"turn this chrome off entirely\":\n *  `chromeVisibility={{ 'snap.guides': never }}`. */\nexport const never: Condition = cond(NEVER);\n\n// ─── Focus / action atoms ───────────────────────────────────────────\n\n/** Canvas surface currently focused. */\nexport const focused: Condition = cond({ focused: true });\n\n/** Any action currently in flight (read: user is gesturing). */\nexport const gesturing: Condition = cond({ gesturing: true });\n\n/** A path is currently in anchor-edit mode. */\nexport const editingAnchors: Condition = cond({ editingAnchors: true });\n\n/** Current selection is resizable (every selected node passes the consumer's\n *  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */\nexport const resizable: Condition = cond({ resizable: true });\n\n/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */\nexport const actionIs = (kind: string): Condition => cond({ actionIs: kind });\n\n// ─── Selection atoms ────────────────────────────────────────────────\n\n/** Nothing selected. */\nexport const selectionEmpty: Condition = cond({ selection: { empty: true } });\n\n/** Exactly `n` items selected. */\nexport const selectionIs = (n: number): Condition => cond({ selection: { is: n } });\n\n/** At least `n` items selected. `selectionAtLeast(1)` is the common\n *  \"something is selected\" check. */\nexport const selectionAtLeast = (n: number): Condition => cond({ selection: { atLeast: n } });\n\n/** Multi-mode handle behavior active (single shared union-bounds\n *  handle vs per-item handles). */\nexport const multiActive: Condition = cond({ when: (c) => c.multiActive });\n\n// ─── Hover atoms ────────────────────────────────────────────────────\n\n/** Pointer is hovering some node. */\nexport const hovering: Condition = cond({ hovering: true });\n\n/** Pointer is hovering a node that is currently selected. */\nexport const hoveringSelected: Condition = cond({ hoveringSelected: true });\n\n// ─── Modifier atoms ─────────────────────────────────────────────────\n\n/** Named modifier key currently held. */\nexport const modifierHeld = (m: keyof ModifierState): Condition => cond({ modifierHeld: m });\n\n// ─── View atoms ─────────────────────────────────────────────────────\n\n/** View scale (uniform or geometric mean for non-uniform) is at least\n *  `z`. Useful for \"hide hairline chrome at low zoom\" rules. */\nexport const zoomAtLeast = (z: number): Condition => cond({ zoomAtLeast: z });\n\n// ─── Mode + capability atoms ───────────────────────────────────────\n\n/** Active mode equals `m`. */\nexport const modeIs = (m: string): Condition => cond({ mode: m });\n\n/** Active mode is one of `modes`. */\nexport const modeIn = (modes: readonly string[]): Condition => cond({ mode: { in: modes } });\n\n/** Active mode is NOT `m`. */\nexport const modeNot = (m: string): Condition => cond({ mode: { not: m } });\n\n/** Active mode's `allows` includes capability `cap`. */\nexport const capabilityIs = (cap: string): Condition => cond({ capability: cap });\n\n/** Active mode's `allows` includes ANY of `caps` (OR). */\nexport const capabilityIn = (caps: readonly string[]): Condition => cond({ capability: { in: caps } });\n\n/** Active mode's `allows` includes ALL of `caps` (AND). */\nexport const capabilityAll = (caps: readonly string[]): Condition => cond({ capability: [...caps] });\n\n/** Active mode's `allows` does NOT include capability `cap`. */\nexport const capabilityNot = (cap: string): Condition => cond({ capability: { not: cap } });\n\n// ─── Device atoms ───────────────────────────────────────────────────\n\n/** Primary pointer is imprecise (touch, most styluses). Absent device\n *  profile → false. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":"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"}
+{"version":3,"file":"conditions.js","names":[],"sources":["../../../src/features/chrome-caps/conditions.ts"],"sourcesContent":["import type { Condition } from './types';\nimport type { Rule } from '@weasel-js/routing';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { evaluate, ALWAYS, NEVER } from '@weasel-js/routing';\nimport type { ModifierState } from '../../interactions/gestures/types';\n\n/**\n * Promote a Rule tree to a fluent Condition.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use\n * the top-level `or` / `and` / `not` helpers or name intermediates.\n *\n * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`\n * produces `{ all: [a, b, c] }`.\n */\nexport function cond(rule: Rule): Condition {\n  const fn = (ctx: RuleCtx) => evaluate(rule, ctx);\n  const condition = fn as Condition;\n  (condition as { rule: Rule }).rule = rule;\n  condition.and    = (other) => cond(combineAll(rule, asRule(other)));\n  condition.or     = (other) => cond(combineAny(rule, asRule(other)));\n  condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));\n  condition.orNot  = (other) => cond(combineAny(rule, { not: asRule(other) }));\n  return condition;\n}\n\nfunction asRule(value: Condition | Rule): Rule {\n  return typeof value === 'function' ? (value as Condition).rule : value;\n}\n\nfunction combineAll(a: Rule, b: Rule): Rule {\n  const left = 'all' in a ? a.all : [a];\n  const right = 'all' in b ? b.all : [b];\n  return { all: [...left, ...right] };\n}\n\nfunction combineAny(a: Rule, b: Rule): Rule {\n  const left = 'any' in a ? a.any : [a];\n  const right = 'any' in b ? b.any : [b];\n  return { any: [...left, ...right] };\n}\n\n/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */\nexport function when(fn: (ctx: RuleCtx) => boolean): Condition {\n  return cond({ when: fn });\n}\n\n// ─── Variadic helpers (for grouped expressions) ─────────────────────\n\n/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right\n *  semantics ambiguous. */\nexport function and(...cs: (Condition | Rule)[]): Condition {\n  return cond({ all: cs.map(asRule) });\n}\n\n/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with\n *  `.and` to make grouping explicit. */\nexport function or(...cs: (Condition | Rule)[]): Condition {\n  return cond({ any: cs.map(asRule) });\n}\n\n/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`\n *  instead; this is for the lead-with-negation case. */\nexport function not(c: Condition | Rule): Condition {\n  return cond({ not: asRule(c) });\n}\n\n// ─── Constant atoms ─────────────────────────────────────────────────\n\n/** Always true. The fallback for any chrome id without a registered rule. */\nexport const always: Condition = cond(ALWAYS);\n\n/** Always false. Useful for \"turn this chrome off entirely\":\n *  `chromeVisibility={{ 'snap.guides': never }}`. */\nexport const never: Condition = cond(NEVER);\n\n// ─── Focus / action atoms ───────────────────────────────────────────\n\n/** Canvas surface currently focused. */\nexport const focused: Condition = cond({ focused: true });\n\n/** Any action currently in flight (read: user is gesturing). */\nexport const gesturing: Condition = cond({ gesturing: true });\n\n/** A path is currently in anchor-edit mode. */\nexport const editingAnchors: Condition = cond({ editingAnchors: true });\n\n/** Current selection is resizable (every selected node passes the consumer's\n *  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */\nexport const resizable: Condition = cond({ resizable: true });\n\n/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */\nexport const actionIs = (kind: string): Condition => cond({ actionIs: kind });\n\n// ─── Selection atoms ────────────────────────────────────────────────\n\n/** Nothing selected. */\nexport const selectionEmpty: Condition = cond({ selection: { empty: true } });\n\n/** Exactly `n` items selected. */\nexport const selectionIs = (n: number): Condition => cond({ selection: { is: n } });\n\n/** At least `n` items selected. `selectionAtLeast(1)` is the common\n *  \"something is selected\" check. */\nexport const selectionAtLeast = (n: number): Condition => cond({ selection: { atLeast: n } });\n\n/** Multi-mode handle behavior active (single shared union-bounds\n *  handle vs per-item handles). */\nexport const multiActive: Condition = cond({ when: (c) => c.multiActive });\n\n// ─── Hover atoms ────────────────────────────────────────────────────\n\n/** Pointer is hovering some node. */\nexport const hovering: Condition = cond({ hovering: true });\n\n/** Pointer is hovering a node that is currently selected. */\nexport const hoveringSelected: Condition = cond({ hoveringSelected: true });\n\n// ─── Modifier atoms ─────────────────────────────────────────────────\n\n/** Named modifier key currently held. */\nexport const modifierHeld = (m: keyof ModifierState): Condition => cond({ modifierHeld: m });\n\n// ─── View atoms ─────────────────────────────────────────────────────\n\n/** View scale (uniform or geometric mean for non-uniform) is at least\n *  `z`. Useful for \"hide hairline chrome at low zoom\" rules. */\nexport const zoomAtLeast = (z: number): Condition => cond({ zoomAtLeast: z });\n\n// ─── Mode + capability atoms ───────────────────────────────────────\n\n/** Active mode equals `m`. */\nexport const modeIs = (m: string): Condition => cond({ mode: m });\n\n/** Active mode is one of `modes`. */\nexport const modeIn = (modes: readonly string[]): Condition => cond({ mode: { in: modes } });\n\n/** Active mode is NOT `m`. */\nexport const modeNot = (m: string): Condition => cond({ mode: { not: m } });\n\n/** Active mode's `allows` includes capability `cap`. */\nexport const capabilityIs = (cap: string): Condition => cond({ capability: cap });\n\n/** Active mode's `allows` includes ANY of `caps` (OR). */\nexport const capabilityIn = (caps: readonly string[]): Condition => cond({ capability: { in: caps } });\n\n/** Active mode's `allows` includes ALL of `caps` (AND). */\nexport const capabilityAll = (caps: readonly string[]): Condition => cond({ capability: [...caps] });\n\n/** Active mode's `allows` does NOT include capability `cap`. */\nexport const capabilityNot = (cap: string): Condition => cond({ capability: { not: cap } });\n\n// ─── Device atoms ───────────────────────────────────────────────────\n\n/** Primary pointer is imprecise (touch, most styluses). Absent device\n *  profile → false. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,KAAK,MAAuB;CAC1C,MAAM,MAAM,QAAiB,SAAS,MAAM,GAAG;CAC/C,MAAM,YAAY;CAClB,UAA8B,OAAO;CACrC,UAAU,OAAU,UAAU,KAAK,WAAW,MAAM,OAAO,KAAK,CAAC,CAAC;CAClE,UAAU,MAAU,UAAU,KAAK,WAAW,MAAM,OAAO,KAAK,CAAC,CAAC;CAClE,UAAU,UAAU,UAAU,KAAK,WAAW,MAAM,EAAE,KAAK,OAAO,KAAK,EAAE,CAAC,CAAC;CAC3E,UAAU,SAAU,UAAU,KAAK,WAAW,MAAM,EAAE,KAAK,OAAO,KAAK,EAAE,CAAC,CAAC;CAC3E,OAAO;AACT;AAEA,SAAS,OAAO,OAA+B;CAC7C,OAAO,OAAO,UAAU,aAAc,MAAoB,OAAO;AACnE;AAEA,SAAS,WAAW,GAAS,GAAe;CAC1C,MAAM,OAAO,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACpC,MAAM,QAAQ,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,GAAG,KAAK,EAAE;AACpC;AAEA,SAAS,WAAW,GAAS,GAAe;CAC1C,MAAM,OAAO,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACpC,MAAM,QAAQ,SAAS,IAAI,EAAE,MAAM,CAAC,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,GAAG,KAAK,EAAE;AACpC;;AAGA,SAAgB,KAAK,IAA0C;CAC7D,OAAO,KAAK,EAAE,MAAM,GAAG,CAAC;AAC1B;;;AAMA,SAAgB,IAAI,GAAG,IAAqC;CAC1D,OAAO,KAAK,EAAE,KAAK,GAAG,IAAI,MAAM,EAAE,CAAC;AACrC;;;AAIA,SAAgB,GAAG,GAAG,IAAqC;CACzD,OAAO,KAAK,EAAE,KAAK,GAAG,IAAI,MAAM,EAAE,CAAC;AACrC;;;AAIA,SAAgB,IAAI,GAAgC;CAClD,OAAO,KAAK,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC;AAChC;;AAKA,IAAa,SAAoB,KAAK,MAAM;;;AAI5C,IAAa,QAAmB,KAAK,KAAK;;AAK1C,IAAa,UAAqB,KAAK,EAAE,SAAS,KAAK,CAAC;;AAGxD,IAAa,YAAuB,KAAK,EAAE,WAAW,KAAK,CAAC;;AAG5D,IAAa,iBAA4B,KAAK,EAAE,gBAAgB,KAAK,CAAC;;;AAItE,IAAa,YAAuB,KAAK,EAAE,WAAW,KAAK,CAAC;;AAG5D,IAAa,YAAY,SAA4B,KAAK,EAAE,UAAU,KAAK,CAAC;;AAK5E,IAAa,iBAA4B,KAAK,EAAE,WAAW,EAAE,OAAO,KAAK,EAAE,CAAC;;AAG5E,IAAa,eAAe,MAAyB,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC;;;AAIlF,IAAa,oBAAoB,MAAyB,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,CAAC;;;AAI5F,IAAa,cAAyB,KAAK,EAAE,OAAO,MAAM,EAAE,YAAY,CAAC;;AAKzE,IAAa,WAAsB,KAAK,EAAE,UAAU,KAAK,CAAC;;AAG1D,IAAa,mBAA8B,KAAK,EAAE,kBAAkB,KAAK,CAAC;;AAK1E,IAAa,gBAAgB,MAAsC,KAAK,EAAE,cAAc,EAAE,CAAC;;;AAM3F,IAAa,eAAe,MAAyB,KAAK,EAAE,aAAa,EAAE,CAAC;;AAK5E,IAAa,UAAU,MAAyB,KAAK,EAAE,MAAM,EAAE,CAAC;;AAGhE,IAAa,UAAU,UAAwC,KAAK,EAAE,MAAM,EAAE,IAAI,MAAM,EAAE,CAAC;;AAG3F,IAAa,WAAW,MAAyB,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;;AAG1E,IAAa,gBAAgB,QAA2B,KAAK,EAAE,YAAY,IAAI,CAAC;;AAGhF,IAAa,gBAAgB,SAAuC,KAAK,EAAE,YAAY,EAAE,IAAI,KAAK,EAAE,CAAC;;AAGrG,IAAa,iBAAiB,SAAuC,KAAK,EAAE,YAAY,CAAC,GAAG,IAAI,EAAE,CAAC;;AAGnG,IAAa,iBAAiB,QAA2B,KAAK,EAAE,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC;;;AAM1F,IAAa,gBAA2B,KAAK,EAAE,eAAe,KAAK,CAAC;;AAGpE,IAAa,WAAsB,KAAK,EAAE,UAAU,KAAK,CAAC"}

package/dist/features/chrome-caps/defaults.js

@@ -1,26 +1,34 @@
 //#region src/features/chrome-caps/defaults.ts
-var e = {
+/**
+* Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map
+* at resolve time; consumer entries take precedence per id.
+*
+* Gating is written in terms of **capabilities, not mode ids**. A
+* capability rule keeps holding when a new mode is added that permits the
+* same thing; a mode rule has to be found and edited every time.
+*/
+var defaultVisibilityRules = {
 	"selection.outline": { all: [{ selection: { atLeast: 1 } }, { capability: { not: "edits-anchors" } }] },
 	"selection.resize-handles": { all: [
 		{ selection: { atLeast: 1 } },
-		{ not: { gesturing: !0 } },
+		{ not: { gesturing: true } },
 		{ capability: "transforms-selection" },
-		{ resizable: !0 }
+		{ resizable: true }
 	] },
 	"selection.rotation-handle": { all: [
 		{ selection: { atLeast: 1 } },
-		{ focused: !0 },
-		{ not: { gesturing: !0 } },
+		{ focused: true },
+		{ not: { gesturing: true } },
 		{ capability: "transforms-selection" }
 	] },
 	"action.marquee": { actionIs: "marquee" },
 	"action.lasso": { actionIs: "lasso" },
 	"action.move-ghosts": { actionIs: "move" },
-	"path-edit.anchors": { editingAnchors: !0 },
-	"path-edit.overlay": { editingAnchors: !0 },
-	"snap.guides": { gesturing: !0 }
+	"path-edit.anchors": { editingAnchors: true },
+	"path-edit.overlay": { editingAnchors: true },
+	"snap.guides": { gesturing: true }
 };
-//#endregion
-export { e as defaultVisibilityRules };
 
+//#endregion
+export { defaultVisibilityRules };
 //# sourceMappingURL=defaults.js.map

package/dist/features/chrome-caps/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":["defaultVisibilityRules"],"sources":["../../../src/features/chrome-caps/defaults.ts"],"sourcesContent":["import type { VisibilityRules } from './types';\nimport type { Rule } from '@weasel-js/routing';\n\n/**\n * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map\n * at resolve time; consumer entries take precedence per id.\n *\n * Gating is written in terms of **capabilities, not mode ids**. A\n * capability rule keeps holding when a new mode is added that permits the\n * same thing; a mode rule has to be found and edited every time.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Off whenever an anchor-editing overlay has taken over the visuals.\n  'selection.outline': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { capability: { not: 'edits-anchors' } },\n    ],\n  } as Rule,\n\n  // Handles hide during an action so the moving / resizing object isn't\n  // visually crowded; they reappear on commit.\n  'selection.resize-handles': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n      { resizable: true },\n    ],\n  } as Rule,\n\n  'selection.rotation-handle': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { focused: true },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n    ],\n  } as Rule,\n\n  // Transient action chrome — only shown during the matching action.\n  'action.marquee':     { actionIs: 'marquee' } as Rule,\n  'action.lasso':       { actionIs: 'lasso' } as Rule,\n  'action.move-ghosts': { actionIs: 'move' } as Rule,\n\n  // Path-edit chrome — gated on there actually being an edited path, not on\n  // `{ mode: 'path-edit' }`: consumers with no mode registry report mode\n  // `'normal'`, and one defining its own anchor-editing mode uses another id.\n  // A state selector rather than a `capability:` one on purpose: the\n  // capability says the user *may* edit anchors, which is not the same as\n  // a path *being* edited.\n  'path-edit.anchors': { editingAnchors: true } as Rule,\n  'path-edit.overlay': { editingAnchors: true } as Rule,\n\n  // Snap system — guides during any action; targets consumer-driven for now.\n  'snap.guides': { gesturing: true } as Rule,\n  // 'snap.targets' — no default; consumer-driven for now.\n\n  // 'grid' / 'debug.*' — no default; visibility is driven by dedicated\n  // boolean props on <SceneCanvas>.\n};\n"],"mappings":";AAWA,IAAaA,IAA0C;CAErD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAIA,4BAA4B,EAC1B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;EACrC,EAAE,WAAW,GAAK;CACpB,EACF;CAEA,6BAA6B,EAC3B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,SAAS,GAAK;EAChB,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;CACvC,EACF;CAGA,kBAAsB,EAAE,UAAU,UAAU;CAC5C,gBAAsB,EAAE,UAAU,QAAQ;CAC1C,sBAAsB,EAAE,UAAU,OAAO;CAQzC,qBAAqB,EAAE,gBAAgB,GAAK;CAC5C,qBAAqB,EAAE,gBAAgB,GAAK;CAG5C,eAAe,EAAE,WAAW,GAAK;AAKnC"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/features/chrome-caps/defaults.ts"],"sourcesContent":["import type { VisibilityRules } from './types';\nimport type { Rule } from '@weasel-js/routing';\n\n/**\n * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map\n * at resolve time; consumer entries take precedence per id.\n *\n * Gating is written in terms of **capabilities, not mode ids**. A\n * capability rule keeps holding when a new mode is added that permits the\n * same thing; a mode rule has to be found and edited every time.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Off whenever an anchor-editing overlay has taken over the visuals.\n  'selection.outline': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { capability: { not: 'edits-anchors' } },\n    ],\n  } as Rule,\n\n  // Handles hide during an action so the moving / resizing object isn't\n  // visually crowded; they reappear on commit.\n  'selection.resize-handles': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n      { resizable: true },\n    ],\n  } as Rule,\n\n  'selection.rotation-handle': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { focused: true },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n    ],\n  } as Rule,\n\n  // Transient action chrome — only shown during the matching action.\n  'action.marquee':     { actionIs: 'marquee' } as Rule,\n  'action.lasso':       { actionIs: 'lasso' } as Rule,\n  'action.move-ghosts': { actionIs: 'move' } as Rule,\n\n  // Path-edit chrome — gated on there actually being an edited path, not on\n  // `{ mode: 'path-edit' }`: consumers with no mode registry report mode\n  // `'normal'`, and one defining its own anchor-editing mode uses another id.\n  // A state selector rather than a `capability:` one on purpose: the\n  // capability says the user *may* edit anchors, which is not the same as\n  // a path *being* edited.\n  'path-edit.anchors': { editingAnchors: true } as Rule,\n  'path-edit.overlay': { editingAnchors: true } as Rule,\n\n  // Snap system — guides during any action; targets consumer-driven for now.\n  'snap.guides': { gesturing: true } as Rule,\n  // 'snap.targets' — no default; consumer-driven for now.\n\n  // 'grid' / 'debug.*' — no default; visibility is driven by dedicated\n  // boolean props on <SceneCanvas>.\n};\n"],"mappings":";;;;;;;;;AAWA,IAAa,yBAA0C;CAErD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAIA,4BAA4B,EAC1B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,KAAK,EAAE,WAAW,KAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;EACrC,EAAE,WAAW,KAAK;CACpB,EACF;CAEA,6BAA6B,EAC3B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,SAAS,KAAK;EAChB,EAAE,KAAK,EAAE,WAAW,KAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;CACvC,EACF;CAGA,kBAAsB,EAAE,UAAU,UAAU;CAC5C,gBAAsB,EAAE,UAAU,QAAQ;CAC1C,sBAAsB,EAAE,UAAU,OAAO;CAQzC,qBAAqB,EAAE,gBAAgB,KAAK;CAC5C,qBAAqB,EAAE,gBAAgB,KAAK;CAG5C,eAAe,EAAE,WAAW,KAAK;AAKnC"}

package/dist/features/chrome-caps/index.js

@@ -1,7 +1,8 @@
-import { actionIs as e, always as t, and as n, canHover as r, capabilityAll as i, capabilityIn as a, capabilityIs as o, capabilityNot as s, coarsePointer as c, cond as l, focused as u, gesturing as d, hovering as f, hoveringSelected as p, modeIn as m, modeIs as h, modeNot as g, modifierHeld as _, multiActive as v, never as y, not as b, or as x, selectionAtLeast as S, selectionEmpty as C, selectionIs as w, when as T, zoomAtLeast as E } from "./conditions.js";
-import { defaultVisibilityRules as D } from "./defaults.js";
-import { resolveVisibility as O } from "./resolve.js";
-import { buildChromeCtx as k } from "./buildChromeCtx.js";
-import { useHoverTracking as A } from "./useHoverTracking.js";
-import { ALWAYS as j, DEFAULT_ALLOWED_CAPABILITIES as M, NEVER as N, buildRuleCtx as P, describeRule as F, evaluate as I } from "@weasel-js/routing";
-export { j as ALWAYS, M as DEFAULT_ALLOWED_CAPABILITIES, N as NEVER, e as actionIs, t as always, n as and, k as buildChromeCtx, P as buildRuleCtx, r as canHover, i as capabilityAll, a as capabilityIn, o as capabilityIs, s as capabilityNot, c as coarsePointer, l as cond, D as defaultVisibilityRules, F as describeRule, I as evaluate, u as focused, d as gesturing, f as hovering, p as hoveringSelected, m as modeIn, h as modeIs, g as modeNot, _ as modifierHeld, v as multiActive, y as never, b as not, x as or, O as resolveVisibility, S as selectionAtLeast, C as selectionEmpty, w as selectionIs, A as useHoverTracking, T as when, E as zoomAtLeast };
+import { actionIs, always, and, canHover, capabilityAll, capabilityIn, capabilityIs, capabilityNot, coarsePointer, cond, editingAnchors, focused, gesturing, hovering, hoveringSelected, modeIn, modeIs, modeNot, modifierHeld, multiActive, never, not, or, selectionAtLeast, selectionEmpty, selectionIs, when, zoomAtLeast } from "./conditions.js";
+import { defaultVisibilityRules } from "./defaults.js";
+import { resolveVisibility } from "./resolve.js";
+import { buildChromeCtx } from "./buildChromeCtx.js";
+import { useHoverTracking } from "./useHoverTracking.js";
+import { ALWAYS as ALWAYS$1, DEFAULT_ALLOWED_CAPABILITIES as DEFAULT_ALLOWED_CAPABILITIES$1, NEVER as NEVER$1, buildRuleCtx as buildRuleCtx$1, describeRule, evaluate as evaluate$1 } from "@weasel-js/routing";
+
+export { ALWAYS$1 as ALWAYS, DEFAULT_ALLOWED_CAPABILITIES$1 as DEFAULT_ALLOWED_CAPABILITIES, NEVER$1 as NEVER, actionIs, always, and, buildChromeCtx, buildRuleCtx$1 as buildRuleCtx, canHover, capabilityAll, capabilityIn, capabilityIs, capabilityNot, coarsePointer, cond, defaultVisibilityRules, describeRule, editingAnchors, evaluate$1 as evaluate, focused, gesturing, hovering, hoveringSelected, modeIn, modeIs, modeNot, modifierHeld, multiActive, never, not, or, resolveVisibility, selectionAtLeast, selectionEmpty, selectionIs, useHoverTracking, when, zoomAtLeast };

package/dist/features/chrome-caps/resolve.js

@@ -1,23 +1,35 @@
-import { viewZoom as e } from "../../core/viewport/view.js";
-import { defaultVisibilityRules as t } from "./defaults.js";
-import { DEFAULT_ALLOWED_CAPABILITIES as n, evaluate as r } from "@weasel-js/routing";
+import { viewZoom } from "../../core/viewport/view.js";
+import { defaultVisibilityRules } from "./defaults.js";
+import { DEFAULT_ALLOWED_CAPABILITIES, evaluate } from "@weasel-js/routing";
+
 //#region src/features/chrome-caps/resolve.ts
-function i(i, a) {
-	let o = i ? {
-		...t,
-		...i
-	} : t, s = "mode" in a ? a : {
-		...a,
-		zoom: e(a.view),
+/**
+* Build the per-frame visibility check: consumer rules merged on top of
+* the kit defaults, evaluated against `ctx`.
+*
+* `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`
+* and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never
+* opted into modality behaves exactly like one sitting in normal mode.
+*/
+function resolveVisibility(consumer, ctx) {
+	const merged = consumer ? {
+		...defaultVisibilityRules,
+		...consumer
+	} : defaultVisibilityRules;
+	const ruleCtx = "mode" in ctx ? ctx : {
+		...ctx,
+		zoom: viewZoom(ctx.view),
 		mode: "normal",
-		allowedCapabilities: n
+		allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES
 	};
-	return (e) => {
-		let t = o[e];
-		return t === void 0 ? !0 : typeof t == "function" ? t(s) : r(t, s);
+	return (id) => {
+		const entry = merged[id];
+		if (entry === void 0) return true;
+		if (typeof entry === "function") return entry(ruleCtx);
+		return evaluate(entry, ruleCtx);
 	};
 }
-//#endregion
-export { i as resolveVisibility };
 
+//#endregion
+export { resolveVisibility };
 //# sourceMappingURL=resolve.js.map

package/dist/features/chrome-caps/resolve.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.js","names":["resolveVisibility","merged","consumer","defaultVisibilityRules","ruleCtx","ctx","viewZoom","DEFAULT_ALLOWED_CAPABILITIES","entry","id","evaluate"],"sources":["../../../src/features/chrome-caps/resolve.ts"],"sourcesContent":["import type { ChromeCtx, ChromeId, VisibilityRules } from './types';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { DEFAULT_ALLOWED_CAPABILITIES } from '@weasel-js/routing';\nimport { evaluate } from '@weasel-js/routing';\nimport { defaultVisibilityRules } from './defaults';\nimport { viewZoom } from 'core/viewport/view';\n\n/**\n * Build the per-frame visibility check: consumer rules merged on top of\n * the kit defaults, evaluated against `ctx`.\n *\n * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`\n * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never\n * opted into modality behaves exactly like one sitting in normal mode.\n */\nexport function resolveVisibility(\n  consumer: VisibilityRules | undefined,\n  ctx: ChromeCtx | RuleCtx,\n): (id: ChromeId) => boolean {\n  const merged: VisibilityRules = consumer\n    ? { ...defaultVisibilityRules, ...consumer }\n    : defaultVisibilityRules;\n  const ruleCtx: RuleCtx = 'mode' in ctx\n    ? ctx\n    : {\n      ...ctx,\n      zoom: viewZoom(ctx.view),\n      mode: 'normal',\n      allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES,\n    };\n  return (id) => {\n    const entry = merged[id];\n    if (entry === undefined) return true;\n    if (typeof entry === 'function') return entry(ruleCtx);\n    return evaluate(entry, ruleCtx);\n  };\n}\n"],"mappings":";;;;AAeA,SAAgBA,EACd,GACA,GAC2B;CAC3B,IAAMC,IAA0BC,IAC5B;EAAE,GAAGC;EAAwB,GAAGD;CAAS,IACzCC,GACEC,IAAmB,UAAUC,IAC/BA,IACA;EACA,GAAGA;EACH,MAAMC,EAASD,EAAI,IAAI;EACvB,MAAM;EACN,qBAAqBE;CACvB;CACF,QAAQ,MAAO;EACb,IAAMC,IAAQP,EAAOQ;EAGrB,OAFID,MAAU,KAAA,IAAkB,KAC5B,OAAOA,KAAU,aAAmBA,EAAMJ,CAAO,IAC9CM,EAASF,GAAOJ,CAAO;CAChC;AACF"}
+{"version":3,"file":"resolve.js","names":[],"sources":["../../../src/features/chrome-caps/resolve.ts"],"sourcesContent":["import type { ChromeCtx, ChromeId, VisibilityRules } from './types';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { DEFAULT_ALLOWED_CAPABILITIES } from '@weasel-js/routing';\nimport { evaluate } from '@weasel-js/routing';\nimport { defaultVisibilityRules } from './defaults';\nimport { viewZoom } from 'core/viewport/view';\n\n/**\n * Build the per-frame visibility check: consumer rules merged on top of\n * the kit defaults, evaluated against `ctx`.\n *\n * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`\n * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never\n * opted into modality behaves exactly like one sitting in normal mode.\n */\nexport function resolveVisibility(\n  consumer: VisibilityRules | undefined,\n  ctx: ChromeCtx | RuleCtx,\n): (id: ChromeId) => boolean {\n  const merged: VisibilityRules = consumer\n    ? { ...defaultVisibilityRules, ...consumer }\n    : defaultVisibilityRules;\n  const ruleCtx: RuleCtx = 'mode' in ctx\n    ? ctx\n    : {\n      ...ctx,\n      zoom: viewZoom(ctx.view),\n      mode: 'normal',\n      allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES,\n    };\n  return (id) => {\n    const entry = merged[id];\n    if (entry === undefined) return true;\n    if (typeof entry === 'function') return entry(ruleCtx);\n    return evaluate(entry, ruleCtx);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,SAAgB,kBACd,UACA,KAC2B;CAC3B,MAAM,SAA0B,WAC5B;EAAE,GAAG;EAAwB,GAAG;CAAS,IACzC;CACJ,MAAM,UAAmB,UAAU,MAC/B,MACA;EACA,GAAG;EACH,MAAM,SAAS,IAAI,IAAI;EACvB,MAAM;EACN,qBAAqB;CACvB;CACF,QAAQ,OAAO;EACb,MAAM,QAAQ,OAAO;EACrB,IAAI,UAAU,QAAW,OAAO;EAChC,IAAI,OAAO,UAAU,YAAY,OAAO,MAAM,OAAO;EACrD,OAAO,SAAS,OAAO,OAAO;CAChC;AACF"}

package/dist/features/chrome-caps/useChromeCaps.js

@@ -1,54 +1,62 @@
-import { viewZoom as e } from "../../core/viewport/view.js";
-import { resolveVisibility as t } from "./resolve.js";
-import { useMemo as n } from "react";
-import { useLatest as r } from "@weasel-js/react";
-import { DEFAULT_ALLOWED_CAPABILITIES as i, buildRuleCtx as a } from "@weasel-js/routing";
+import { viewZoom } from "../../core/viewport/view.js";
+import { resolveVisibility } from "./resolve.js";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+import { DEFAULT_ALLOWED_CAPABILITIES, buildRuleCtx } from "@weasel-js/routing";
+
 //#region src/features/chrome-caps/useChromeCaps.ts
-var o = {
-	alt: !1,
-	ctrl: !1,
-	meta: !1,
-	shift: !1
+/**
+* The rule context a surface's chrome-visibility rules and action eligibility
+* are evaluated against, and the hook that keeps one for `<SceneCanvas>`.
+*/
+var NO_MODIFIERS = {
+	alt: false,
+	ctrl: false,
+	meta: false,
+	shift: false
 };
-function s(t, n) {
-	let { resizable: r } = t;
-	return a({
-		focused: t.focused,
-		selection: n.selection,
-		multiActive: n.selection.length > 1,
-		modifiers: t.modifiers ?? o,
-		action: n.action,
-		hover: t.hover,
-		zoom: e(n.view),
-		mode: t.mode?.id ?? "normal",
-		allowedCapabilities: t.mode?.allowedCapabilities ?? i,
-		selectionResizable: r ? n.selection.every((e) => r(e)) : void 0,
-		editingAnchors: t.editingAnchors,
-		device: t.device
+/** One view's rule context on a surface. */
+function surfaceRuleCtx(surface, view) {
+	const { resizable } = surface;
+	return buildRuleCtx({
+		focused: surface.focused,
+		selection: view.selection,
+		multiActive: view.selection.length > 1,
+		modifiers: surface.modifiers ?? NO_MODIFIERS,
+		action: view.action,
+		hover: surface.hover,
+		zoom: viewZoom(view.view),
+		mode: surface.mode?.id ?? "normal",
+		allowedCapabilities: surface.mode?.allowedCapabilities ?? DEFAULT_ALLOWED_CAPABILITIES,
+		selectionResizable: resizable ? view.selection.every((id) => resizable(id)) : void 0,
+		editingAnchors: surface.editingAnchors,
+		device: surface.device
 	});
 }
-function c(e) {
-	let i = r(e);
-	return n(() => {
-		let e = (e) => {
-			let t = i.current;
-			return s({
-				focused: !t.getFocused || t.getFocused(),
-				modifiers: t.getModifiers?.(),
-				hover: t.getHover(),
-				mode: t.getMode?.(),
-				resizable: t.resizable,
-				editingAnchors: t.editingAnchors(),
-				device: t.device
-			}, e);
+/** The chrome-caps answers for a surface. The object keeps its identity for
+*  the life of the component and reads `source` as of the last commit. */
+function useChromeCaps(source) {
+	const live = useLatest(source);
+	return useMemo(() => {
+		const build = (inputs) => {
+			const now = live.current;
+			return surfaceRuleCtx({
+				focused: now.getFocused ? now.getFocused() : true,
+				modifiers: now.getModifiers?.(),
+				hover: now.getHover(),
+				mode: now.getMode?.(),
+				resizable: now.resizable,
+				editingAnchors: now.editingAnchors(),
+				device: now.device
+			}, inputs);
 		};
 		return {
-			ruleCtx: (t) => i.current.getMode ? e(t) : void 0,
-			isVisible: (n) => t(i.current.rules, e(n))
+			ruleCtx: (inputs) => live.current.getMode ? build(inputs) : void 0,
+			isVisible: (inputs) => resolveVisibility(live.current.rules, build(inputs))
 		};
-	}, [i]);
+	}, [live]);
 }
-//#endregion
-export { s as surfaceRuleCtx, c as useChromeCaps };
 
+//#endregion
+export { surfaceRuleCtx, useChromeCaps };
 //# sourceMappingURL=useChromeCaps.js.map

package/dist/features/chrome-caps/useChromeCaps.js.map

@@ -1 +1 @@
-{"version":3,"file":"useChromeCaps.js","names":["NO_MODIFIERS","surfaceRuleCtx","surface","buildRuleCtx","view","viewZoom","DEFAULT_ALLOWED_CAPABILITIES","resizable","id","useChromeCaps","live","useLatest","source","useMemo","build","now","inputs","resolveVisibility"],"sources":["../../../src/features/chrome-caps/useChromeCaps.ts"],"sourcesContent":["/**\n * The rule context a surface's chrome-visibility rules and action eligibility\n * are evaluated against, and the hook that keeps one for `<SceneCanvas>`.\n */\nimport { useMemo } from 'react';\nimport type { ActiveMode } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  buildRuleCtx,\n  DEFAULT_ALLOWED_CAPABILITIES,\n  type DeviceProfile,\n  type ModifierState,\n  type RuleCtx,\n} from '@weasel-js/routing';\nimport type { NodeId } from '../../core/scene/types';\nimport { viewZoom, type View } from '../../core/viewport/view';\nimport { resolveVisibility } from './resolve';\nimport type { VisibilityRules } from './types';\n\n/**\n * The part of a rule context that belongs to one view. Everything else a\n * `RuleCtx` carries — mode, capabilities, device, focus — is the surface's and\n * the same for every view drawn on it.\n */\nexport interface ViewRuleInputs {\n  selection: readonly NodeId[];\n  view: View;\n  /** What that view's dispatcher currently has in flight. */\n  action: { kind: string | null; id: string | null };\n}\n\n/** The part of a rule context that belongs to the surface. */\nexport interface SurfaceRuleInputs {\n  focused: boolean;\n  /** The modifier keys held. Absent means none, so `modifierHeld` never matches. */\n  modifiers?: ModifierState | undefined;\n  hover: NodeId | null;\n  /** Absent on a surface with no mode registry, which behaves as normal mode. */\n  mode: ActiveMode | undefined;\n  /** Whether one node may be resized. Absent means every node may. */\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: boolean;\n  device: DeviceProfile;\n}\n\nconst NO_MODIFIERS = { alt: false, ctrl: false, meta: false, shift: false };\n\n/** One view's rule context on a surface. */\nexport function surfaceRuleCtx(surface: SurfaceRuleInputs, view: ViewRuleInputs): RuleCtx {\n  const { resizable } = surface;\n  return buildRuleCtx({\n    focused: surface.focused,\n    selection: view.selection,\n    multiActive: view.selection.length > 1,\n    modifiers: surface.modifiers ?? NO_MODIFIERS,\n    action: view.action,\n    hover: surface.hover,\n    zoom: viewZoom(view.view),\n    mode: surface.mode?.id ?? 'normal',\n    // An empty set would make every `capability:` rule false and hide the\n    // chrome those rules gate.\n    allowedCapabilities: surface.mode?.allowedCapabilities ?? DEFAULT_ALLOWED_CAPABILITIES,\n    // Left undefined without a predicate, which `resizable:` reads as resizable.\n    selectionResizable: resizable ? view.selection.every((id) => resizable(id)) : undefined,\n    editingAnchors: surface.editingAnchors,\n    device: surface.device,\n  });\n}\n\n/** Where a surface's rule context comes from. Read at the moment a rule is\n *  evaluated, never at render. */\nexport interface ChromeCapsSource {\n  /** The surface's rule table, over the kit defaults. */\n  rules: VisibilityRules | undefined;\n  /** The active mode. Absent when no mode registry is wired. */\n  getMode: (() => ActiveMode) | undefined;\n  /** Absent means the surface always counts as focused. */\n  getFocused: (() => boolean) | undefined;\n  getHover: () => NodeId | null;\n  /** Absent means no modifier key ever counts as held. */\n  getModifiers?: (() => ModifierState) | undefined;\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: () => boolean;\n  device: DeviceProfile;\n}\n\n/**\n * A surface's chrome-caps answers for one view. The rules are surface-wide on\n * purpose — one consumer table, one set of kit defaults — but a rule keyed on\n * selection, camera or the in-flight action answers differently per view, so\n * the caller supplies that part and both the paint gate and the dispatcher's\n * eligibility filter read the same context.\n */\nexport interface ChromeCaps {\n  /** `undefined` when the surface gates nothing: no mode registry is wired. */\n  ruleCtx(inputs: ViewRuleInputs): RuleCtx | undefined;\n  isVisible(inputs: ViewRuleInputs): (id: string) => boolean;\n}\n\n/** The chrome-caps answers for a surface. The object keeps its identity for\n *  the life of the component and reads `source` as of the last commit. */\nexport function useChromeCaps(source: ChromeCapsSource): ChromeCaps {\n  const live = useLatest(source);\n  return useMemo(() => {\n    const build = (inputs: ViewRuleInputs): RuleCtx => {\n      const now = live.current;\n      return surfaceRuleCtx({\n        focused: now.getFocused ? now.getFocused() : true,\n        modifiers: now.getModifiers?.(),\n        hover: now.getHover(),\n        mode: now.getMode?.(),\n        resizable: now.resizable,\n        editingAnchors: now.editingAnchors(),\n        device: now.device,\n      }, inputs);\n    };\n    return {\n      ruleCtx: (inputs) => (live.current.getMode ? build(inputs) : undefined),\n      isVisible: (inputs) => resolveVisibility(live.current.rules, build(inputs)),\n    };\n  }, [live]);\n}\n"],"mappings":";;;;;;AA6CA,IAAMA,IAAe;CAAE,KAAK;CAAO,MAAM;CAAO,MAAM;CAAO,OAAO;AAAM;AAG1E,SAAgBC,EAAe,GAA4B,GAA+B;CACxF,IAAM,EAAE,iBAAcC;CACtB,OAAOC,EAAa;EAClB,SAASD,EAAQ;EACjB,WAAWE,EAAK;EAChB,aAAaA,EAAK,UAAU,SAAS;EACrC,WAAWF,EAAQ,aAAaF;EAChC,QAAQI,EAAK;EACb,OAAOF,EAAQ;EACf,MAAMG,EAASD,EAAK,IAAI;EACxB,MAAMF,EAAQ,MAAM,MAAM;EAG1B,qBAAqBA,EAAQ,MAAM,uBAAuBI;EAE1D,oBAAoBC,IAAYH,EAAK,UAAU,OAAO,MAAOG,EAAUC,CAAE,CAAC,IAAI,KAAA;EAC9E,gBAAgBN,EAAQ;EACxB,QAAQA,EAAQ;CAClB,CAAC;AACH;AAkCA,SAAgBO,EAAc,GAAsC;CAClE,IAAMC,IAAOC,EAAUC,CAAM;CAC7B,OAAOC,QAAc;EACnB,IAAMC,KAAS,MAAoC;GACjD,IAAMC,IAAML,EAAK;GACjB,OAAOT,EAAe;IACpB,SAAS,GAAI,cAAac,EAAI,WAAW;IACzC,WAAWA,EAAI,eAAe;IAC9B,OAAOA,EAAI,SAAS;IACpB,MAAMA,EAAI,UAAU;IACpB,WAAWA,EAAI;IACf,gBAAgBA,EAAI,eAAe;IACnC,QAAQA,EAAI;GACd,GAAGC,CAAM;EACX;EACA,OAAO;GACL,UAAU,MAAYN,EAAK,QAAQ,UAAUI,EAAME,CAAM,IAAI,KAAA;GAC7D,YAAY,MAAWC,EAAkBP,EAAK,QAAQ,OAAOI,EAAME,CAAM,CAAC;EAC5E;CACF,GAAG,CAACN,CAAI,CAAC;AACX"}
+{"version":3,"file":"useChromeCaps.js","names":[],"sources":["../../../src/features/chrome-caps/useChromeCaps.ts"],"sourcesContent":["/**\n * The rule context a surface's chrome-visibility rules and action eligibility\n * are evaluated against, and the hook that keeps one for `<SceneCanvas>`.\n */\nimport { useMemo } from 'react';\nimport type { ActiveMode } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  buildRuleCtx,\n  DEFAULT_ALLOWED_CAPABILITIES,\n  type DeviceProfile,\n  type ModifierState,\n  type RuleCtx,\n} from '@weasel-js/routing';\nimport type { NodeId } from '../../core/scene/types';\nimport { viewZoom, type View } from '../../core/viewport/view';\nimport { resolveVisibility } from './resolve';\nimport type { VisibilityRules } from './types';\n\n/**\n * The part of a rule context that belongs to one view. Everything else a\n * `RuleCtx` carries — mode, capabilities, device, focus — is the surface's and\n * the same for every view drawn on it.\n */\nexport interface ViewRuleInputs {\n  selection: readonly NodeId[];\n  view: View;\n  /** What that view's dispatcher currently has in flight. */\n  action: { kind: string | null; id: string | null };\n}\n\n/** The part of a rule context that belongs to the surface. */\nexport interface SurfaceRuleInputs {\n  focused: boolean;\n  /** The modifier keys held. Absent means none, so `modifierHeld` never matches. */\n  modifiers?: ModifierState | undefined;\n  hover: NodeId | null;\n  /** Absent on a surface with no mode registry, which behaves as normal mode. */\n  mode: ActiveMode | undefined;\n  /** Whether one node may be resized. Absent means every node may. */\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: boolean;\n  device: DeviceProfile;\n}\n\nconst NO_MODIFIERS = { alt: false, ctrl: false, meta: false, shift: false };\n\n/** One view's rule context on a surface. */\nexport function surfaceRuleCtx(surface: SurfaceRuleInputs, view: ViewRuleInputs): RuleCtx {\n  const { resizable } = surface;\n  return buildRuleCtx({\n    focused: surface.focused,\n    selection: view.selection,\n    multiActive: view.selection.length > 1,\n    modifiers: surface.modifiers ?? NO_MODIFIERS,\n    action: view.action,\n    hover: surface.hover,\n    zoom: viewZoom(view.view),\n    mode: surface.mode?.id ?? 'normal',\n    // An empty set would make every `capability:` rule false and hide the\n    // chrome those rules gate.\n    allowedCapabilities: surface.mode?.allowedCapabilities ?? DEFAULT_ALLOWED_CAPABILITIES,\n    // Left undefined without a predicate, which `resizable:` reads as resizable.\n    selectionResizable: resizable ? view.selection.every((id) => resizable(id)) : undefined,\n    editingAnchors: surface.editingAnchors,\n    device: surface.device,\n  });\n}\n\n/** Where a surface's rule context comes from. Read at the moment a rule is\n *  evaluated, never at render. */\nexport interface ChromeCapsSource {\n  /** The surface's rule table, over the kit defaults. */\n  rules: VisibilityRules | undefined;\n  /** The active mode. Absent when no mode registry is wired. */\n  getMode: (() => ActiveMode) | undefined;\n  /** Absent means the surface always counts as focused. */\n  getFocused: (() => boolean) | undefined;\n  getHover: () => NodeId | null;\n  /** Absent means no modifier key ever counts as held. */\n  getModifiers?: (() => ModifierState) | undefined;\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: () => boolean;\n  device: DeviceProfile;\n}\n\n/**\n * A surface's chrome-caps answers for one view. The rules are surface-wide on\n * purpose — one consumer table, one set of kit defaults — but a rule keyed on\n * selection, camera or the in-flight action answers differently per view, so\n * the caller supplies that part and both the paint gate and the dispatcher's\n * eligibility filter read the same context.\n */\nexport interface ChromeCaps {\n  /** `undefined` when the surface gates nothing: no mode registry is wired. */\n  ruleCtx(inputs: ViewRuleInputs): RuleCtx | undefined;\n  isVisible(inputs: ViewRuleInputs): (id: string) => boolean;\n}\n\n/** The chrome-caps answers for a surface. The object keeps its identity for\n *  the life of the component and reads `source` as of the last commit. */\nexport function useChromeCaps(source: ChromeCapsSource): ChromeCaps {\n  const live = useLatest(source);\n  return useMemo(() => {\n    const build = (inputs: ViewRuleInputs): RuleCtx => {\n      const now = live.current;\n      return surfaceRuleCtx({\n        focused: now.getFocused ? now.getFocused() : true,\n        modifiers: now.getModifiers?.(),\n        hover: now.getHover(),\n        mode: now.getMode?.(),\n        resizable: now.resizable,\n        editingAnchors: now.editingAnchors(),\n        device: now.device,\n      }, inputs);\n    };\n    return {\n      ruleCtx: (inputs) => (live.current.getMode ? build(inputs) : undefined),\n      isVisible: (inputs) => resolveVisibility(live.current.rules, build(inputs)),\n    };\n  }, [live]);\n}\n"],"mappings":";;;;;;;;;;;AA6CA,IAAM,eAAe;CAAE,KAAK;CAAO,MAAM;CAAO,MAAM;CAAO,OAAO;AAAM;;AAG1E,SAAgB,eAAe,SAA4B,MAA+B;CACxF,MAAM,EAAE,cAAc;CACtB,OAAO,aAAa;EAClB,SAAS,QAAQ;EACjB,WAAW,KAAK;EAChB,aAAa,KAAK,UAAU,SAAS;EACrC,WAAW,QAAQ,aAAa;EAChC,QAAQ,KAAK;EACb,OAAO,QAAQ;EACf,MAAM,SAAS,KAAK,IAAI;EACxB,MAAM,QAAQ,MAAM,MAAM;EAG1B,qBAAqB,QAAQ,MAAM,uBAAuB;EAE1D,oBAAoB,YAAY,KAAK,UAAU,OAAO,OAAO,UAAU,EAAE,CAAC,IAAI;EAC9E,gBAAgB,QAAQ;EACxB,QAAQ,QAAQ;CAClB,CAAC;AACH;;;AAkCA,SAAgB,cAAc,QAAsC;CAClE,MAAM,OAAO,UAAU,MAAM;CAC7B,OAAO,cAAc;EACnB,MAAM,SAAS,WAAoC;GACjD,MAAM,MAAM,KAAK;GACjB,OAAO,eAAe;IACpB,SAAS,IAAI,aAAa,IAAI,WAAW,IAAI;IAC7C,WAAW,IAAI,eAAe;IAC9B,OAAO,IAAI,SAAS;IACpB,MAAM,IAAI,UAAU;IACpB,WAAW,IAAI;IACf,gBAAgB,IAAI,eAAe;IACnC,QAAQ,IAAI;GACd,GAAG,MAAM;EACX;EACA,OAAO;GACL,UAAU,WAAY,KAAK,QAAQ,UAAU,MAAM,MAAM,IAAI;GAC7D,YAAY,WAAW,kBAAkB,KAAK,QAAQ,OAAO,MAAM,MAAM,CAAC;EAC5E;CACF,GAAG,CAAC,IAAI,CAAC;AACX"}