@weasel-js/core 1.7.0 → 1.7.1

package/dist/debug/defaultTheme.js

@@ -0,0 +1,31 @@
+//#region src/debug/defaultTheme.ts
+var e = {
+	hitboxFill: "rgba(255, 0, 255, 0.25)",
+	hitboxStroke: "#ff00ff",
+	handle: "#00e5ff",
+	bounds: "#ffeb3b",
+	origin: "#69f0ae",
+	snap: "#ffa726",
+	layerText: "#e0e0e0",
+	layerTextBg: "rgba(0, 0, 0, 0.6)",
+	idText: "#ffeb3b",
+	fpsText: "#e0e0e0",
+	fpsTextBg: "rgba(0, 0, 0, 0.6)",
+	viewport: "#b388ff"
+}, t = {
+	hitbox: {
+		width: 1,
+		dash: [2, 2]
+	},
+	bounds: { width: 1 },
+	handle: { width: 1 },
+	snap: { width: 1 },
+	viewport: {
+		width: 1,
+		dash: [6, 4]
+	}
+};
+//#endregion
+export { t as DEFAULT_DEBUG_STROKES, e as DEFAULT_DEBUG_THEME };
+
+//# sourceMappingURL=defaultTheme.js.map

package/dist/debug/defaultTheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTheme.js","names":["DEFAULT_DEBUG_THEME","DEFAULT_DEBUG_STROKES"],"sources":["../../src/debug/defaultTheme.ts"],"sourcesContent":["import type { DebugStrokes, DebugTheme } from './types';\n\n/**\n * Default colors per the spec's Visual Style section. High contrast against\n * the demo's dark backdrop. Override by passing `theme: { ... }` on\n * `DebugConfig`.\n */\nexport const DEFAULT_DEBUG_THEME: DebugTheme = {\n  hitboxFill: 'rgba(255, 0, 255, 0.25)',\n  hitboxStroke: '#ff00ff',\n  handle: '#00e5ff',\n  bounds: '#ffeb3b',\n  origin: '#69f0ae',\n  snap: '#ffa726',\n  layerText: '#e0e0e0',\n  layerTextBg: 'rgba(0, 0, 0, 0.6)',\n  idText: '#ffeb3b',\n  fpsText: '#e0e0e0',\n  fpsTextBg: 'rgba(0, 0, 0, 0.6)',\n  viewport: '#b388ff',\n};\n\n/**\n * Default line widths and dashes. Hairline everywhere so the overlay never\n * hides the geometry it is describing; the dash on hitboxes is what\n * distinguishes them from the solid bounds box at the same rect.\n * Override by passing `strokes: { ... }` on `DebugConfig`.\n */\nexport const DEFAULT_DEBUG_STROKES: DebugStrokes = {\n  hitbox: { width: 1, dash: [2, 2] },\n  bounds: { width: 1 },\n  handle: { width: 1 },\n  snap: { width: 1 },\n  viewport: { width: 1, dash: [6, 4] },\n};\n"],"mappings":";AAOA,IAAaA,IAAkC;CAC7C,YAAY;CACZ,cAAc;CACd,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,MAAM;CACN,WAAW;CACX,aAAa;CACb,QAAQ;CACR,SAAS;CACT,WAAW;CACX,UAAU;AACZ,GAQaC,IAAsC;CACjD,QAAQ;EAAE,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CACjC,QAAQ,EAAE,OAAO,EAAE;CACnB,QAAQ,EAAE,OAAO,EAAE;CACnB,MAAM,EAAE,OAAO,EAAE;CACjB,UAAU;EAAE,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;AACrC"}

package/dist/debug/flag.js

@@ -0,0 +1,41 @@
+//#region src/debug/flag.ts
+var e = ["weasel.debug", "weaseldraw.debug"], t = null;
+function n() {
+	let t = {
+		all: !1,
+		set: /* @__PURE__ */ new Set()
+	};
+	if (typeof localStorage > "u") return t;
+	try {
+		for (let t of e) {
+			let e = localStorage.getItem(t);
+			if (e != null && e !== "") return e === "1" || e === "true" || e === "*" ? {
+				all: !0,
+				set: /* @__PURE__ */ new Set()
+			} : {
+				all: !1,
+				set: new Set(e.split(/[\s,]+/).filter(Boolean))
+			};
+		}
+		return t;
+	} catch {
+		return t;
+	}
+}
+function r() {
+	return t === null && (t = n()), t;
+}
+function i(e) {
+	let t = r();
+	return t.all ? !0 : e === void 0 ? t.set.size > 0 : t.set.has(e);
+}
+function a(e, ...t) {
+	i(e) && console.debug(`[${e}]`, ...t);
+}
+function o(e, ...t) {
+	i(e) && console.warn(`[${e}]`, ...t);
+}
+//#endregion
+export { a as dlog, o as dwarn, i as isDebugEnabled };
+
+//# sourceMappingURL=flag.js.map

