@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/meshPaint/register.js

@@ -1,7 +0,0 @@
-import { registerPaintKind as e } from "../../core/paintKinds.js";
-import { meshGradientKind as t } from "./meshPaint.js";
-//#region src/features/meshPaint/register.ts
-e(t);
-//#endregion
-
-//# sourceMappingURL=register.js.map

package/dist/features/meshPaint/register.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.js","names":["registerPaintKind","meshGradientKind"],"sources":["../../../src/features/meshPaint/register.ts"],"sourcesContent":["/** Registers the mesh-gradient kind at import; `@weasel-js/core/mesh` imports it for effect. */\nimport { registerPaintKind } from '../../core/paintKinds';\nimport { meshGradientKind } from './meshPaint';\n\nregisterPaintKind(meshGradientKind);\n"],"mappings":";;;AAIAA,EAAkBC,CAAgB"}

package/dist/features/meshPaint/surface.js

@@ -1,110 +0,0 @@
-//#region src/features/meshPaint/surface.ts
-function e(e, t) {
-	return e.points[(t & 3) * 3];
-}
-function t(e) {
-	return e.points.length >= 16;
-}
-function n(e) {
-	return e.points.length === 12 || e.points.length === 16;
-}
-function r(e, t, n, r, i) {
-	let a = 1 - i, o = a * a * a, s = 3 * a * a * i, c = 3 * a * i * i, l = i * i * i;
-	return {
-		x: o * e.x + s * t.x + c * n.x + l * r.x,
-		y: o * e.y + s * t.y + c * n.y + l * r.y
-	};
-}
-function i(e, t) {
-	let n = e.points, r = (t & 3) * 3;
-	return [
-		n[r],
-		n[r + 1],
-		n[r + 2],
-		n[(t + 1 & 3) * 3]
-	];
-}
-function a(e, n, r) {
-	return t(e) ? l(e, n, r) : o(e, n, r);
-}
-function o(t, n, a) {
-	let [o, s, c, l] = i(t, 0), [u, d, f, p] = i(t, 1), [m, h, g, _] = i(t, 2), [v, y, b, x] = i(t, 3), S = r(o, s, c, l, n), C = r(m, h, g, _, 1 - n), w = r(u, d, f, p, a), T = r(v, y, b, x, 1 - a), E = e(t, 0), D = e(t, 1), O = e(t, 2), k = e(t, 3), A = (e, t) => (1 - a) * e + a * t, j = (e, t) => (1 - n) * e + n * t, M = (e, t, r, i) => (1 - n) * (1 - a) * e + n * (1 - a) * t + n * a * r + (1 - n) * a * i;
-	return {
-		x: A(S.x, C.x) + j(T.x, w.x) - M(E.x, D.x, O.x, k.x),
-		y: A(S.y, C.y) + j(T.y, w.y) - M(E.y, D.y, O.y, k.y)
-	};
-}
-function s(e) {
-	let t = e.points;
-	return [
-		[
-			t[0],
-			t[11],
-			t[10],
-			t[9]
-		],
-		[
-			t[1],
-			t[12],
-			t[13],
-			t[8]
-		],
-		[
-			t[2],
-			t[15],
-			t[14],
-			t[7]
-		],
-		[
-			t[3],
-			t[4],
-			t[5],
-			t[6]
-		]
-	];
-}
-var c = (e) => {
-	let t = 1 - e;
-	return [
-		t * t * t,
-		3 * t * t * e,
-		3 * t * e * e,
-		e * e * e
-	];
-};
-function l(e, t, n) {
-	let r = s(e), i = c(t), a = c(n), o = 0, l = 0;
-	for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) {
-		let n = i[e] * a[t];
-		o += n * r[e][t].x, l += n * r[e][t].y;
-	}
-	return {
-		x: o,
-		y: l
-	};
-}
-function u(e, t) {
-	return [
-		(1 - e) * (1 - t),
-		e * (1 - t),
-		e * t,
-		(1 - e) * t
-	];
-}
-function d(e, t = 8) {
-	let n = Infinity, r = Infinity, i = -Infinity, o = -Infinity;
-	for (let s = 0; s <= t; s++) for (let c = 0; c <= t; c++) {
-		let l = a(e, s / t, c / t);
-		l.x < n && (n = l.x), l.y < r && (r = l.y), l.x > i && (i = l.x), l.y > o && (o = l.y);
-	}
-	return {
-		x: n,
-		y: r,
-		width: i - n,
-		height: o - r
-	};
-}
-//#endregion
-export { u as cornerWeights, a as evalPatch, t as isTensorPatch, n as isValidPatch, d as patchBounds, e as patchCorner };
-
-//# sourceMappingURL=surface.js.map

package/dist/features/meshPaint/surface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"surface.js","names":["patchCorner","patch","i","isTensorPatch","isValidPatch","bezier","s","t","a","b","d","p0","p1","p2","p3","edge","p","evalPatch","evalTensor","u","v","evalCoons","b0","b1","b2","b3","r0","r1","r2","r3","t0","t1","t2","t3","l0","l1","l2","l3","bottom","top","right","left","c0","c1","c2","c3","ruledU","ruledV","corner","k0","k1","k2","k3","tensorNet","BERNSTEIN","net","bu","bv","x","y","j","w","cornerWeights","patchBounds","minX","minY","maxX","maxY","steps"],"sources":["../../../src/features/meshPaint/surface.ts"],"sourcesContent":["/**\n * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as\n * pure geometry.\n *\n * A patch is a curved quadrilateral: four cubic Bézier edges and a color at\n * each corner. The interior is what the edges imply — a Coons patch reads it\n * off the boundary alone; a tensor patch adds four interior control points\n * that pull it around. Both evaluate at a `(u, v)` in the unit square, which\n * is what lets the renderer subdivide a patch into as many triangles as it\n * wants without the patch knowing.\n *\n * Nothing here touches GL, a color string, or a scene. `evalPatch` is the\n * whole contract.\n */\n\n/** A point in the patch's own space. */\nexport interface MeshPoint {\n  x: number;\n  y: number;\n}\n\n/**\n * One patch.\n *\n * `points` walks the boundary: corner 0, the two control points of the edge\n * leaving it, corner 1, its two, and so on — twelve points, ending with the\n * two controls that return to corner 0. A tensor patch appends its four\n * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the\n * bicubic control net, which is PDF's own order.\n *\n * Twelve points is a Coons patch and sixteen is a tensor patch; there is no\n * flag, because the count already says which it is.\n *\n * `colors` are the corner colors in the same walk order, as whatever color\n * form the caller resolves — the renderer hands premultiplied RGBA in, the\n * serializer hands CSS strings.\n */\nexport interface MeshPatch<TColor = string> {\n  points: readonly MeshPoint[];\n  colors: readonly [TColor, TColor, TColor, TColor];\n}\n\n/** Corner `i` of the boundary walk. */\nexport function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint {\n  return patch.points[(i & 3) * 3];\n}\n\n/** `true` when the patch carries the four interior points a tensor patch adds. */\nexport function isTensorPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length >= 16;\n}\n\n/** A patch is twelve boundary points, or sixteen with the interior. Anything\n *  else cannot be evaluated, and saying so here beats painting nonsense. */\nexport function isValidPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length === 12 || patch.points.length === 16;\n}\n\nfunction bezier(p0: MeshPoint, p1: MeshPoint, p2: MeshPoint, p3: MeshPoint, t: number): MeshPoint {\n  const s = 1 - t;\n  const a = s * s * s;\n  const b = 3 * s * s * t;\n  const c = 3 * s * t * t;\n  const d = t * t * t;\n  return {\n    x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,\n    y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,\n  };\n}\n\n/** The edge leaving corner `i`, as its four control points. */\nfunction edge(patch: MeshPatch<unknown>, i: number): [MeshPoint, MeshPoint, MeshPoint, MeshPoint] {\n  const p = patch.points;\n  const a = (i & 3) * 3;\n  return [p[a], p[a + 1], p[a + 2], p[((i + 1) & 3) * 3]];\n}\n\n/**\n * The patch surface at `(u, v)`, both in `0..1`.\n *\n * `u` runs along the edge leaving corner 0 and `v` along the edge leaving\n * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and\n * `(0,1)` corner 3 — the same walk `colors` is in.\n */\nexport function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  return isTensorPatch(patch) ? evalTensor(patch, u, v) : evalCoons(patch, u, v);\n}\n\nfunction evalCoons(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const [b0, b1, b2, b3] = edge(patch, 0);        // corner 0 → 1, along u at v=0\n  const [r0, r1, r2, r3] = edge(patch, 1);        // corner 1 → 2, along v at u=1\n  const [t0, t1, t2, t3] = edge(patch, 2);        // corner 2 → 3, along u at v=1\n  const [l0, l1, l2, l3] = edge(patch, 3);        // corner 3 → 0, along v at u=0\n\n  const bottom = bezier(b0, b1, b2, b3, u);\n  const top = bezier(t0, t1, t2, t3, 1 - u);      // walks 2 → 3, so reverse it\n  const right = bezier(r0, r1, r2, r3, v);\n  const left = bezier(l0, l1, l2, l3, 1 - v);     // walks 3 → 0, so reverse it\n\n  const c0 = patchCorner(patch, 0);\n  const c1 = patchCorner(patch, 1);\n  const c2 = patchCorner(patch, 2);\n  const c3 = patchCorner(patch, 3);\n\n  // The Coons construction: the two ruled surfaces between opposite edges,\n  // minus the bilinear surface through the corners they both already carry.\n  const ruledU = (a: number, b: number): number => (1 - v) * a + v * b;\n  const ruledV = (a: number, b: number): number => (1 - u) * a + u * b;\n  const corner = (k0: number, k1: number, k2: number, k3: number): number =>\n    (1 - u) * (1 - v) * k0 + u * (1 - v) * k1 + u * v * k2 + (1 - u) * v * k3;\n\n  return {\n    x: ruledU(bottom.x, top.x) + ruledV(left.x, right.x)\n      - corner(c0.x, c1.x, c2.x, c3.x),\n    y: ruledU(bottom.y, top.y) + ruledV(left.y, right.y)\n      - corner(c0.y, c1.y, c2.y, c3.y),\n  };\n}\n\n/** The bicubic control net a tensor patch's sixteen points make, as\n *  `net[i][j]` with `i` along `u` and `j` along `v`. */\nfunction tensorNet(patch: MeshPatch<unknown>): MeshPoint[][] {\n  const p = patch.points;\n  // Boundary, read off the same walk; interior from the four trailing points.\n  return [\n    [p[0], p[11], p[10], p[9]],\n    [p[1], p[12], p[13], p[8]],\n    [p[2], p[15], p[14], p[7]],\n    [p[3], p[4], p[5], p[6]],\n  ];\n}\n\nconst BERNSTEIN = (t: number): [number, number, number, number] => {\n  const s = 1 - t;\n  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];\n};\n\nfunction evalTensor(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const net = tensorNet(patch);\n  const bu = BERNSTEIN(u);\n  const bv = BERNSTEIN(v);\n  let x = 0;\n  let y = 0;\n  for (let i = 0; i < 4; i++) {\n    for (let j = 0; j < 4; j++) {\n      const w = bu[i] * bv[j];\n      x += w * net[i][j].x;\n      y += w * net[i][j].y;\n    }\n  }\n  return { x, y };\n}\n\n/**\n * The four corner weights at `(u, v)` — bilinear, in the corner walk order.\n *\n * Color is separate from position on purpose: it interpolates in whatever\n * space the caller chose, which is not a thing the surface can do for it.\n */\nexport function cornerWeights(u: number, v: number): [number, number, number, number] {\n  return [(1 - u) * (1 - v), u * (1 - v), u * v, (1 - u) * v];\n}\n\n/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone\n *  bound a Bézier but not tightly, and a mesh paint is baked into a texture\n *  sized from this — a loose box wastes texels on every side. */\nexport function patchBounds(\n  patch: MeshPatch<unknown>, steps = 8,\n): { x: number; y: number; width: number; height: number } {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (let i = 0; i <= steps; i++) {\n    for (let j = 0; j <= steps; j++) {\n      const p = evalPatch(patch, i / steps, j / steps);\n      if (p.x < minX) minX = p.x;\n      if (p.y < minY) minY = p.y;\n      if (p.x > maxX) maxX = p.x;\n      if (p.y > maxY) maxY = p.y;\n    }\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":"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"}

package/dist/features/minimap/actions.js

@@ -1,53 +0,0 @@
-//#region src/features/minimap/actions.ts
-var e = "minimap.center", t = "minimap.pan";
-function n(e, t, n) {
-	let r = e.hostSize?.();
-	if (!r) return;
-	let i = e.get();
-	e.set({
-		x: t - r.width / (2 * i.scale.x),
-		y: n - r.height / (2 * i.scale.y),
-		scale: i.scale
-	});
-}
-function r(e) {
-	return e.rootView;
-}
-function i() {
-	return {
-		id: e,
-		label: "Minimap — center the view here",
-		requires: ["rootView"],
-		invoker: {
-			timing: "immediate",
-			run: (e, t) => {
-				let i = t, a = r(e);
-				a && i?.worldX !== void 0 && i.worldY !== void 0 && n(a, i.worldX, i.worldY);
-			}
-		}
-	};
-}
-function a() {
-	return {
-		id: t,
-		label: "Minimap — pan the view",
-		requires: ["rootView"],
-		invoker: {
-			timing: "ongoing",
-			start(e) {
-				let t = r(e.deps);
-				return t ? {
-					onMove: (e) => {
-						let r = e.drag?.current ?? e.world;
-						n(t, r.x, r.y);
-					},
-					onEnd: () => {}
-				} : {};
-			}
-		}
-	};
-}
-//#endregion
-export { e as MINIMAP_CENTER, t as MINIMAP_PAN, n as centerRootOn, i as minimapCenterAction, a as minimapPanAction };
-
-//# sourceMappingURL=actions.js.map