package/dist/debug/flag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flag.js","names":["KEYS","cached","read","empty","k","v","get","isDebugEnabled","c","namespace","dlog","args","dwarn"],"sources":["../../src/debug/flag.ts"],"sourcesContent":["/**\n * Namespaced, opt-in console tracing for the kit.\n *\n * Enable in the browser:\n *\n *   localStorage.setItem('weasel.debug', '*')                 // all namespaces\n *   localStorage.setItem('weasel.debug', 'tools,dispatch')    // specific ones\n *   localStorage.setItem('weasel.debug', '1')                 // legacy \"all\"\n *\n * Each call site picks a stable namespace string. Off by default; the flag\n * is read once and cached per page session — reload to pick up a change.\n *\n * Mirrors `packages/ui/src/dlog.ts`. The two impls live in separate\n * packages because weasel-ui doesn't depend on the kit, but both read the\n * same localStorage keys so behavior is uniform from a debugger's POV.\n *\n * Known kit namespaces:\n *   - tools           — active-tool + hotkey transitions (useTools)\n *   - dispatch        — gesture start / end / cancel (dispatcher)\n *   - drag-rect       — useDragRect lifecycle\n *   - drag-radial     — useDragRadial lifecycle\n *   - scene           — restored-op replay gaps (history persistence)\n *   - scene-canvas    — SceneCanvas mount / unmount; adapter paste-translation warnings\n *   - history         — applyOps push, no-op suppression, serialize/restore\n *   - clipboard       — OS clipboard write/read failures, malformed payloads\n */\n\nconst KEYS = ['weasel.debug', 'weaseldraw.debug'] as const;\n\ninterface Cached {\n  all: boolean;\n  set: Set<string>;\n}\n\nlet cached: Cached | null = null;\n\nfunction read(): Cached {\n  const empty: Cached = { all: false, set: new Set() };\n  if (typeof localStorage === 'undefined') return empty;\n  try {\n    for (const k of KEYS) {\n      const v = localStorage.getItem(k);\n      if (v == null || v === '') continue;\n      if (v === '1' || v === 'true' || v === '*') return { all: true, set: new Set() };\n      return { all: false, set: new Set(v.split(/[\\s,]+/).filter(Boolean)) };\n    }\n    return empty;\n  } catch {\n    return empty;\n  }\n}\n\nfunction get(): Cached {\n  if (cached === null) cached = read();\n  return cached;\n}\n\n/** True when `namespace` (or `*`) is enabled. Pass no argument to test\n *  whether *any* namespace is on (legacy global-flag semantics). */\nexport function isDebugEnabled(namespace?: string): boolean {\n  const c = get();\n  if (c.all) return true;\n  if (namespace === undefined) return c.set.size > 0;\n  return c.set.has(namespace);\n}\n\n/** Conditional `console.debug` — no-op unless `namespace` (or `*`) is enabled.\n *  Each call is prefixed with `[namespace]` so the source is searchable. */\nexport function dlog(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  // eslint-disable-next-line no-console\n  console.debug(`[${namespace}]`, ...args);\n}\n\n/** Conditional `console.warn` — like `dlog` but at warn level. Use for\n *  diagnostics that indicate something worth surfacing during debugging\n *  (e.g. no-op op batches suppressed). */\nexport function dwarn(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  console.warn(`[${namespace}]`, ...args);\n}\n"],"mappings":";AA2BA,IAAMA,IAAO,CAAC,gBAAgB,kBAAkB,GAO5CC,IAAwB;AAE5B,SAASC,IAAe;CACtB,IAAMC,IAAgB;EAAE,KAAK;EAAO,qBAAK,IAAI,IAAI;CAAE;CACnD,IAAI,OAAO,eAAiB,KAAa,OAAOA;CAChD,IAAI;EACF,KAAK,IAAMC,KAAKJ,GAAM;GACpB,IAAMK,IAAI,aAAa,QAAQD,CAAC;GAChC,IAAIC,KAAK,QAAQA,MAAM,IAEvB,OADIA,MAAM,OAAOA,MAAM,UAAUA,MAAM,MAAY;IAAE,KAAK;IAAM,qBAAK,IAAI,IAAI;GAAE,IACxE;IAAE,KAAK;IAAO,KAAK,IAAI,IAAIA,EAAE,MAAM,QAAQ,CAAC,CAAC,OAAO,OAAO,CAAC;GAAE;EACvE;EACA,OAAOF;CACT,QAAQ;EACN,OAAOA;CACT;AACF;AAEA,SAASG,IAAc;CAErB,OADIL,MAAW,SAAM,IAASC,EAAK,IAC5BD;AACT;AAIA,SAAgBM,EAAe,GAA6B;CAC1D,IAAMC,IAAIF,EAAI;CAGd,OAFIE,EAAE,MAAY,KACdC,MAAc,KAAA,IAAkBD,EAAE,IAAI,OAAO,IAC1CA,EAAE,IAAI,IAAIC,CAAS;AAC5B;AAIA,SAAgBC,EAAK,GAAmB,GAAGC,GAAuB;CAChE,AAAKJ,EAAeE,CAAS,KAE7B,QAAQ,MAAM,IAAIA,EAAU,IAAI,GAAGE,CAAI;AACzC;AAKA,SAAgBC,EAAM,GAAmB,GAAGD,GAAuB;CACjE,AAAKJ,EAAeE,CAAS,KAC7B,QAAQ,KAAK,IAAIA,EAAU,IAAI,GAAGE,CAAI;AACxC"}

package/dist/debug/frameStats.js

@@ -0,0 +1,16 @@
+//#region src/debug/frameStats.ts
+function e(e, t, n) {
+	return {
+		paintMs: n,
+		drawCalls: t.drawCalls,
+		layers: e.map((e, n) => ({
+			id: e.id,
+			drawCalls: t.spans[n]?.drawCalls ?? 0,
+			ms: e.buildMs + (t.spans[n]?.ms ?? 0)
+		}))
+	};
+}
+//#endregion
+export { e as frameStatsOf };
+
+//# sourceMappingURL=frameStats.js.map

package/dist/debug/frameStats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameStats.js","names":["frameStatsOf","render","layers","l","i"],"sources":["../../src/debug/frameStats.ts"],"sourcesContent":["import type { LayerDrawSpan } from 'core/layers/render';\nimport type { RenderStats } from '../renderer/WeaselRenderer';\nimport type { FrameStats } from './types';\n\n/** One paint's {@link FrameStats}: each layer's build time from `drawLayers`\n *  joined with its dispatch cost from the renderer, span for span. */\nexport function frameStatsOf(layers: readonly LayerDrawSpan[], render: RenderStats, paintMs: number): FrameStats {\n  return {\n    paintMs,\n    drawCalls: render.drawCalls,\n    layers: layers.map((l, i) => ({\n      id: l.id,\n      drawCalls: render.spans[i]?.drawCalls ?? 0,\n      ms: l.buildMs + (render.spans[i]?.ms ?? 0),\n    })),\n  };\n}\n"],"mappings":";AAMA,SAAgBA,EAAa,GAAkC,GAAqB,GAA6B;CAC/G,OAAO;EACL;EACA,WAAWC,EAAO;EAClB,QAAQC,EAAO,KAAK,GAAG,OAAO;GAC5B,IAAIC,EAAE;GACN,WAAWF,EAAO,MAAMG,EAAE,EAAE,aAAa;GACzC,IAAID,EAAE,WAAWF,EAAO,MAAMG,EAAE,EAAE,MAAM;EAC1C,EAAE;CACJ;AACF"}

package/dist/debug/parseDebugFlags.js

@@ -0,0 +1,32 @@
+//#region src/debug/parseDebugFlags.ts
+var e = [
+	"hitboxes",
+	"handles",
+	"bounds",
+	"origins",
+	"snap",
+	"layers",
+	"ids",
+	"fps",
+	"viewport"
+];
+function t(t) {
+	let n = t.startsWith("?") ? t.slice(1) : t;
+	if (n.length === 0) return null;
+	let r = new URLSearchParams(n).get("debug");
+	if (!r) return null;
+	let i = r.split(",").map((e) => e.trim()).filter(Boolean);
+	if (i.length === 0) return null;
+	if (i.includes("all")) {
+		let t = {};
+		for (let n of e) t[n] = !0;
+		return t;
+	}
+	let a = {};
+	for (let t of i) e.includes(t) && (a[t] = !0);
+	return Object.keys(a).length > 0 ? a : null;
+}
+//#endregion
+export { t as parseDebugFlags };
+
+//# sourceMappingURL=parseDebugFlags.js.map

package/dist/debug/parseDebugFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDebugFlags.js","names":["ALL_FEATURES","parseDebugFlags","trimmed","search","raw","tokens","t","out","f"],"sources":["../../src/debug/parseDebugFlags.ts"],"sourcesContent":["import type { DebugConfig, DebugFeature } from './types';\n\nconst ALL_FEATURES: DebugFeature[] = [\n  'hitboxes', 'handles', 'bounds', 'origins', 'snap', 'layers', 'ids', 'fps', 'viewport',\n];\n\n/**\n * Parse a URL query string (with or without leading `?`) for a `debug` param.\n *\n * - `?debug=hitboxes` → `{ hitboxes: true }`\n * - `?debug=bounds,origins` → `{ bounds: true, origins: true }`\n * - `?debug=all` → every feature enabled\n * - missing/empty/unknown-only → `null`\n */\nexport function parseDebugFlags(search: string): DebugConfig | null {\n  const trimmed = search.startsWith('?') ? search.slice(1) : search;\n  if (trimmed.length === 0) return null;\n  const params = new URLSearchParams(trimmed);\n  const raw = params.get('debug');\n  if (!raw) return null;\n  const tokens = raw.split(',').map((t) => t.trim()).filter(Boolean);\n  if (tokens.length === 0) return null;\n  if (tokens.includes('all')) {\n    const out: DebugConfig = {};\n    for (const f of ALL_FEATURES) out[f] = true;\n    return out;\n  }\n  const out: DebugConfig = {};\n  for (const t of tokens) {\n    if ((ALL_FEATURES as string[]).includes(t)) out[t as DebugFeature] = true;\n  }\n  return Object.keys(out).length > 0 ? out : null;\n}\n"],"mappings":";AAEA,IAAMA,IAA+B;CACnC;CAAY;CAAW;CAAU;CAAW;CAAQ;CAAU;CAAO;CAAO;AAC9E;AAUA,SAAgBC,EAAgB,GAAoC;CAClE,IAAMC,IAAUC,EAAO,WAAW,GAAG,IAAIA,EAAO,MAAM,CAAC,IAAIA;CAC3D,IAAID,EAAQ,WAAW,GAAG,OAAO;CAEjC,IAAME,IAAM,IADO,gBAAgBF,CACvB,CAAA,CAAO,IAAI,OAAO;CAC9B,IAAI,CAACE,GAAK,OAAO;CACjB,IAAMC,IAASD,EAAI,MAAM,GAAG,CAAC,CAAC,KAAK,MAAME,EAAE,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO;CACjE,IAAID,EAAO,WAAW,GAAG,OAAO;CAChC,IAAIA,EAAO,SAAS,KAAK,GAAG;EAC1B,IAAME,IAAmB,CAAC;EAC1B,KAAK,IAAMC,KAAKR,GAAc,EAAIQ,KAAK;EACvC,OAAOD;CACT;CACA,IAAMA,IAAmB,CAAC;CAC1B,KAAK,IAAM,KAAKF,GACd,AAAKL,EAA0B,SAAS,CAAC,MAAG,EAAI,KAAqB;CAEvE,OAAO,OAAO,KAAKO,CAAG,CAAC,CAAC,SAAS,IAAIA,IAAM;AAC7C"}

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

@@ -0,0 +1,16 @@
+//#region src/features/chrome-caps/buildChromeCtx.ts
+function e(e) {
+	return {
+		focused: e.focused,
+		selection: e.selection,
+		multiActive: e.multiActive,
+		modifiers: e.modifiers,
+		action: e.action,
+		hover: e.hover,
+		view: e.view
+	};
+}
+//#endregion
+export { e as buildChromeCtx };
+
+//# sourceMappingURL=buildChromeCtx.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildChromeCtx.js","names":["buildChromeCtx","args"],"sources":["../../../src/features/chrome-caps/buildChromeCtx.ts"],"sourcesContent":["/**\n * Pure assembler for {@link ChromeCtx}.\n *\n * Called once per frame on the rendering side from whichever surface\n * needs to evaluate visibility rules — `composeAffordanceLayer`,\n * `createSelectionOverlayLayer`, the dispatcher overlay layer, etc.\n *\n * Sources are passed as plain getters / values rather than the live\n * objects they come from. This keeps `chrome-caps` from depending on\n * React, the dispatcher's concrete type, or `ChromeState`'s bounds\n * machinery — the same builder works from a test harness, a forge\n * story, or `<SceneCanvas>`.\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":";AAgCA,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"}

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

@@ -0,0 +1,36 @@
+import { ALWAYS as e, NEVER as t, evaluate as n } 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;
+}
+function i(e) {
+	return typeof e == "function" ? e.rule : e;
+}
+function a(e, t) {
+	let n = "all" in e ? e.all : [e], r = "all" in t ? t.all : [t];
+	return { all: [...n, ...r] };
+}
+function o(e, t) {
+	let n = "any" in e ? e.any : [e], r = "any" in t ? t.any : [t];
+	return { any: [...n, ...r] };
+}
+function s(e) {
+	return r({ when: e });
+}
+function c(...e) {
+	return r({ all: e.map(i) });
+}
+function l(...e) {
+	return r({ any: e.map(i) });
+}
+function u(e) {
+	return r({ not: i(e) });
+}
+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 };
+
+//# sourceMappingURL=conditions.js.map

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