package/dist/features/minimap/actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.js","names":["MINIMAP_CENTER","MINIMAP_PAN","centerRootOn","size","root","v","x","y","rootOf","deps","minimapCenterAction","p","params","minimapPanAction","ctx","m"],"sources":["../../../src/features/minimap/actions.ts"],"sourcesContent":["/**\n * The minimap's input: press to recenter the main camera on a world point,\n * drag to keep it there. Both read `rootView` — never `view`, which inside the\n * minimap's own view answers the minimap's camera.\n */\nimport type { Action, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { ViewApi } from 'interactions/actions/depSchema';\n\n/** Action id for `minimapCenterAction`. */\nexport const MINIMAP_CENTER = 'minimap.center';\n/** Action id for `minimapPanAction`. */\nexport const MINIMAP_PAN = 'minimap.pan';\n\n/** Move `root` so world point (`x`, `y`) sits at the center of its host,\n *  keeping its scale. A no-op while the host is unmeasured. */\nexport function centerRootOn(root: ViewApi, x: number, y: number): void {\n  const size = root.hostSize?.();\n  if (!size) return;\n  const v = root.get();\n  root.set({\n    x: x - size.width / (2 * v.scale.x),\n    y: y - size.height / (2 * v.scale.y),\n    scale: v.scale,\n  });\n}\n\nfunction rootOf(deps: InvocationCtx['deps']): ViewApi | undefined {\n  return deps.rootView;\n}\n\n/** Recenter the main camera on the pressed world point. */\nexport function minimapCenterAction(): Action {\n  return {\n    id: MINIMAP_CENTER,\n    label: 'Minimap — center the view here',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const p = params as { worldX?: number; worldY?: number } | undefined;\n        const root = rootOf(deps);\n        if (!root || p?.worldX === undefined || p.worldY === undefined) return;\n        centerRootOn(root, p.worldX, p.worldY);\n      },\n    },\n  };\n}\n\n/** Keep the main camera centered on the pointer's world point while dragging.\n *  Pair it with `minimap.center` on `pointerDown`, which handles the press.\n *  A recenter lands the moment it is computed, so there is nothing to commit\n *  and a cancel ends where a release does. */\nexport function minimapPanAction(): Action {\n  return {\n    id: MINIMAP_PAN,\n    label: 'Minimap — pan the view',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx): OngoingHandle {\n        const root = rootOf(ctx.deps);\n        if (!root) return {};\n        // The press already centered (`minimap.center`); the move that crossed\n        // the drag threshold is pumped to `onMove` like every later one.\n        return {\n          onMove: (m) => {\n            const p = m.drag?.current ?? m.world;\n            centerRootOn(root, p.x, p.y);\n          },\n          onEnd: () => {},\n        };\n      },\n    },\n  };\n}\n"],"mappings":";AASA,IAAaA,IAAiB,kBAEjBC,IAAc;AAI3B,SAAgBC,EAAa,GAAe,GAAW,GAAiB;CACtE,IAAMC,IAAOC,EAAK,WAAW;CAC7B,IAAI,CAACD,GAAM;CACX,IAAME,IAAID,EAAK,IAAI;CACnB,EAAK,IAAI;EACP,GAAGE,IAAIH,EAAK,SAAS,IAAIE,EAAE,MAAM;EACjC,GAAGE,IAAIJ,EAAK,UAAU,IAAIE,EAAE,MAAM;EAClC,OAAOA,EAAE;CACX,CAAC;AACH;AAEA,SAASG,EAAO,GAAkD;CAChE,OAAOC,EAAK;AACd;AAGA,SAAgBC,IAA8B;CAC5C,OAAO;EACL,IAAIV;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMW,IAAIC,GACJR,IAAOI,EAAOC,CAAI;IACxB,AAAKL,KAAQO,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,KAAA,KACrDT,EAAaE,GAAMO,EAAE,QAAQA,EAAE,MAAM;GACvC;EACF;CACF;AACF;AAMA,SAAgBE,IAA2B;CACzC,OAAO;EACL,IAAIZ;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAmC;IACvC,IAAMG,IAAOI,EAAOM,EAAI,IAAI;IAI5B,OAHKV,IAGE;KACL,SAAS,MAAM;MACb,IAAMO,IAAII,EAAE,MAAM,WAAWA,EAAE;MAC/B,EAAaX,GAAMO,EAAE,GAAGA,EAAE,CAAC;KAC7B;KACA,aAAa,CAAC;IAChB,IATkB,CAAC;GAUrB;EACF;CACF;AACF"}

package/dist/features/minimap/createMinimapContribution.js

@@ -1,96 +0,0 @@
-import { AUTO_POSE_DESCRIPTOR as e } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { FALLBACK_ACCENT as t, accentColorOf as n } from "../../canvas/accentColor.js";
-import { MINIMAP_CENTER as r, MINIMAP_PAN as i, minimapCenterAction as a, minimapPanAction as o } from "./actions.js";
-import { createIndicatorLayer as s, createLinkedCursorLayer as c } from "./layers.js";
-import { FALLBACK_FIT_VIEW as l, computeFitView as u } from "../../canvas/minimapMath.js";
-//#region src/features/minimap/createMinimapContribution.ts
-function d(e, r) {
-	let i = null, a = t, o = (e) => e !== null && r.some((t) => t !== e.viewId);
-	return {
-		layer: c({
-			id: e,
-			pointer: () => i,
-			color: () => a,
-			views: r
-		}),
-		attach: (e, t) => {
-			let r = t.get("pointer");
-			if (!r) return () => {};
-			a = n(e.element), i = r.get();
-			let s = r.subscribe(() => {
-				let t = i;
-				i = r.get(), (o(t) || o(i)) && e.requestRedraw();
-			});
-			return () => {
-				s(), i = null, e.requestRedraw();
-			};
-		}
-	};
-}
-function f(e = {}) {
-	let t = e.id ?? "linked-cursor", n = d(t, e.views ?? [null]);
-	return {
-		id: t,
-		eligibility: { always: !0 },
-		overlay: n.layer,
-		attach: n.attach
-	};
-}
-var p = "#18181c";
-function m(t) {
-	let n = t.id ?? "minimap", c = t.fit ?? "scene", f = null, m = null, h = (n, r) => {
-		let i = f?.get("scene");
-		if (!i) return l;
-		let a = typeof t.rect == "function" ? t.rect(n, r) : t.rect, o = i.getVersion();
-		if (m && m.scene === i && m.version === o && m.w === a.w && m.h === a.h) return m.view;
-		let s = f?.get("poseDescriptor") ?? e, d = u(i, {
-			width: a.w,
-			height: a.h
-		}, c, s);
-		return m = {
-			scene: i,
-			version: o,
-			w: a.w,
-			h: a.h,
-			view: d
-		}, d;
-	}, g = d(`${n}.cursor`, [null, n]), _ = s({
-		viewId: n,
-		root: () => f?.get("rootView"),
-		...t.indicatorStyle ? { style: t.indicatorStyle } : {}
-	});
-	return {
-		id: n,
-		eligibility: { always: !0 },
-		views: [{
-			id: n,
-			bounds: t.rect,
-			view: h,
-			interactive: !0,
-			background: t.background ?? p,
-			...t.layers ? { layers: t.layers } : {}
-		}],
-		actions: [a(), o()],
-		bindings: [{
-			spec: { kind: "pointerDown" },
-			actionId: r,
-			opts: { views: [n] }
-		}, {
-			spec: { kind: "drag" },
-			actionId: i,
-			opts: { views: [n] }
-		}],
-		overlay: [_, g.layer],
-		attach: (e, t) => {
-			f = t;
-			let n = g.attach(e, t);
-			return e.requestRedraw(), () => {
-				n(), f = null, m = null;
-			};
-		}
-	};
-}
-//#endregion
-export { f as createLinkedCursorContribution, m as createMinimapContribution };
-
-//# sourceMappingURL=createMinimapContribution.js.map

package/dist/features/minimap/createMinimapContribution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMinimapContribution.js","names":["linkedCursor","pointer","color","FALLBACK_ACCENT","visible","p","ownViews","v","createLinkedCursorLayer","store","deps","accentColorOf","api","off","prev","createLinkedCursorContribution","id","opts","cursor","DEFAULT_BACKGROUND","createMinimapContribution","fit","cached","fitCamera","scene","FALLBACK_FIT_VIEW","r","outer","dims","version","descriptor","AUTO_POSE_DESCRIPTOR","view","computeFitView","indicator","createIndicatorLayer","minimapCenterAction","minimapPanAction","MINIMAP_CENTER","MINIMAP_PAN","reader","detachCursor"],"sources":["../../../src/features/minimap/createMinimapContribution.ts"],"sourcesContent":["/**\n * A minimap over a `<SceneCanvas>`, written as one `SurfaceContribution`: a\n * view through a fit camera, the pan that moves the main camera from inside\n * it, the visible-rect indicator, and a linked crosshair.\n */\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport type { CanvasExtensionApi } from '../../canvas/canvasExtension';\nimport type { ViewRect } from '../../canvas/CanvasView';\nimport type { ContributionDepReader, SurfaceContribution } from '../../canvas/surfaceContribution';\nimport {\n  computeFitView, FALLBACK_FIT_VIEW, type IndicatorStyle, type MinimapFit,\n} from '../../canvas/minimapMath';\nimport {\n  MINIMAP_CENTER, MINIMAP_PAN, minimapCenterAction, minimapPanAction,\n} from './actions';\nimport { createIndicatorLayer, createLinkedCursorLayer } from './layers';\nimport { accentColorOf, FALLBACK_ACCENT } from '../../canvas/accentColor';\n\n\n/**\n * The linked crosshair's live half: follows the pointer store, and asks the\n * surface to repaint whenever the crosshair shows, moves, or has just hidden.\n * `ownViews` are the view ids this surface paints; the crosshair shows in any\n * of them the pointer is not over.\n */\nfunction linkedCursor(id: string, ownViews: readonly (string | null)[]) {\n  let pointer: PointerWorldPos = null;\n  let color = FALLBACK_ACCENT;\n  const visible = (p: PointerWorldPos): boolean =>\n    p !== null && ownViews.some((v) => v !== p.viewId);\n  const layer = createLinkedCursorLayer({ id, pointer: () => pointer, color: () => color, views: ownViews });\n  const attach = (api: CanvasExtensionApi, deps: ContributionDepReader): (() => void) => {\n    const store = deps.get('pointer');\n    if (!store) return () => {};\n    color = accentColorOf(api.element);\n    pointer = store.get();\n    const off = store.subscribe(() => {\n      const prev = pointer;\n      pointer = store.get();\n      if (visible(prev) || visible(pointer)) api.requestRedraw();\n    });\n    return () => {\n      off();\n      pointer = null;\n      api.requestRedraw();\n    };\n  };\n  return { layer, attach };\n}\n\n/** Options for {@link createLinkedCursorContribution}. */\nexport interface LinkedCursorOptions {\n  /** Entry id. Default `'linked-cursor'`. */\n  id?: string;\n  /** Views on this surface the crosshair may paint in. Default `[null]`, the\n   *  surface's own camera — the main canvas beside a detached minimap. */\n  views?: readonly (string | null)[];\n}\n\n/**\n * The linked crosshair alone: this surface paints the pointer's position\n * whenever the pointer is over some other view — another surface under the\n * same `<PointerContextProvider>`, such as a detached `<MinimapCanvas>`.\n *\n * A surface carrying `createMinimapContribution` already has one, in both its\n * views; this is for a surface without.\n */\nexport function createLinkedCursorContribution(opts: LinkedCursorOptions = {}): SurfaceContribution {\n  const id = opts.id ?? 'linked-cursor';\n  const cursor = linkedCursor(id, opts.views ?? [null]);\n  return { id, eligibility: { always: true }, overlay: cursor.layer, attach: cursor.attach };\n}\n\n/** Options for {@link createMinimapContribution}. */\nexport interface MinimapContributionOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {\n  /** View and entry id. Default `'minimap'`. */\n  id?: string;\n  /** Where the minimap paints, in CSS pixels from the canvas top-left. A\n   *  function is re-read every frame, so it can follow the canvas's size. */\n  rect: ViewRect | ((outer: View, dims: Dims) => ViewRect);\n  /** What the minimap frames. Default `'scene'`, the union of leaf poses. */\n  fit?: MinimapFit<TData, TLayer, TPose>;\n  /** The surface layers the minimap paints. Default: all of them. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  /** Ground painted before the minimap's layers, so the main canvas does not\n   *  show through. */\n  background?: string;\n  /** The visible-rect indicator's stroke. */\n  indicatorStyle?: IndicatorStyle;\n}\n\nconst DEFAULT_BACKGROUND = '#18181c';\n\n/**\n * A minimap inside a `<SceneCanvas>`, installed with one entry:\n *\n * ```tsx\n * const minimap = useMemo(() => createMinimapContribution({ rect: { x: 8, y: 8, w: 160, h: 110 } }), []);\n * <SceneCanvas ambient={[minimap]} … />\n * ```\n *\n * Press in it to center the main camera on that point, drag to keep it there.\n * It shows the main camera's visible rect, and a crosshair where the pointer is\n * over the other view. Build it once — each instance keeps the live state its\n * layers read.\n */\nexport function createMinimapContribution<TData = unknown, TLayer extends string = string, TPose = unknown>(\n  opts: MinimapContributionOptions<TData, TLayer, TPose>,\n): SurfaceContribution {\n  const id = opts.id ?? 'minimap';\n  const fit = (opts.fit ?? 'scene') as MinimapFit<unknown, string, unknown>;\n  let deps: ContributionDepReader | null = null;\n\n  // The fit follows the scene, so it is recomputed only when the scene's\n  // version or the minimap's size changes — it is read on every frame and\n  // every event.\n  let cached: { scene: unknown; version: number; w: number; h: number; view: View } | null = null;\n  const fitCamera = (outer: View, dims: Dims): View => {\n    const scene = deps?.get('scene') as Scene<unknown, string, unknown> | undefined;\n    if (!scene) return FALLBACK_FIT_VIEW;\n    const r = typeof opts.rect === 'function' ? opts.rect(outer, dims) : opts.rect;\n    const version = scene.getVersion();\n    if (cached && cached.scene === scene && cached.version === version && cached.w === r.w && cached.h === r.h) {\n      return cached.view;\n    }\n    const descriptor = (deps?.get('poseDescriptor') ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<unknown>;\n    const view = computeFitView(scene, { width: r.w, height: r.h }, fit, descriptor);\n    cached = { scene, version, w: r.w, h: r.h, view };\n    return view;\n  };\n\n  const cursor = linkedCursor(`${id}.cursor`, [null, id]);\n  const indicator = createIndicatorLayer({\n    viewId: id,\n    root: () => deps?.get('rootView'),\n    ...(opts.indicatorStyle ? { style: opts.indicatorStyle } : {}),\n  });\n\n  return {\n    id,\n    eligibility: { always: true },\n    views: [{\n      id,\n      bounds: opts.rect,\n      view: fitCamera,\n      interactive: true,\n      background: opts.background ?? DEFAULT_BACKGROUND,\n      ...(opts.layers ? { layers: opts.layers } : {}),\n    }],\n    actions: [minimapCenterAction(), minimapPanAction()],\n    bindings: [\n      { spec: { kind: 'pointerDown' }, actionId: MINIMAP_CENTER, opts: { views: [id] } },\n      { spec: { kind: 'drag' }, actionId: MINIMAP_PAN, opts: { views: [id] } },\n    ],\n    overlay: [indicator, cursor.layer],\n    attach: (api, reader) => {\n      deps = reader;\n      const detachCursor = cursor.attach(api, reader);\n      // The fit camera had no scene until now.\n      api.requestRedraw();\n      return () => {\n        detachCursor();\n        deps = null;\n        cached = null;\n      };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/features/minimap/layers.js

@@ -1,103 +0,0 @@
-//#region src/features/minimap/layers.ts
-function e(e) {
-	return e?.viewId ?? null;
-}
-function t(t) {
-	let { viewId: n, root: r, style: i = {} } = t;
-	return {
-		id: `${n}.indicator`,
-		label: "Minimap indicator",
-		draw: (t, a) => {
-			if (e(t) !== n) return [];
-			let o = r(), s = o?.hostSize?.();
-			if (!o || !s) return [];
-			let c = o.get(), l = 1 / a.scale.x;
-			return [{
-				kind: "path",
-				path: {
-					kind: "rect",
-					x: c.x,
-					y: c.y,
-					width: s.width / c.scale.x,
-					height: s.height / c.scale.y
-				},
-				stroke: {
-					paint: {
-						fill: "solid",
-						color: i.stroke ?? "#ffffff"
-					},
-					width: (i.width ?? 1) * l,
-					dash: (i.dash ?? [2, 3]).map((e) => e * l)
-				}
-			}];
-		}
-	};
-}
-var n = "rgba(0, 0, 0, 0.6)";
-function r(e, t, n) {
-	let r = n, i = 9 * r, a = 3 * r, o = 2 * r, s = 1 * r, c = [
-		{
-			x: e - a - i,
-			y: t - o / 2,
-			w: i,
-			h: o
-		},
-		{
-			x: e + a,
-			y: t - o / 2,
-			w: i,
-			h: o
-		},
-		{
-			x: e - o / 2,
-			y: t - a - i,
-			w: o,
-			h: i
-		},
-		{
-			x: e - o / 2,
-			y: t + a,
-			w: o,
-			h: i
-		}
-	];
-	return {
-		halo: c.map((e) => ({
-			x: e.x - s,
-			y: e.y - s,
-			w: e.w + 2 * s,
-			h: e.h + 2 * s
-		})),
-		bars: c
-	};
-}
-function i(t) {
-	let { id: i, pointer: a, color: o, views: s } = t;
-	return {
-		id: i,
-		label: "Linked cursor",
-		draw: (t, i) => {
-			let c = a(), l = e(t);
-			if (!c || c.viewId === l || s && !s.includes(l)) return [];
-			let { halo: u, bars: d } = r(c.worldX, c.worldY, 1 / i.scale.x), f = (e, t) => ({
-				kind: "path",
-				path: {
-					kind: "rect",
-					x: e.x,
-					y: e.y,
-					width: e.w,
-					height: e.h
-				},
-				fill: {
-					fill: "solid",
-					color: t
-				}
-			}), p = o();
-			return [...u.map((e) => f(e, n)), ...d.map((e) => f(e, p))];
-		}
-	};
-}
-//#endregion
-export { n as CROSSHAIR_HALO, t as createIndicatorLayer, i as createLinkedCursorLayer, r as crosshairRects };
-
-//# sourceMappingURL=layers.js.map

package/dist/features/minimap/layers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"layers.js","names":["viewIdOf","data","createIndicatorLayer","opts","viewId","r","root","size","v","px","view","style","d","CROSSHAIR_HALO","crosshairRects","k","unitsPerPx","arm","gap","t","h","bars","x","y","b","createLinkedCursorLayer","p","pointer","here","views","rect","c","accent","color","halo"],"sources":["../../../src/features/minimap/layers.ts"],"sourcesContent":["/**\n * The minimap's chrome: the main camera's visible rect, drawn in the minimap,\n * and the linked crosshair, drawn in every view the pointer is not over.\n */\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '../../renderer/DrawCommand';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport type { IndicatorStyle } from '../../canvas/minimapMath';\n\n/** What a layer's `data` carries for this feature: the view it draws for. */\nfunction viewIdOf(data: unknown): string | null {\n  return (data as { viewId?: string | null } | null)?.viewId ?? null;\n}\n\n/**\n * The main camera's visible world rect, painted only in view `viewId`. Its\n * stroke and dash are screen pixels whatever the minimap's scale.\n */\nexport function createIndicatorLayer(opts: {\n  viewId: string;\n  root: () => ViewApi | undefined;\n  style?: IndicatorStyle;\n}): RenderLayer<unknown> {\n  const { viewId, root, style = {} } = opts;\n  return {\n    id: `${viewId}.indicator`,\n    label: 'Minimap indicator',\n    draw: (data, view: View): DrawCommand[] => {\n      if (viewIdOf(data) !== viewId) return [];\n      const r = root();\n      const size = r?.hostSize?.();\n      if (!r || !size) return [];\n      const v = r.get();\n      const px = 1 / view.scale.x;\n      return [{\n        kind: 'path',\n        path: { kind: 'rect', x: v.x, y: v.y, width: size.width / v.scale.x, height: size.height / v.scale.y },\n        stroke: {\n          paint: { fill: 'solid', color: style.stroke ?? '#ffffff' },\n          width: (style.width ?? 1) * px,\n          dash: (style.dash ?? [2, 3]).map((d) => d * px),\n        },\n      }];\n    },\n  };\n}\n\n/** Screen-pixel geometry of the crosshair: arm length, the gap at its center,\n *  line thickness, and the dark halo that keeps it legible over any content. */\nconst ARM = 9;\nconst GAP = 3;\nconst THICK = 2;\nconst HALO = 1;\n/** The halo's color: dark enough to separate the accent from any content. */\nexport const CROSSHAIR_HALO = 'rgba(0, 0, 0, 0.6)';\n\n/** An axis-aligned rect, `{ x, y, w, h }`. */\nexport interface CrosshairRect { x: number; y: number; w: number; h: number }\n\n/**\n * The linked crosshair at (`x`, `y`) as rects in the caller's units, where one\n * screen pixel is `unitsPerPx` of them: four halo rects to paint first, then\n * four bars. A painter with no weasel renderer — a 2D canvas — draws the same\n * crosshair from these.\n */\nexport function crosshairRects(\n  x: number, y: number, unitsPerPx: number,\n): { halo: CrosshairRect[]; bars: CrosshairRect[] } {\n  const k = unitsPerPx;\n  const arm = ARM * k, gap = GAP * k, t = THICK * k, h = HALO * k;\n  const bars: CrosshairRect[] = [\n    { x: x - gap - arm, y: y - t / 2, w: arm, h: t },\n    { x: x + gap, y: y - t / 2, w: arm, h: t },\n    { x: x - t / 2, y: y - gap - arm, w: t, h: arm },\n    { x: x - t / 2, y: y + gap, w: t, h: arm },\n  ];\n  const halo = bars.map((b) => ({ x: b.x - h, y: b.y - h, w: b.w + 2 * h, h: b.h + 2 * h }));\n  return { halo, bars };\n}\n\n/**\n * A crosshair at the pointer's world point, in each of `views` the pointer is\n * not over — the other side of a linked cursor. A fixed screen size in every\n * view. `views` omitted paints in every view.\n */\nexport function createLinkedCursorLayer(opts: {\n  id: string;\n  pointer: () => PointerWorldPos;\n  color: () => string;\n  views?: readonly (string | null)[];\n}): RenderLayer<unknown> {\n  const { id, pointer, color, views } = opts;\n  return {\n    id,\n    label: 'Linked cursor',\n    draw: (data, view: View): DrawCommand[] => {\n      const p = pointer();\n      const here = viewIdOf(data);\n      if (!p || p.viewId === here || (views && !views.includes(here))) return [];\n      const { halo, bars } = crosshairRects(p.worldX, p.worldY, 1 / view.scale.x);\n      const rect = (r: CrosshairRect, c: string): DrawCommand => ({\n        kind: 'path',\n        path: { kind: 'rect', x: r.x, y: r.y, width: r.w, height: r.h },\n        fill: { fill: 'solid', color: c },\n      });\n      const accent = color();\n      return [\n        ...halo.map((r) => rect(r, CROSSHAIR_HALO)),\n        ...bars.map((r) => rect(r, accent)),\n      ];\n    },\n  };\n}\n"],"mappings":";AAYA,SAASA,EAAS,GAA8B;CAC9C,OAAQC,GAA4C,UAAU;AAChE;AAMA,SAAgBC,EAAqB,GAIZ;CACvB,IAAM,EAAE,WAAQ,SAAM,WAAQ,CAAC,MAAMC;CACrC,OAAO;EACL,IAAI,GAAGC,EAAO;EACd,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAIJ,EAASC,CAAI,MAAMG,GAAQ,OAAO,CAAC;GACvC,IAAMC,IAAIC,EAAK,GACTC,IAAOF,GAAG,WAAW;GAC3B,IAAI,CAACA,KAAK,CAACE,GAAM,OAAO,CAAC;GACzB,IAAMC,IAAIH,EAAE,IAAI,GACVI,IAAK,IAAIC,EAAK,MAAM;GAC1B,OAAO,CAAC;IACN,MAAM;IACN,MAAM;KAAE,MAAM;KAAQ,GAAGF,EAAE;KAAG,GAAGA,EAAE;KAAG,OAAOD,EAAK,QAAQC,EAAE,MAAM;KAAG,QAAQD,EAAK,SAASC,EAAE,MAAM;IAAE;IACrG,QAAQ;KACN,OAAO;MAAE,MAAM;MAAS,OAAOG,EAAM,UAAU;KAAU;KACzD,QAAQA,EAAM,SAAS,KAAKF;KAC5B,OAAOE,EAAM,QAAQ,CAAC,GAAG,CAAC,EAAA,CAAG,KAAK,MAAMC,IAAIH,CAAE;IAChD;GACF,CAAC;EACH;CACF;AACF;AAIA,IAKaI,IAAiB;AAW9B,SAAgBC,EACd,GAAW,GAAW,GAC4B;CAClD,IAAMC,IAAIC,GACJC,IAAM,IAAMF,GAAGG,IAAM,IAAMH,GAAGI,IAAI,IAAQJ,GAAGK,IAAI,IAAOL,GACxDM,IAAwB;EAC5B;GAAE,GAAGC,IAAIJ,IAAMD;GAAK,GAAGM,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EAC/C;GAAE,GAAGG,IAAIJ;GAAK,GAAGK,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EACzC;GAAE,GAAGG,IAAIH,IAAI;GAAG,GAAGI,IAAIL,IAAMD;GAAK,GAAGE;GAAG,GAAGF;EAAI;EAC/C;GAAE,GAAGK,IAAIH,IAAI;GAAG,GAAGI,IAAIL;GAAK,GAAGC;GAAG,GAAGF;EAAI;CAC3C;CAEA,OAAO;EAAE,MADII,EAAK,KAAK,OAAO;GAAE,GAAGG,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;EAAE,EAC9E;EAAM;CAAK;AACtB;AAOA,SAAgBK,EAAwB,GAKf;CACvB,IAAM,EAAE,OAAI,YAAS,UAAO,aAAUtB;CACtC,OAAO;EACL;EACA,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAMuB,IAAIC,EAAQ,GACZC,IAAO5B,EAASC,CAAI;GAC1B,IAAI,CAACyB,KAAKA,EAAE,WAAWE,KAASC,KAAS,CAACA,EAAM,SAASD,CAAI,GAAI,OAAO,CAAC;GACzE,IAAM,EAAE,SAAM,YAASd,EAAeY,EAAE,QAAQA,EAAE,QAAQ,IAAIhB,EAAK,MAAM,CAAC,GACpEoB,KAAQ,GAAkB,OAA4B;IAC1D,MAAM;IACN,MAAM;KAAE,MAAM;KAAQ,GAAGzB,EAAE;KAAG,GAAGA,EAAE;KAAG,OAAOA,EAAE;KAAG,QAAQA,EAAE;IAAE;IAC9D,MAAM;KAAE,MAAM;KAAS,OAAO0B;IAAE;GAClC,IACMC,IAASC,EAAM;GACrB,OAAO,CACL,GAAGC,EAAK,KAAK,MAAMJ,EAAKzB,GAAGQ,CAAc,CAAC,GAC1C,GAAGQ,EAAK,KAAK,MAAMS,EAAKzB,GAAG2B,CAAM,CAAC,CACpC;EACF;CACF;AACF"}

package/dist/features/overlays/useNodeOverlayFrame.js

@@ -1,103 +0,0 @@
-import { useCanvasSize as e } from "../../core/viewport/useCanvasSize.js";
-import { composeWorldPose as t } from "../../core/scene/composeFrame.js";
-import { composeRectPose as n } from "../groups/composePose.js";
-import { effectivePose as r } from "../../core/scene/effectivePose.js";
-import { poseRotationOf as i } from "../../core/geometry/poseRotation.js";
-import { applyToPoint as a, invert as o, multiply as s } from "@weasel-js/geom";
-import { useCallback as c, useInsertionEffect as l, useRef as u } from "react";
-//#region src/features/overlays/useNodeOverlayFrame.ts
-function d(t, n, r, i = {}) {
-	let { width: d, height: g } = e(n), { view: _, compose: v } = i, y = c(() => {
-		let e = p(t, r, v);
-		return e ? s(m(f(_)), h(e)) : null;
-	}, [
-		t,
-		r,
-		v,
-		_
-	]), b = c((e) => {
-		let t = y();
-		if (!t) return e;
-		let [n, r] = a(t, e.x, e.y);
-		return {
-			x: n,
-			y: r
-		};
-	}, [y]), x = u(null), S = c((e) => {
-		let t = y(), n = t && o(t);
-		n && (x.current = n);
-		let [r, i] = a(n ?? x.current, e.x, e.y);
-		return {
-			x: r,
-			y: i
-		};
-	}, [y]), C = p(t, r, v), w = C && d !== 0 && g !== 0 ? y() : null, T = w && o(w);
-	return l(() => {
-		T && (x.current = T);
-	}), !C || !T ? null : {
-		box: {
-			x: C.x,
-			y: C.y,
-			width: C.width,
-			height: C.height
-		},
-		toScreen: b,
-		toLocal: S,
-		width: d,
-		height: g
-	};
-}
-function f(e) {
-	return typeof e == "function" ? e() : e;
-}
-function p(e, i, a) {
-	if (i == null) return null;
-	let o = e.nodes;
-	return o.has(i) ? t({
-		getPose: (t) => r(e, o.get(t)),
-		getParent: (e) => o.get(e)?.parent ?? null
-	}, i, a ?? n) : null;
-}
-function m(e) {
-	if (!e) return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
-	let { x: t, y: n } = e.scale;
-	return [
-		t,
-		0,
-		0,
-		n,
-		-e.x * t,
-		-e.y * n
-	];
-}
-function h(e) {
-	let t = i(e);
-	if (!t) return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
-	let n = Math.cos(t.rotation), r = Math.sin(t.rotation);
-	return [
-		n,
-		r,
-		-r,
-		n,
-		t.cx - t.cx * n + t.cy * r,
-		t.cy - t.cx * r - t.cy * n
-	];
-}
-//#endregion
-export { d as useNodeOverlayFrame };
-
-//# sourceMappingURL=useNodeOverlayFrame.js.map

package/dist/features/overlays/useNodeOverlayFrame.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useNodeOverlayFrame.js","names":["useNodeOverlayFrame","useCanvasSize","containerRef","options","project","useCallback","box","worldBoxOf","scene","nodeId","compose","multiply","viewMatrix","resolveView","view","rotationMatrix","toScreen","m","p","x","y","applyToPoint","lastInverse","useRef","toLocal","inverse","invert","width","height","useInsertionEffect","nodes","composeWorldPose","effectivePose","id","composeRectPose","sx","sy","r","poseRotationOf","pose","c","s"],"sources":["../../../src/features/overlays/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * This is the frame half of `subscribeView`'s \"DOM pinned to world\n * coordinates\" case. Consumers positioning chrome over a node — gradient\n * handles, a badge, a caret — otherwise re-derive it, and the\n * translate-and-scale inverse that derivation usually reaches for drops\n * `pose.rotation`, so the chrome sits where the node would be unrotated.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. Rotation lives in this hook,\n * not in those: a node's stored geometry is pre-rotation by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, type Mat3 } from '@weasel-js/geom';\nimport type { Node, RectPose, Scene } from '../../core/scene/types';\nimport { useCanvasSize } from '../../core/viewport/useCanvasSize';\nimport type { View } from '../../core/viewport/view';\nimport { composeRectPose, composeWorldPose } from '../groups/composePose';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\n\n/** Structural point, matching every other `{ x, y }` the kit passes across a\n *  boundary. */\nexport interface OverlayPoint {\n  x: number;\n  y: number;\n}\n\n/** The overlay frame for one node. `null` from the hook means there is no\n *  frame yet — no node, or nothing measured to draw it on. */\nexport interface NodeOverlayFrame {\n  /** The node's composed world box, **unrotated**: the frame `toScreen` maps\n   *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Node box frame → overlay pixels, rotation and view included. */\n  toScreen: (p: OverlayPoint) => OverlayPoint;\n  /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view\n   *  flattens an axis, it keeps the last mapping that had an inverse. */\n  toLocal: (p: OverlayPoint) => OverlayPoint;\n  /** The container's size in CSS pixels — the overlay's own box. */\n  width: number;\n  height: number;\n}\n\n/** Options for `useNodeOverlayFrame`. */\nexport interface UseNodeOverlayFrameOptions<TPose> {\n  /**\n   * Current viewport. A thunk is re-read on every projection, which is what\n   * an uncontrolled `SceneCanvas` needs — its camera lives in a ref and moves\n   * without a render, so pass the handle's `getView`. A plain `View` is the\n   * value from the render that supplied it, correct for a controlled\n   * consumer. Omit it and world units are handed through as screen pixels.\n   */\n  view?: View | (() => View);\n  /** Fold a child pose into its parent's frame. Default `composeRectPose`. */\n  compose?: (parent: TPose, child: TPose) => TPose;\n}\n\n/**\n * Resolve the overlay frame for `nodeId` against `containerRef` — the element\n * the overlay is positioned in, which must be the canvas's own box for the\n * projection to land.\n *\n * Returns `null` when there is no node under `nodeId`, when the container has\n * not been measured, or when the view collapses an axis to zero — the three\n * states in which an overlay has nothing to draw.\n */\nexport function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  containerRef: RefObject<HTMLElement | null>,\n  nodeId: string | null | undefined,\n  options: UseNodeOverlayFrameOptions<TPose> = {},\n): NodeOverlayFrame | null {\n  const { width, height } = useCanvasSize(containerRef);\n  const { view, compose } = options;\n\n  const project = useCallback((): Mat3 | null => {\n    const box = worldBoxOf(scene, nodeId, compose);\n    if (!box) return null;\n    return multiply(viewMatrix(resolveView(view)), rotationMatrix(box));\n  }, [scene, nodeId, compose, view]);\n\n  const toScreen = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    if (!m) return p;\n    const [x, y] = applyToPoint(m, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const lastInverse = useRef<Mat3 | null>(null);\n\n  const toLocal = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    const inverse = m && invert(m);\n    if (inverse) lastInverse.current = inverse;\n    // Published by the commit that handed this toLocal out, so there is one.\n    const [x, y] = applyToPoint(inverse ?? lastInverse.current!, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const box = worldBoxOf(scene, nodeId, compose);\n  const m = box && width !== 0 && height !== 0 ? project() : null;\n  const inverse = m && invert(m);\n  useInsertionEffect(() => {\n    if (inverse) lastInverse.current = inverse;\n  });\n\n  if (!box || !inverse) return null;\n  return { box: { x: box.x, y: box.y, width: box.width, height: box.height }, toScreen, toLocal, width, height };\n}\n\nfunction resolveView(view: View | (() => View) | undefined): View | undefined {\n  return typeof view === 'function' ? view() : view;\n}\n\nfunction worldBoxOf<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  nodeId: string | null | undefined,\n  compose: ((parent: TPose, child: TPose) => TPose) | undefined,\n): TPose | null {\n  if (nodeId == null) return null;\n  const nodes = scene.nodes as ReadonlyMap<string, Node<TData, TLayer, TPose>>;\n  if (!nodes.has(nodeId)) return null;\n  // `effectivePose`, not `node.pose`: an overlay tracks what the renderer\n  // draws, and a gesture override or a derived pose is exactly the difference.\n  const adapter = {\n    getPose: (id: string) => effectivePose(scene, nodes.get(id)!),\n    getParent: (id: string) => nodes.get(id)?.parent ?? null,\n  };\n  return composeWorldPose(adapter, nodeId, compose ?? composeRectPose);\n}\n\n/** World → overlay pixels: `screen = (world − view) × view.scale`. */\nfunction viewMatrix(view: View | undefined): Mat3 {\n  if (!view) return [1, 0, 0, 1, 0, 0];\n  const { x: sx, y: sy } = view.scale;\n  return [sx, 0, 0, sy, -view.x * sx, -view.y * sy];\n}\n\n/** The pose→world leg the box frame omits, per `poseRotationOf`'s convention. */\nfunction rotationMatrix(pose: RectPose): Mat3 {\n  const r = poseRotationOf(pose);\n  if (!r) return [1, 0, 0, 1, 0, 0];\n  const c = Math.cos(r.rotation);\n  const s = Math.sin(r.rotation);\n  return [c, s, -s, c, r.cx - r.cx * c + r.cy * s, r.cy - r.cx * s - r.cy * c];\n}\n"],"mappings":";;;;;;;;AAuEA,SAAgBA,EACd,GACA,GACA,GACA,IAA6C,CAAC,GACrB;CACzB,IAAM,EAAE,UAAO,cAAWC,EAAcC,CAAY,GAC9C,EAAE,SAAM,eAAYC,GAEpBC,IAAUC,QAA+B;EAC7C,IAAMC,IAAMC,EAAWC,GAAOC,GAAQC,CAAO;EAE7C,OADKJ,IACEK,EAASC,EAAWC,EAAYC,CAAI,CAAC,GAAGC,EAAeT,CAAG,CAAC,IADjD;CAEnB,GAAG;EAACE;EAAOC;EAAQC;EAASI;CAAI,CAAC,GAE3BE,IAAWX,GAAa,MAAkC;EAC9D,IAAMY,IAAIb,EAAQ;EAClB,IAAI,CAACa,GAAG,OAAOC;EACf,IAAM,CAACC,GAAGC,KAAKC,EAAaJ,GAAGC,EAAE,GAAGA,EAAE,CAAC;EACvC,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENkB,IAAcC,EAAoB,IAAI,GAEtCC,IAAUnB,GAAa,MAAkC;EAC7D,IAAMY,IAAIb,EAAQ,GACZqB,IAAUR,KAAKS,EAAOT,CAAC;EAC7B,AAAIQ,MAAS,EAAY,UAAUA;EAEnC,IAAM,CAACN,GAAGC,KAAKC,EAAaI,KAAWH,EAAY,SAAUJ,EAAE,GAAGA,EAAE,CAAC;EACrE,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENE,IAAMC,EAAWC,GAAOC,GAAQC,CAAO,GACvCO,IAAIX,KAAOqB,MAAU,KAAKC,MAAW,IAAIxB,EAAQ,IAAI,MACrDqB,IAAUR,KAAKS,EAAOT,CAAC;CAM7B,OALAY,QAAyB;EACvB,AAAIJ,MAAS,EAAY,UAAUA;CACrC,CAAC,GAEG,CAACnB,KAAO,CAACmB,IAAgB,OACtB;EAAE,KAAK;GAAE,GAAGnB,EAAI;GAAG,GAAGA,EAAI;GAAG,OAAOA,EAAI;GAAO,QAAQA,EAAI;EAAO;EAAG;EAAU;EAAS;EAAO;CAAO;AAC/G;AAEA,SAASO,EAAY,GAAyD;CAC5E,OAAO,OAAOC,KAAS,aAAaA,EAAK,IAAIA;AAC/C;AAEA,SAASP,EACP,GACA,GACA,GACc;CACd,IAAIE,KAAU,MAAM,OAAO;CAC3B,IAAMqB,IAAQtB,EAAM;CAQpB,OAPKsB,EAAM,IAAIrB,CAAM,IAOdsB,EAAiB;EAHtB,UAAU,MAAeC,EAAcxB,GAAOsB,EAAM,IAAIG,CAAE,CAAE;EAC5D,YAAY,MAAeH,EAAM,IAAIG,CAAE,CAAC,EAAE,UAAU;CAE9B,GAASxB,GAAQC,KAAWwB,CAAe,IAPpC;AAQjC;AAGA,SAAStB,EAAW,GAA8B;CAChD,IAAI,CAACE,GAAM,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CACnC,IAAM,EAAE,GAAGqB,GAAI,GAAGC,MAAOtB,EAAK;CAC9B,OAAO;EAACqB;EAAI;EAAG;EAAGC;EAAI,CAACtB,EAAK,IAAIqB;EAAI,CAACrB,EAAK,IAAIsB;CAAE;AAClD;AAGA,SAASrB,EAAe,GAAsB;CAC5C,IAAMsB,IAAIC,EAAeC,CAAI;CAC7B,IAAI,CAACF,GAAG,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CAChC,IAAMG,IAAI,KAAK,IAAIH,EAAE,QAAQ,GACvBI,IAAI,KAAK,IAAIJ,EAAE,QAAQ;CAC7B,OAAO;EAACG;EAAGC;EAAG,CAACA;EAAGD;EAAGH,EAAE,KAAKA,EAAE,KAAKG,IAAIH,EAAE,KAAKI;EAAGJ,EAAE,KAAKA,EAAE,KAAKI,IAAIJ,EAAE,KAAKG;CAAC;AAC7E"}

package/dist/features/parallax/createParallaxLayer.js

@@ -1,26 +0,0 @@
-import { drawOneLayer as e, subscribeToSources as t } from "../../core/layers/render.js";
-import { deriveParallaxView as n } from "../../core/viewport/parallax.js";
-import { isParallaxSource as r } from "./createParallaxPlane.js";
-//#region src/features/parallax/createParallaxLayer.ts
-function i(i) {
-	let { id: a, label: o, source: s, parallax: c, getOuterView: l } = i, u = r(c) ? () => c.get() : () => c, d = t(s);
-	return {
-		id: a,
-		label: o,
-		space: "screen",
-		subscribe: r(c) ? (e) => {
-			let t = d(e), n = c.subscribe(e);
-			return () => {
-				t(), n();
-			};
-		} : d,
-		draw: (t, r, i) => {
-			let a = n(l?.() ?? r, u());
-			return s.flatMap((n) => e(n, t, a, i));
-		}
-	};
-}
-//#endregion
-export { i as createParallaxLayer };
-
-//# sourceMappingURL=createParallaxLayer.js.map

package/dist/features/parallax/createParallaxLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createParallaxLayer.js","names":["createParallaxLayer","opts","read","isParallaxSource","parallax","fromSources","subscribeToSources","source","offSources","listener","offPlane","inner","deriveParallaxView","getOuterView","outer","drawOneLayer","layer","data","dims"],"sources":["../../../src/features/parallax/createParallaxLayer.ts"],"sourcesContent":["import { drawOneLayer, subscribeToSources, type RenderLayer } from '../../core/layers/render';\nimport type { View } from '../../core/viewport/view';\nimport { deriveParallaxView, type ParallaxOpts } from '../../core/viewport/parallax';\nimport { isParallaxSource, type ParallaxSource } from './createParallaxPlane';\n\n/** Options for `createParallaxLayer`. */\nexport interface CreateParallaxLayerOpts<TData> {\n  id: string;\n  label: string;\n  /** Layers re-rendered through the derived inner view. */\n  source: RenderLayer<TData>[];\n  /** How the plane tracks the camera. Pass a `ParallaxSource` (such as\n   *  `createParallaxPlane`) to change it after the layer is built — an\n   *  animator tweening `pan` or `zoom` writes the plane, not the layer. */\n  parallax: ParallaxOpts | ParallaxSource;\n  /** Where the camera view comes from. Defaults to the view the Canvas hands\n   *  the layer — the `view` prop. A consumer running a 60 Hz camera through\n   *  refs pins that prop to identity, and would otherwise get identity back\n   *  for every `pan` value and a backdrop that never moves. */\n  getOuterView?: () => View;\n}\n\n/**\n * Wrap source RenderLayers in a parallax plane. The plane's inner view is\n * derived from the camera view per {@link deriveParallaxView}; each source\n * layer is drawn through it by `drawOneLayer`, so a `space: 'world'` source\n * gets the inner view's transform and a `space: 'screen'` one does not. The\n * plane itself is emitted as `space: 'screen'` — its children already carry\n * whatever transform they need, and the outer Canvas must add none.\n *\n * What this draws is paint: pointer events target the camera's view. Content\n * that should be clickable belongs on a scene layer carrying `parallax`\n * instead, which `<SceneCanvas>` renders and picks through the same view.\n *\n * **Screen-space source layers don't compose meaningfully** — they ignore\n * the derived view by definition. Same constraint as `createViewportLayer`.\n */\nexport function createParallaxLayer<TData>(\n  opts: CreateParallaxLayerOpts<TData>,\n): RenderLayer<TData> {\n  const { id, label, source, parallax, getOuterView } = opts;\n  const read = isParallaxSource(parallax) ? () => parallax.get() : () => parallax;\n  const fromSources = subscribeToSources(source);\n  return {\n    id,\n    label,\n    space: 'screen',\n    subscribe: isParallaxSource(parallax)\n      ? (listener) => {\n        const offSources = fromSources(listener);\n        const offPlane = parallax.subscribe(listener);\n        return () => { offSources(); offPlane(); };\n      }\n      : fromSources,\n    draw: (data, outer, dims) => {\n      const inner = deriveParallaxView(getOuterView?.() ?? outer, read());\n      return source.flatMap((layer) => drawOneLayer(layer, data, inner, dims));\n    },\n  };\n}\n"],"mappings":";;;;AAqCA,SAAgBA,EACd,GACoB;CACpB,IAAM,EAAE,OAAI,UAAO,WAAQ,aAAU,oBAAiBC,GAChDC,IAAOC,EAAiBC,CAAQ,UAAUA,EAAS,IAAI,UAAUA,GACjEC,IAAcC,EAAmBC,CAAM;CAC7C,OAAO;EACL;EACA;EACA,OAAO;EACP,WAAWJ,EAAiBC,CAAQ,KAC/B,MAAa;GACd,IAAMI,IAAaH,EAAYI,CAAQ,GACjCC,IAAWN,EAAS,UAAUK,CAAQ;GAC5C,aAAa;IAAgB,AAAdD,EAAW,GAAGE,EAAS;GAAG;EAC3C,IACEL;EACJ,OAAO,GAAM,GAAO,MAAS;GAC3B,IAAMM,IAAQC,EAAmBC,IAAe,KAAKC,GAAOZ,EAAK,CAAC;GAClE,OAAOK,EAAO,SAAS,MAAUQ,EAAaC,GAAOC,GAAMN,GAAOO,CAAI,CAAC;EACzE;CACF;AACF"}

package/dist/features/parallax/createParallaxPlane.js

@@ -1,26 +0,0 @@
-//#region src/features/parallax/createParallaxPlane.ts
-function e(e) {
-	let t = { ...e }, n = /* @__PURE__ */ new Set();
-	return {
-		get: () => t,
-		set(e) {
-			t = {
-				...t,
-				...e
-			};
-			for (let e of [...n]) e();
-		},
-		subscribe(e) {
-			return n.add(e), () => {
-				n.delete(e);
-			};
-		}
-	};
-}
-function t(e) {
-	return typeof e.get == "function";
-}
-//#endregion
-export { e as createParallaxPlane, t as isParallaxSource };
-
-//# sourceMappingURL=createParallaxPlane.js.map

package/dist/features/parallax/createParallaxPlane.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createParallaxPlane.js","names":["createParallaxPlane","current","initial","listeners","patch","fn","isParallaxSource","p"],"sources":["../../../src/features/parallax/createParallaxPlane.ts"],"sourcesContent":["import type { RedrawSource } from '../../core/layers/render';\nimport type { ParallaxOpts } from '../../core/viewport/parallax';\n\n/** Parallax opts that can change after a layer is built. `get` is read on\n *  every draw, and a notification repaints whatever draws through it. */\nexport interface ParallaxSource extends RedrawSource {\n  get(): ParallaxOpts;\n}\n\n/** A {@link ParallaxSource} you write to — what an animator's `onTick` drives\n *  to tween a plane's `pan`, `zoom` or `anchor`. */\nexport interface ParallaxPlane extends ParallaxSource {\n  /** Merge `patch` over the current opts and notify. */\n  set(patch: Partial<ParallaxOpts>): void;\n}\n\n/** A {@link ParallaxPlane} starting at `initial`. Pass it as a parallax\n *  layer's `parallax` and write to it to move the plane. */\nexport function createParallaxPlane(initial: ParallaxOpts): ParallaxPlane {\n  let current: ParallaxOpts = { ...initial };\n  const listeners = new Set<() => void>();\n  return {\n    get: () => current,\n    set(patch) {\n      current = { ...current, ...patch };\n      for (const fn of [...listeners]) fn();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n  };\n}\n\n/** Whether `p` is a live source rather than a fixed set of opts. */\nexport function isParallaxSource(p: ParallaxOpts | ParallaxSource): p is ParallaxSource {\n  return typeof (p as ParallaxSource).get === 'function';\n}\n"],"mappings":";AAkBA,SAAgBA,EAAoB,GAAsC;CACxE,IAAIC,IAAwB,EAAE,GAAGC,EAAQ,GACnCC,oBAAY,IAAI,IAAgB;CACtC,OAAO;EACL,WAAWF;EACX,IAAI,GAAO;GACT,IAAU;IAAE,GAAGA;IAAS,GAAGG;GAAM;GACjC,KAAK,IAAMC,KAAM,CAAC,GAAGF,CAAS,GAAG,EAAG;EACtC;EACA,UAAU,GAAI;GAEZ,OADAA,EAAU,IAAIE,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;CACF;AACF;AAGA,SAAgBC,EAAiB,GAAuD;CACtF,OAAO,OAAQC,EAAqB,OAAQ;AAC9C"}