@@ -0,0 +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. The function form evaluates\n * the tree against a RuleCtx; combinator methods produce new Conditions\n * wrapping `all`/`any`/`not` nodes.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))` — NOT\n * `(focused || (hovering && selectionIs(1)))` as standard precedence\n * would give. For grouped disjunction, use the top-level `or` / `and` /\n * `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] }` rather than `{ all: [{ all: [a, b] }, c] }`.\n * Canonical form simplifies downstream introspection.\n *\n * Use {@link when} for the inline-lambda escape hatch.\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). Implemented as a `when` because\n *  `multiActive` is a derived single-call read on RuleCtx, not a\n *  selector-table key. Stable; safe to introspect. */\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 (new) ─────────────────────────────────\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, so a rule written with this atom is inert on the\n *  mouse-shaped default rather than silently flipping. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. Pair with\n *  `not(...)` to gate chrome that only makes sense with a hovering\n *  pointer: `not(canHover)` is \"this device cannot hover\". */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":";;AAwBA,SAAgBA,EAAK,GAAuB;CAE1C,IAAMC,KADM,MAAiBC,EAASC,GAAMC,CAAG;CAO/C,OALA,EAA8B,OAAOD,GACrC,EAAU,OAAU,MAAUH,EAAKK,EAAWF,GAAMG,EAAOC,CAAK,CAAC,CAAC,GAClE,EAAU,MAAU,MAAUP,EAAKQ,EAAWL,GAAMG,EAAOC,CAAK,CAAC,CAAC,GAClE,EAAU,UAAU,MAAUP,EAAKK,EAAWF,GAAM,EAAE,KAAKG,EAAOC,CAAK,EAAE,CAAC,CAAC,GAC3E,EAAU,SAAU,MAAUP,EAAKQ,EAAWL,GAAM,EAAE,KAAKG,EAAOC,CAAK,EAAE,CAAC,CAAC,GACpEN;AACT;AAEA,SAASK,EAAO,GAA+B;CAC7C,OAAO,OAAOG,KAAU,aAAcA,EAAoB,OAAOA;AACnE;AAEA,SAASJ,EAAW,GAAS,GAAe;CAC1C,IAAMK,IAAO,SAASC,IAAIA,EAAE,MAAM,CAACA,CAAC,GAC9BC,IAAQ,SAASC,IAAIA,EAAE,MAAM,CAACA,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAGH,GAAM,GAAGE,CAAK,EAAE;AACpC;AAEA,SAASJ,EAAW,GAAS,GAAe;CAC1C,IAAME,IAAO,SAASC,IAAIA,EAAE,MAAM,CAACA,CAAC,GAC9BC,IAAQ,SAASC,IAAIA,EAAE,MAAM,CAACA,CAAC;CACrC,OAAO,EAAE,KAAK,CAAC,GAAGH,GAAM,GAAGE,CAAK,EAAE;AACpC;AAGA,SAAgBE,EAAK,GAA0C;CAC7D,OAAOd,EAAK,EAAE,MAAMe,EAAG,CAAC;AAC1B;AAMA,SAAgBC,EAAI,GAAGC,GAAqC;CAC1D,OAAOjB,EAAK,EAAE,KAAKiB,EAAG,IAAIX,CAAM,EAAE,CAAC;AACrC;AAIA,SAAgBY,EAAG,GAAGD,GAAqC;CACzD,OAAOjB,EAAK,EAAE,KAAKiB,EAAG,IAAIX,CAAM,EAAE,CAAC;AACrC;AAIA,SAAgBa,EAAI,GAAgC;CAClD,OAAOnB,EAAK,EAAE,KAAKM,EAAOc,CAAC,EAAE,CAAC;AAChC;AAKA,IAAaC,IAAoBrB,EAAKsB,CAAM,GAI/BC,IAAmBvB,EAAKwB,CAAK,GAK7BC,IAAqBzB,EAAK,EAAE,SAAS,GAAK,CAAC,GAG3C0B,IAAuB1B,EAAK,EAAE,WAAW,GAAK,CAAC;AAGnBA,EAAK,EAAE,gBAAgB,GAAK,CAAC,GAIlCA,EAAK,EAAE,WAAW,GAAK,CAAC;AAG5D,IAAa2B,KAAY,MAA4B3B,EAAK,EAAE,UAAU4B,EAAK,CAAC,GAK/DC,IAA4B7B,EAAK,EAAE,WAAW,EAAE,OAAO,GAAK,EAAE,CAAC,GAG/D8B,KAAe,MAAyB9B,EAAK,EAAE,WAAW,EAAE,IAAI+B,EAAE,EAAE,CAAC,GAIrEC,KAAoB,MAAyBhC,EAAK,EAAE,WAAW,EAAE,SAAS+B,EAAE,EAAE,CAAC,GAM/EE,IAAyBjC,EAAK,EAAE,OAAO,MAAMoB,EAAE,YAAY,CAAC,GAK5Dc,IAAsBlC,EAAK,EAAE,UAAU,GAAK,CAAC,GAG7CmC,IAA8BnC,EAAK,EAAE,kBAAkB,GAAK,CAAC,GAK7DoC,KAAgB,MAAsCpC,EAAK,EAAE,cAAcqC,EAAE,CAAC,GAM9EC,KAAe,MAAyBtC,EAAK,EAAE,aAAauC,EAAE,CAAC,GAK/DC,KAAU,MAAyBxC,EAAK,EAAE,MAAMqC,EAAE,CAAC,GAGnDI,KAAU,MAAwCzC,EAAK,EAAE,MAAM,EAAE,IAAI0C,EAAM,EAAE,CAAC,GAG9EC,KAAW,MAAyB3C,EAAK,EAAE,MAAM,EAAE,KAAKqC,EAAE,EAAE,CAAC,GAG7DO,KAAgB,MAA2B5C,EAAK,EAAE,YAAY6C,EAAI,CAAC,GAGnEC,KAAgB,MAAuC9C,EAAK,EAAE,YAAY,EAAE,IAAI+C,EAAK,EAAE,CAAC,GAGxFC,KAAiB,MAAuChD,EAAK,EAAE,YAAY,CAAC,GAAG+C,CAAI,EAAE,CAAC,GAGtFE,KAAiB,MAA2BjD,EAAK,EAAE,YAAY,EAAE,KAAK6C,EAAI,EAAE,CAAC,GAO7EK,IAA2BlD,EAAK,EAAE,eAAe,GAAK,CAAC,GAKvDmD,IAAsBnD,EAAK,EAAE,UAAU,GAAK,CAAC"}

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

@@ -0,0 +1,26 @@
+//#region src/features/chrome-caps/defaults.ts
+var e = {
+	"selection.outline": { all: [{ selection: { atLeast: 1 } }, { capability: { not: "edits-anchors" } }] },
+	"selection.resize-handles": { all: [
+		{ selection: { atLeast: 1 } },
+		{ not: { gesturing: !0 } },
+		{ capability: "transforms-selection" },
+		{ resizable: !0 }
+	] },
+	"selection.rotation-handle": { all: [
+		{ selection: { atLeast: 1 } },
+		{ focused: !0 },
+		{ not: { gesturing: !0 } },
+		{ 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 }
+};
+//#endregion
+export { e as defaultVisibilityRules };
+
+//# sourceMappingURL=defaults.js.map

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

@@ -0,0 +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 * Written as literal Rule trees rather than fluent chains so the inputs\n * each rule depends on are immediately visible. The fluent atoms compile\n * to the same trees; either form is valid in a VisibilityRules entry.\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. There is\n * no `mode:` rule left in this table — the `path-edit.*` chrome used to be\n * the exception, on the theory that it's the visual signature of one mode;\n * see the comment on those rules below for why that was wrong in both\n * directions and what replaced it.\n *\n * Chrome that gates on the *absence* of a capability (the selection\n * outline, suppressed while an anchor-editing overlay owns the visuals)\n * uses `capability: { not: … }` for the same reason.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Static selection chrome — visible while a selection exists, but off\n  // whenever an anchor-editing overlay has taken over the visuals (today:\n  // path-edit mode; tomorrow: anything else that allows `edits-anchors`).\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. Gated on the mode actually\n  // permitting transforms — grabbing a resize handle in a mode that\n  // forbids `transforms-selection` could only ever be a no-op — and on the\n  // selection being resizable (consumer `resizable` predicate).\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  // Rotation handle visible whenever any selection is focused — single\n  // mode pivots around the selected node's center; multi mode pivots\n  // around the union AABB center. Same transform gating as resize; also\n  // off during an action.\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.\n  //\n  // This used to read `{ mode: 'path-edit' }`, which was wrong in both\n  // directions. Consumers with no mode registry report mode `'normal'`,\n  // so the anchor hit-test (which asks `isVisible('path-edit.anchors')`)\n  // refused every anchor while the overlay — which never consulted the\n  // table at all — drew them anyway: visible but not grabbable, the exact\n  // failure this table exists to make impossible. And a consumer defining\n  // its own anchor-editing mode under a different id got neither.\n  //\n  // `editingAnchors` is the state both surfaces actually care about. It's\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, and drawing anchors for the former is wrong.\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 currently driven by\n  // dedicated boolean props on <SceneCanvas>. They'll move into this\n  // table as they migrate.\n};\n"],"mappings":";AAuBA,IAAaA,IAA0C;CAIrD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAOA,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;CAMA,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;CAgBzC,qBAAqB,EAAE,gBAAgB,GAAK;CAC5C,qBAAqB,EAAE,gBAAgB,GAAK;CAG5C,eAAe,EAAE,WAAW,GAAK;AAMnC"}

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

@@ -0,0 +1,7 @@
+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 };

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

@@ -0,0 +1,23 @@
+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";
+//#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),
+		mode: "normal",
+		allowedCapabilities: n
+	};
+	return (e) => {
+		let t = o[e];
+		return t === void 0 ? !0 : typeof t == "function" ? t(s) : r(t, s);
+	};
+}
+//#endregion
+export { i as resolveVisibility };
+
+//# sourceMappingURL=resolve.js.map

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

@@ -0,0 +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. Merges consumer rules on top\n * of the kit defaults, then closes over `ctx` so each chrome-id\n * lookup runs its rule against the current state.\n *\n * `VisibilityRules` entries may be either fluent `Condition` values\n * (callable) or raw `Rule` trees — we normalize at lookup time.\n *\n * Predicates are O(1) and run once per chrome id per frame; no\n * memoization in v1 — profile before adding any.\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":";;;;AAsBA,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"}

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

@@ -0,0 +1,27 @@
+import { useEffect as e, useRef as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+//#region src/features/chrome-caps/useHoverTracking.ts
+function r(r) {
+	let { canvasRef: i, nodeAtClientPoint: a, enabled: o = !0 } = r, s = t(null), c = n(a);
+	return e(() => {
+		if (!o) return;
+		let e = i.current;
+		if (!e) return;
+		let t = (e) => {
+			s.current = c.current(e.clientX, e.clientY)?.id ?? null;
+		}, n = () => {
+			s.current = null;
+		};
+		return e.addEventListener("pointermove", t), e.addEventListener("pointerleave", n), () => {
+			e.removeEventListener("pointermove", t), e.removeEventListener("pointerleave", n);
+		};
+	}, [
+		i,
+		o,
+		c
+	]), () => s.current;
+}
+//#endregion
+export { r as useHoverTracking };
+
+//# sourceMappingURL=useHoverTracking.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHoverTracking.js","names":["useHoverTracking","args","hoverRef","useRef","nodeAtRef","useLatest","nodeAtClientPoint","useEffect","enabled","c","canvasRef","onMove","onLeave"],"sources":["../../../src/features/chrome-caps/useHoverTracking.ts"],"sourcesContent":["/**\n * useHoverTracking — last-hovered NodeId for chrome-caps rules.\n *\n * Attaches a `pointermove` listener to the supplied canvas; on each move it\n * runs the supplied `nodeAtClientPoint` and caches the resulting id on a ref.\n * Cleared on `pointerleave` (pointer left the canvas → nothing is hovered).\n *\n * Returns a stable getter — call once per frame from `buildChromeCtx`.\n *\n * No re-render: the ref updates silently, and the next render that\n * reads it picks up the fresh value. Chrome-caps rules are evaluated\n * during paint, so the hover state is always read fresh.\n */\n\nimport { useEffect, useRef, type RefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from '../../core/scene/types';\n\n/** Options for `useHoverTracking`. */\nexport interface UseHoverTrackingArgs {\n  canvasRef: RefObject<HTMLElement | null>;\n  /** Topmost id under a client point, or null. One lookup rather than a\n   *  client→world thunk beside a world-space picker: a screen-pixel pick\n   *  tolerance converts against the camera the point resolved to, and two\n   *  thunks are two chances to disagree about which view that is. */\n  nodeAtClientPoint: (clientX: number, clientY: number) => { id: NodeId } | null;\n  enabled?: boolean;\n}\n\n/** Track which node the pointer is over. Returns a getter rather than state,\n *  so per-frame code can read the current value without the hover re-rendering\n *  the component on every pointer move. */\nexport function useHoverTracking(args: UseHoverTrackingArgs): () => NodeId | null {\n  const { canvasRef, nodeAtClientPoint, enabled = true } = args;\n  const hoverRef = useRef<NodeId | null>(null);\n  const nodeAtRef = useLatest(nodeAtClientPoint);\n\n  useEffect(() => {\n    if (!enabled) return;\n    const c = canvasRef.current;\n    if (!c) return;\n    const onMove = (e: PointerEvent) => {\n      hoverRef.current = nodeAtRef.current(e.clientX, e.clientY)?.id ?? null;\n    };\n    const onLeave = () => { hoverRef.current = null; };\n    c.addEventListener('pointermove', onMove);\n    c.addEventListener('pointerleave', onLeave);\n    return () => {\n      c.removeEventListener('pointermove', onMove);\n      c.removeEventListener('pointerleave', onLeave);\n    };\n  }, [canvasRef, enabled, nodeAtRef]);\n\n  return () => hoverRef.current;\n}\n"],"mappings":";;;AAgCA,SAAgBA,EAAiB,GAAiD;CAChF,IAAM,EAAE,cAAW,sBAAmB,aAAU,OAASC,GACnDC,IAAWC,EAAsB,IAAI,GACrCC,IAAYC,EAAUC,CAAiB;CAkB7C,OAhBAC,QAAgB;EACd,IAAI,CAACC,GAAS;EACd,IAAMC,IAAIC,EAAU;EACpB,IAAI,CAACD,GAAG;EACR,IAAME,KAAU,MAAoB;GAClC,EAAS,UAAUP,EAAU,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM;EACpE,GACMQ,UAAgB;GAAE,EAAS,UAAU;EAAM;EAGjD,OAFAH,EAAE,iBAAiB,eAAeE,CAAM,GACxCF,EAAE,iBAAiB,gBAAgBG,CAAO,SAC7B;GAEX,AADAH,EAAE,oBAAoB,eAAeE,CAAM,GAC3CF,EAAE,oBAAoB,gBAAgBG,CAAO;EAC/C;CACF,GAAG;EAACF;EAAWF;EAASJ;CAAS,CAAC,SAErBF,EAAS;AACxB"}

package/dist/features/cursor/paintedCursorLayer.js

@@ -0,0 +1,60 @@
+import { pathFromD as e } from "@weasel-js/geom";
+import { GLYPHS as t, chromeLineWidthScale as n, cursorPaintMatrix as r, cursorPaintOps as i, cursorWorldSize as a } from "@weasel-js/cursor";
+//#region src/features/cursor/paintedCursorLayer.ts
+var o = "painted-cursor", s = /* @__PURE__ */ new Map();
+function c(t) {
+	let n = s.get(t);
+	return n === void 0 && (n = e(t), s.set(t, n)), n;
+}
+function l(e) {
+	return {
+		kind: "path",
+		path: c(e.d),
+		...e.fill === void 0 ? {} : { fill: { color: e.fill } },
+		...e.stroke === void 0 ? {} : { stroke: {
+			paint: { color: e.stroke.color },
+			width: e.stroke.width,
+			cap: "round",
+			join: "round"
+		} }
+	};
+}
+function u(e) {
+	return {
+		id: o,
+		label: "Painted cursor",
+		space: "screen",
+		draw: (o, s) => {
+			let c = e.current();
+			if (!c) return [];
+			let { cursor: u, at: d } = c, f = t[u.glyph];
+			if (!f) return [];
+			let p = (s.scale.x + s.scale.y) / 2, m = u.worldRadius !== void 0, h = m ? a(f, u.worldRadius, p) : u.size ?? 24;
+			if (!(h > 0) || !Number.isFinite(h)) return [];
+			let g = i(f, m ? { lineWidthScale: n(f, h) } : {}), [_, v, y, b, x, S] = r(f, {
+				size: h,
+				angle: u.angle,
+				at: d
+			});
+			return [{
+				kind: "group",
+				transform: new Float32Array([
+					_,
+					v,
+					0,
+					y,
+					b,
+					0,
+					x,
+					S,
+					1
+				]),
+				children: g.map(l)
+			}];
+		}
+	};
+}
+//#endregion
+export { o as PAINTED_CURSOR_LAYER_ID, u as createPaintedCursorLayer };
+
+//# sourceMappingURL=paintedCursorLayer.js.map

package/dist/features/cursor/paintedCursorLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintedCursorLayer.js","names":["PAINTED_CURSOR_LAYER_ID","pathCache","pathFor","p","d","pathFromD","commandFor","op","createPaintedCursorLayer","frame","state","glyph","GLYPHS","cursor","scale","view","worldSized","size","cursorWorldSize","ops","cursorPaintOps","chromeLineWidthScale","a","b","c","e","f","cursorPaintMatrix"],"sources":["../../../src/features/cursor/paintedCursorLayer.ts"],"sourcesContent":["/**\n * The painted tier: draws a cursor glyph into the scene when it is too big,\n * or too tied to the view, to be a CSS `url()` cursor.\n *\n * A layer rather than something each tool draws in its own overlay, because\n * the alternative is every tool re-wiring the same thing. Riding the layer\n * system also means anything that reaches the cursor pipeline through a layer\n * claim — a HUD widget's `cursorAt` — gets the painted tier without knowing\n * this exists.\n *\n * Screen-space: the glyph is chrome at the pointer, not content in the\n * document, so it must not pan or zoom with the camera. What *does* track the\n * camera is a world-sized glyph's size, and `view.scale` is read for that.\n */\n\nimport { GLYPHS } from '@weasel-js/cursor';\nimport {\n  chromeLineWidthScale,\n  cursorPaintMatrix,\n  cursorPaintOps,\n  cursorWorldSize,\n} from '@weasel-js/cursor';\nimport type { CursorPaintOp } from '@weasel-js/cursor';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { pathFromD, type Path } from '@weasel-js/geom';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\n\n/** Layer id, so a consumer can order or hide it like any other. */\nexport const PAINTED_CURSOR_LAYER_ID = 'painted-cursor';\n\n/**\n * `d` strings are fixed by the glyph set, so the parse is done once per glyph\n * member for the life of the process. Handing the renderer the same `Path`\n * object every frame also lets its own mesh cache hit.\n */\nconst pathCache = new Map<string, Path>();\nfunction pathFor(d: string): Path {\n  let p = pathCache.get(d);\n  if (p === undefined) {\n    p = pathFromD(d);\n    pathCache.set(d, p);\n  }\n  return p;\n}\n\nfunction commandFor(op: CursorPaintOp): PathDrawCommand {\n  return {\n    kind: 'path',\n    path: pathFor(op.d),\n    ...(op.fill !== undefined ? { fill: { color: op.fill } } : {}),\n    ...(op.stroke !== undefined\n      ? {\n          stroke: {\n            paint: { color: op.stroke.color },\n            width: op.stroke.width,\n            cap: 'round' as const,\n            join: 'round' as const,\n          },\n        }\n      : {}),\n  };\n}\n\n/**\n * A screen-space layer that draws the glyph `state` currently holds at the pointer,\n * or nothing when it holds none. `<Canvas>` mounts one over its own state already.\n */\nexport function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown> {\n  return {\n    id: PAINTED_CURSOR_LAYER_ID,\n    label: 'Painted cursor',\n    space: 'screen',\n    draw: (_data, view) => {\n      const frame = state.current();\n      if (!frame) return [];\n      const { cursor, at } = frame;\n      const glyph = GLYPHS[cursor.glyph];\n      if (!glyph) return [];\n\n      // A world-sized glyph is measured against the live camera, and holds its\n      // line weight in CSS px while its geometry grows — a ring at a 400px\n      // radius drawn with scaled weight is a filled blob, not a cursor.\n      // Radial, so a single radius needs one scale factor; average the axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const worldSized = cursor.worldRadius !== undefined;\n      const size = worldSized\n        ? cursorWorldSize(glyph, cursor.worldRadius as number, scale)\n        : (cursor.size ?? 24);\n      if (!(size > 0) || !Number.isFinite(size)) return [];\n\n      const ops = cursorPaintOps(\n        glyph,\n        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {},\n      );\n      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {\n        size,\n        angle: cursor.angle,\n        at,\n      });\n      // Column-major, the layout `Mat3` documents.\n      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);\n      const children: DrawCommand[] = ops.map(commandFor);\n      return [{ kind: 'group', transform, children }];\n    },\n  };\n}\n"],"mappings":";;;AA6BA,IAAaA,IAA0B,kBAOjCC,oBAAY,IAAI,IAAkB;AACxC,SAASC,EAAQ,GAAiB;CAChC,IAAIC,IAAIF,EAAU,IAAIG,CAAC;CAKvB,OAJID,MAAM,KAAA,MACR,IAAIE,EAAUD,CAAC,GACfH,EAAU,IAAIG,GAAGD,CAAC,IAEbA;AACT;AAEA,SAASG,EAAW,GAAoC;CACtD,OAAO;EACL,MAAM;EACN,MAAMJ,EAAQK,EAAG,CAAC;EAClB,GAAIA,EAAG,SAAS,KAAA,IAA2C,CAAC,IAAhC,EAAE,MAAM,EAAE,OAAOA,EAAG,KAAK,EAAE;EACvD,GAAIA,EAAG,WAAW,KAAA,IASd,CAAC,IARD,EACE,QAAQ;GACN,OAAO,EAAE,OAAOA,EAAG,OAAO,MAAM;GAChC,OAAOA,EAAG,OAAO;GACjB,KAAK;GACL,MAAM;EACR,EACF;CAEN;AACF;AAMA,SAAgBC,EAAyB,GAAiD;CACxF,OAAO;EACL,IAAIR;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,MAAS;GACrB,IAAMS,IAAQC,EAAM,QAAQ;GAC5B,IAAI,CAACD,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,WAAQ,UAAOA,GACjBE,IAAQC,EAAOC,EAAO;GAC5B,IAAI,CAACF,GAAO,OAAO,CAAC;GAMpB,IAAMG,KAASC,EAAK,MAAM,IAAIA,EAAK,MAAM,KAAK,GACxCC,IAAaH,EAAO,gBAAgB,KAAA,GACpCI,IAAOD,IACTE,EAAgBP,GAAOE,EAAO,aAAuBC,CAAK,IACzDD,EAAO,QAAQ;GACpB,IAAI,EAAEI,IAAO,MAAM,CAAC,OAAO,SAASA,CAAI,GAAG,OAAO,CAAC;GAEnD,IAAME,IAAMC,EACVT,GACAK,IAAa,EAAE,gBAAgBK,EAAqBV,GAAOM,CAAI,EAAE,IAAI,CAAC,CACxE,GACM,CAACK,GAAGC,GAAGC,GAAGpB,GAAGqB,GAAGC,KAAKC,EAAkBhB,GAAO;IAClD;IACA,OAAOE,EAAO;IACd;GACF,CAAC;GAID,OAAO,CAAC;IAAE,MAAM;IAAS,WAAA,IAFH,aAAa;KAACS;KAAGC;KAAG;KAAGC;KAAGpB;KAAG;KAAGqB;KAAGC;KAAG;IAAC,CAEpC;IAAW,UADJP,EAAI,IAAIb,CACJ;GAAS,CAAC;EAChD;CACF;AACF"}

package/dist/features/focus/gateLayer.js

@@ -0,0 +1,14 @@
+import { subscribeToSources as e } from "../../core/layers/render.js";
+//#region src/features/focus/gateLayer.ts
+function t(t) {
+	let { layer: n, visible: r } = t, i = {
+		id: n.id,
+		label: n.label,
+		draw: (e, t, i) => r() ? n.draw(e, t, i) : []
+	};
+	return n.defaultVisible !== void 0 && (i.defaultVisible = n.defaultVisible), n.alwaysOn !== void 0 && (i.alwaysOn = n.alwaysOn), n.space !== void 0 && (i.space = n.space), n.subscribe && (i.subscribe = e([n])), i;
+}
+//#endregion
+export { t as gateLayer };
+
+//# sourceMappingURL=gateLayer.js.map

package/dist/features/focus/gateLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateLayer.js","names":["gateLayer","opts","wrapped","layer","visible","data","view","dims","subscribeToSources"],"sources":["../../../src/features/focus/gateLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` wrapper that conditionally emits draw commands based on a\n * predicate. Most common use: hide selection-overlay handles when the\n * canvas isn't focused.\n *\n * The predicate is a getter (`() => boolean`), not a static value, because\n * RenderLayers are constructed once but their `draw` runs every frame —\n * a static value would lock in whatever the predicate returned at\n * construction time.\n */\nimport { subscribeToSources, type RenderLayer } from 'core/layers/render';\n\n/** Options for `gateLayer`. */\nexport interface GateLayerOptions<TData> {\n  /** The wrapped layer. Its `id`, `label`, `defaultVisible`, `alwaysOn`,\n   *  `space` flow through unchanged. */\n  layer: RenderLayer<TData>;\n  /** Returns `true` to render the layer this frame, `false` to skip. */\n  visible: () => boolean;\n}\n\n/** Wrap a render layer so it only draws while `visible()` is true. The\n *  predicate is consulted per frame, which is how chrome follows canvas focus\n *  without the layer knowing anything about focus. */\nexport function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData> {\n  const { layer, visible } = opts;\n  const wrapped: RenderLayer<TData> = {\n    id: layer.id,\n    label: layer.label,\n    draw: (data, view, dims) => (visible() ? layer.draw(data, view, dims) : []),\n  };\n  if (layer.defaultVisible !== undefined) wrapped.defaultVisible = layer.defaultVisible;\n  if (layer.alwaysOn !== undefined) wrapped.alwaysOn = layer.alwaysOn;\n  if (layer.space !== undefined) wrapped.space = layer.space;\n  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);\n  return wrapped;\n}\n"],"mappings":";;AAwBA,SAAgBA,EAAiB,GAAmD;CAClF,IAAM,EAAE,UAAO,eAAYC,GACrBC,IAA8B;EAClC,IAAIC,EAAM;EACV,OAAOA,EAAM;EACb,OAAO,GAAM,GAAM,MAAUC,EAAQ,IAAID,EAAM,KAAKE,GAAMC,GAAMC,CAAI,IAAI,CAAC;CAC3E;CAKA,OAJIJ,EAAM,mBAAmB,KAAA,MAAW,EAAQ,iBAAiBA,EAAM,iBACnEA,EAAM,aAAa,KAAA,MAAW,EAAQ,WAAWA,EAAM,WACvDA,EAAM,UAAU,KAAA,MAAW,EAAQ,QAAQA,EAAM,QACjDA,EAAM,cAAW,EAAQ,YAAYK,EAAmB,CAACL,CAAK,CAAC,IAC5DD;AACT"}

package/dist/features/focus/useCanvasFocus.js

@@ -0,0 +1,29 @@
+import { useCallback as e, useMemo as t, useRef as n, useState as r } from "react";
+//#region src/features/focus/useCanvasFocus.ts
+function i(i = {}) {
+	let { initial: a = !1, tabIndex: o = 0 } = i, [s, c] = r(a), l = n(a), u = e(() => {
+		l.current || (l.current = !0, c(!0));
+	}, []), d = e(() => {
+		l.current && (l.current = !1, c(!1));
+	}, []), f = e(() => l.current, []), p = e((e) => {
+		l.current !== e && (l.current = e, c(e));
+	}, []);
+	return {
+		focused: s,
+		focusProps: t(() => ({
+			tabIndex: o,
+			onFocus: u,
+			onBlur: d
+		}), [
+			o,
+			u,
+			d
+		]),
+		getFocused: f,
+		setFocused: p
+	};
+}
+//#endregion
+export { i as useCanvasFocus };
+
+//# sourceMappingURL=useCanvasFocus.js.map

package/dist/features/focus/useCanvasFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasFocus.js","names":["useCanvasFocus","options","focused","setFocusedState","useState","initial","focusedRef","useRef","onFocus","useCallback","onBlur","getFocused","setFocused","next","useMemo","tabIndex"],"sources":["../../../src/features/focus/useCanvasFocus.ts"],"sourcesContent":["/**\n * Track DOM focus on a canvas (or any focusable host element). Returns the\n * live `focused` boolean, props to spread onto the focusable element, and a\n * stable `getFocused()` getter for use inside per-frame closures (notably\n * `RenderLayer.draw`, which is constructed once but called every frame).\n *\n * Pure feature module — no Canvas/SceneCanvas integration. Consumers compose\n * the hook + `gateLayer` (or their own gate) to hide affordances when blurred.\n */\nimport { useCallback, useMemo, useRef, useState } from 'react';\n\n/** Options for `useCanvasFocus`. */\nexport interface UseCanvasFocusOptions {\n  /** Initial focus state. Default `false` — handles hidden until first click. */\n  initial?: boolean;\n  /** `tabIndex` to set on the focusable element. Default `0` (focusable in\n   *  document tab order). Set to `-1` for programmatic-only focus. */\n  tabIndex?: number;\n}\n\n/** What `useCanvasFocus` hands back: the focus state, the props that\n *  maintain it, and a getter for reading it from per-frame code. */\nexport interface CanvasFocusReturn {\n  /** Live boolean — true when the element has DOM focus. Triggers re-renders\n   *  when the focus state changes (set via React state). */\n  focused: boolean;\n  /** Spread onto the focusable element (e.g. the canvas). Includes\n   *  `tabIndex`, `onFocus`, `onBlur`. */\n  focusProps: {\n    tabIndex: number;\n    onFocus: () => void;\n    onBlur: () => void;\n  };\n  /** Stable getter for the live focused state. Use inside per-frame closures\n   *  like `RenderLayer.draw`, where the layer is constructed once and\n   *  reading `focused` directly would capture the value at construction\n   *  time. The getter always returns the current value. */\n  getFocused: () => boolean;\n  /** Imperative focus / blur. Useful for tests and programmatic control. */\n  setFocused: (next: boolean) => void;\n}\n\n/** Track DOM focus on the canvas, so chrome that should only show while the\n *  canvas is focused can be gated on it. */\nexport function useCanvasFocus(options: UseCanvasFocusOptions = {}): CanvasFocusReturn {\n  const { initial = false, tabIndex = 0 } = options;\n  const [focused, setFocusedState] = useState<boolean>(initial);\n  // Every state change goes through a handler below that writes this first.\n  const focusedRef = useRef<boolean>(initial);\n\n  const onFocus = useCallback(() => {\n    if (!focusedRef.current) {\n      focusedRef.current = true;\n      setFocusedState(true);\n    }\n  }, []);\n  const onBlur = useCallback(() => {\n    if (focusedRef.current) {\n      focusedRef.current = false;\n      setFocusedState(false);\n    }\n  }, []);\n  const getFocused = useCallback(() => focusedRef.current, []);\n  const setFocused = useCallback((next: boolean) => {\n    if (focusedRef.current === next) return;\n    focusedRef.current = next;\n    setFocusedState(next);\n  }, []);\n\n  // Stable until tabIndex changes, so it can be spread onto memoized elements\n  // without retriggering downstream effects.\n  const focusProps = useMemo(() => ({ tabIndex, onFocus, onBlur }), [tabIndex, onFocus, onBlur]);\n\n  return {\n    focused,\n    focusProps,\n    getFocused,\n    setFocused,\n  };\n}\n"],"mappings":";;AA4CA,SAAgBA,EAAe,IAAiC,CAAC,GAAsB;CACrF,IAAM,EAAE,aAAU,IAAO,cAAW,MAAMC,GACpC,CAACC,GAASC,KAAmBC,EAAkBC,CAAO,GAEtDC,IAAaC,EAAgBF,CAAO,GAEpCG,IAAUC,QAAkB;EAChC,AAAKH,EAAW,YACd,EAAW,UAAU,IACrBH,EAAgB,EAAI;CAExB,GAAG,CAAC,CAAC,GACCO,IAASD,QAAkB;EAC/B,AAAIH,EAAW,YACb,EAAW,UAAU,IACrBH,EAAgB,EAAK;CAEzB,GAAG,CAAC,CAAC,GACCQ,IAAaF,QAAkBH,EAAW,SAAS,CAAC,CAAC,GACrDM,IAAaH,GAAa,MAAkB;EAChD,AAAIH,EAAW,YAAYO,MAC3B,EAAW,UAAUA,GACrBV,EAAgBU,CAAI;CACtB,GAAG,CAAC,CAAC;CAML,OAAO;EACL;EACA,YAJiBC,SAAe;GAAE;GAAU;GAAS;EAAO,IAAI;GAACC;GAAUP;GAASE;EAAM,CAI1F;EACA;EACA;CACF;AACF"}

package/dist/features/groups/children.js

@@ -0,0 +1,23 @@
+//#region src/features/groups/children.ts
+function e(e) {
+	return {
+		id: e.id ?? "children",
+		label: e.label ?? "Children",
+		defaultVisible: e.defaultVisible,
+		alwaysOn: e.alwaysOn,
+		draw: (t, n) => {
+			let r = e.adapter.getChildren;
+			if (!r) return [];
+			let i = r(typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null), a = [];
+			for (let r of i) {
+				let i = e.drawChild(r, t, n);
+				for (let e of i) a.push(e);
+			}
+			return a;
+		}
+	};
+}
+//#endregion
+export { e as createChildrenLayer };
+
+//# sourceMappingURL=children.js.map

package/dist/features/groups/children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"children.js","names":["createChildrenLayer","opts","getChildren","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/features/groups/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer — replaces the manual `for (id of getChildren()) ...`\n * pattern with a `RenderLayer` factory that consumes an `OrderedAdapter`.\n *\n * Children are drawn in z-order (forward iteration: index 0 = bottom). The\n * caller supplies a `drawChild` callback that emits `DrawCommand[]` for one\n * object; this layer is the boilerplate-free way to plug a scene graph's\n * z-order into the layer composition system.\n *\n * If the adapter doesn't implement `getChildren` (it's optional on\n * `OrderedAdapter`), the layer is a silent no-op — adopt z-order incrementally\n * without breaking existing layers.\n */\n\nimport type { DrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const getChildren = opts.adapter.getChildren;\n      if (!getChildren) return [];\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAwCA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAcD,EAAK,QAAQ;GACjC,IAAI,CAACC,GAAa,OAAO,CAAC;GAK1B,IAAMC,IAAMD,EAHV,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,IACO,GACxBG,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}

package/dist/features/groups/composePose.js

@@ -0,0 +1,67 @@
+import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, frameAtOrAbove as n, rebaseLocalPose as r } from "../../core/scene/composeFrame.js";
+//#region src/features/groups/composePose.ts
+function i(e, t) {
+	return {
+		...t,
+		x: e.x + t.x,
+		y: e.y + t.y
+	};
+}
+function a(e, t, n) {
+	return {
+		...e,
+		x: e.x + t,
+		y: e.y + n
+	};
+}
+function o(e, t) {
+	return {
+		...t,
+		x: t.x - e.x,
+		y: t.y - e.y
+	};
+}
+function s(e, t, n, r, i) {
+	let a = Math.cos(n), o = Math.sin(n);
+	return [e + (r - e) * a - (i - t) * o, t + (r - e) * o + (i - t) * a];
+}
+function c(e, t) {
+	let n = e.rotation ?? 0, [r, i] = s(e.x + e.width / 2, e.y + e.height / 2, n, e.x + t.x + t.width / 2, e.y + t.y + t.height / 2);
+	return {
+		...t,
+		x: r - t.width / 2,
+		y: i - t.height / 2,
+		rotation: (t.rotation ?? 0) + n
+	};
+}
+function l(e, t) {
+	let n = e.rotation ?? 0, [r, i] = s(e.x + e.width / 2, e.y + e.height / 2, -n, t.x + t.width / 2, t.y + t.height / 2);
+	return {
+		...t,
+		x: r - e.x - t.width / 2,
+		y: i - e.y - t.height / 2,
+		rotation: (t.rotation ?? 0) - n
+	};
+}
+var u = {
+	compose: i,
+	decompose: o,
+	closure: "translation"
+}, d = {
+	compose: c,
+	decompose: l,
+	closure: "rigid"
+};
+function f(e, n) {
+	return (r) => {
+		try {
+			return t(e, r, n);
+		} catch {
+			return null;
+		}
+	};
+}
+//#endregion
+export { e as IDENTITY_POSE_COMPOSITION, u as RECT_POSE_COMPOSITION, d as RIGID_POSE_COMPOSITION, i as composeRectPose, c as composeRigidPose, t as composeWorldPose, o as decomposeRectPose, l as decomposeRigidPose, n as frameAtOrAbove, r as rebaseLocalPose, a as translateRectPose, f as worldPoseLookup };
+
+//# sourceMappingURL=composePose.js.map