@weasel-js/core 1.7.0 → 1.7.2

package/dist/core/viewport/interpolateView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolateView.js","names":["axisCurve","linear","x0","x1","t","s0","s1","p","w","ratio","s","interpolateView","fx","from","to","fy","a","b"],"sources":["../../../src/core/viewport/interpolateView.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * Per-axis camera curve. Two views that differ in scale agree at exactly one\n * screen point; holding the world point under it fixed is what makes a zoom\n * read as anchored rather than drifting. Scale moves geometrically between\n * positive endpoints, so each frame changes the view by the same ratio and an\n * easing that overshoots past 1 still cannot cross zero.\n *\n * Endpoints that are not both positive get the linear branch: `(s1/s0)^t` is\n * NaN for a negative ratio and `1/s0` is infinite at zero, and there is no\n * geometric path across a sign change to be had anyway.\n */\nfunction axisCurve(x0: number, s0: number, x1: number, s1: number): (t: number) => { x: number; s: number } {\n  const linear = (t: number) => ({ x: x0 + (x1 - x0) * t, s: s0 + (s1 - s0) * t });\n  if (!(s0 > 0) || !(s1 > 0)) return linear;\n  // Equal scales: no fixed point exists on this axis. That is a pure pan.\n  if (Math.abs(s1 - s0) <= 1e-12 * Math.max(Math.abs(s0), Math.abs(s1), 1)) return linear;\n  const p = (x1 - x0) / (1 / s0 - 1 / s1); // screen px where the two views agree\n  const w = p / s0 + x0;                   // the world point under it\n  const ratio = s1 / s0;\n  return (t) => {\n    const s = s0 * Math.pow(ratio, t);\n    return { x: w - p / s, s };\n  };\n}\n\n/**\n * `InterpolatorFactory<View>` for camera animation — built once per animation,\n * called with eased `t` each frame. Pass to `Animator.tween`'s `interpolator`.\n */\nexport function interpolateView(from: View, to: View): (t: number) => View {\n  const fx = axisCurve(from.x, from.scale.x, to.x, to.scale.x);\n  const fy = axisCurve(from.y, from.scale.y, to.y, to.scale.y);\n  return (t: number): View => {\n    const a = fx(t);\n    const b = fy(t);\n    return { x: a.x, y: b.x, scale: { x: a.s, y: b.s } };\n  };\n}\n"],"mappings":";AAaA,SAASA,EAAU,GAAY,GAAY,GAAY,GAAqD;CAC1G,IAAMC,KAAU,OAAe;EAAE,GAAGC,KAAMC,IAAKD,KAAME;EAAG,GAAGC,KAAMC,IAAKD,KAAMD;CAAE;CAG9E,IAFI,EAAEC,IAAK,MAAM,EAAEC,IAAK,MAEpB,KAAK,IAAIA,IAAKD,CAAE,KAAK,QAAQ,KAAK,IAAI,KAAK,IAAIA,CAAE,GAAG,KAAK,IAAIC,CAAE,GAAG,CAAC,GAAG,OAAOL;CACjF,IAAMM,KAAKJ,IAAKD,MAAO,IAAIG,IAAK,IAAIC,IAC9BE,IAAID,IAAIF,IAAKH,GACbO,IAAQH,IAAKD;CACnB,QAAQ,MAAM;EACZ,IAAMK,IAAIL,IAAcI,MAAOL;EAC/B,OAAO;GAAE,GAAGI,IAAID,IAAIG;GAAG;EAAE;CAC3B;AACF;AAMA,SAAgBC,EAAgB,GAAY,GAA+B;CACzE,IAAMC,IAAKZ,EAAUa,EAAK,GAAGA,EAAK,MAAM,GAAGC,EAAG,GAAGA,EAAG,MAAM,CAAC,GACrDC,IAAKf,EAAUa,EAAK,GAAGA,EAAK,MAAM,GAAGC,EAAG,GAAGA,EAAG,MAAM,CAAC;CAC3D,QAAQ,MAAoB;EAC1B,IAAME,IAAIJ,EAAGR,CAAC,GACRa,IAAIF,EAAGX,CAAC;EACd,OAAO;GAAE,GAAGY,EAAE;GAAG,GAAGC,EAAE;GAAG,OAAO;IAAE,GAAGD,EAAE;IAAG,GAAGC,EAAE;GAAE;EAAE;CACrD;AACF"}

package/dist/core/viewport/meanScale.js

@@ -0,0 +1,8 @@
+//#region src/core/viewport/meanScale.ts
+function e(e) {
+	return Math.sqrt(e.x * e.y);
+}
+//#endregion
+export { e as meanScale };
+
+//# sourceMappingURL=meanScale.js.map

package/dist/core/viewport/meanScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meanScale.js","names":["meanScale","s"],"sources":["../../../src/core/viewport/meanScale.ts"],"sourcesContent":["/**\n * Geometric mean of a per-axis scale. Degenerates to `s.x` (or `s.y`) when the\n * two axes are equal; otherwise sits between them.\n *\n * **Not for hit-testing.** A screen-pixel length is not one world distance\n * under non-uniform zoom, and collapsing it to a scalar makes a pickable\n * region too generous on one axis and too mean on the other. Use `pxExtent`\n * for a per-axis world length, or `withinPxBox` / `withinPxRadius` to compare\n * in screen space directly. Chrome hit-tests moved off this in 2026-08.\n *\n * Nor for placing chrome or measuring a pick slop: `standoff` and\n * `strokeHitTest`'s `slop` work on screen, which stays exact under a rotated\n * target where no per-axis world answer exists.\n *\n * What legitimately remains is a stroke width for a line that is not\n * axis-aligned. A ribbon takes one world width, and the renderer resolves a\n * `{ px }` width through this same mean, so a picker reading ink widths must\n * too. An axis-aligned line has an exact answer — `pxExtent` on its cross\n * axis, as the grid layer does.\n */\nexport function meanScale(s: { x: number; y: number }): number {\n  return Math.sqrt(s.x * s.y);\n}\n"],"mappings":";AAoBA,SAAgBA,EAAU,GAAqC;CAC7D,OAAO,KAAK,KAAKC,EAAE,IAAIA,EAAE,CAAC;AAC5B"}

package/dist/core/viewport/parallax.js

@@ -0,0 +1,111 @@
+//#region src/core/viewport/parallax.ts
+function e(e) {
+	return typeof e == "number" ? {
+		x: e,
+		y: e
+	} : e;
+}
+function t(t, n) {
+	let r = e(n.pan), i = e(n.zoom ?? 1), a = n.anchor ?? {
+		x: 0,
+		y: 0
+	};
+	return {
+		x: a.x + (t.x - a.x) * r.x,
+		y: a.y + (t.y - a.y) * r.y,
+		scale: {
+			x: 1 + (t.scale.x - 1) * i.x,
+			y: 1 + (t.scale.y - 1) * i.y
+		}
+	};
+}
+function n(e, n) {
+	let r = t(e, n), i = e.scale.x / r.scale.x, a = e.scale.y / r.scale.y;
+	return {
+		scale: {
+			x: i,
+			y: a
+		},
+		offset: {
+			x: r.x - i * e.x,
+			y: r.y - a * e.y
+		}
+	};
+}
+function r(e, t) {
+	return {
+		x: t.x * e.scale.x + e.offset.x,
+		y: t.y * e.scale.y + e.offset.y
+	};
+}
+function i(e, t) {
+	return {
+		x: (t.x - e.offset.x) / e.scale.x,
+		y: (t.y - e.offset.y) / e.scale.y
+	};
+}
+function a(e, t) {
+	let n = t({
+		x: e.x,
+		y: e.y
+	}), r = t({
+		x: e.x + e.width,
+		y: e.y + e.height
+	});
+	return {
+		x: Math.min(n.x, r.x),
+		y: Math.min(n.y, r.y),
+		width: Math.abs(r.x - n.x),
+		height: Math.abs(r.y - n.y)
+	};
+}
+function o(e, t) {
+	return {
+		...t,
+		...a(t, (t) => r(e, t))
+	};
+}
+function s(e, t) {
+	return {
+		...t,
+		...a(t, (t) => i(e, t))
+	};
+}
+function c(e, t) {
+	if (e === t) return null;
+	let n = e ?? l, r = t ?? l, i = r.scale.x / n.scale.x, a = r.scale.y / n.scale.y, o = {
+		scale: {
+			x: i,
+			y: a
+		},
+		offset: {
+			x: r.offset.x - n.offset.x * i,
+			y: r.offset.y - n.offset.y * a
+		}
+	};
+	return o.scale.x === 1 && o.scale.y === 1 && o.offset.x === 0 && o.offset.y === 0 ? null : o;
+}
+var l = {
+	scale: {
+		x: 1,
+		y: 1
+	},
+	offset: {
+		x: 0,
+		y: 0
+	}
+};
+function u(e) {
+	return [
+		e.scale.x,
+		0,
+		0,
+		e.scale.y,
+		e.offset.x,
+		e.offset.y
+	];
+}
+//#endregion
+export { t as deriveParallaxView, i as fromPlane, n as planeMap, u as planeMatrix, c as planeToPlane, s as rectFromPlane, o as rectToPlane, r as toPlane };
+
+//# sourceMappingURL=parallax.js.map

package/dist/core/viewport/parallax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallax.js","names":["asXY","v","deriveParallaxView","p","opts","z","outer","planeMap","inner","kx","ky","toPlane","m","fromPlane","mapRect","a","map","r","b","rectToPlane","rectFromPlane","planeToPlane","from","to","f","IDENTITY_MAP","t","sx","sy","planeMatrix"],"sources":["../../../src/core/viewport/parallax.ts"],"sourcesContent":["import type { View } from './view';\n\n/** One value for both axes, or a separate value per axis. */\nexport type ScalarOrXY = number | { x: number; y: number };\n\n/** How a parallax plane tracks the camera: `pan` is the fraction of the\n *  camera's translation it follows (1 = locked to the scene, 0 = fixed to the\n *  screen), `zoom` the same for scale, and `anchor` the camera position\n *  (`view.x` / `view.y`) the translation is measured from — every plane lines\n *  up when the camera sits there. */\nexport interface ParallaxOpts {\n  pan: ScalarOrXY;\n  zoom?: ScalarOrXY;\n  anchor?: { x: number; y: number };\n}\n\nfunction asXY(v: ScalarOrXY): { x: number; y: number } {\n  return typeof v === 'number' ? { x: v, y: v } : v;\n}\n\n/**\n * Pure derivation of a parallax plane's inner `View` from the camera view\n * plus per-plane factors.\n *\n * `pan` controls how much the plane translates with the camera (1 = normal,\n * 0 = locked to `anchor`, >1 = leads). `zoom` controls how much it scales\n * with camera zoom (1 = normal, 0 = fixed at identity scale). `anchor`\n * (default origin) is the camera position at which all planes agree.\n *\n * Identity holds: `pan=1, zoom=1` returns a view equal to `outer`.\n */\nexport function deriveParallaxView(outer: View, opts: ParallaxOpts): View {\n  const p = asXY(opts.pan);\n  const z = asXY(opts.zoom ?? 1);\n  const a = opts.anchor ?? { x: 0, y: 0 };\n  return {\n    x: a.x + (outer.x - a.x) * p.x,\n    y: a.y + (outer.y - a.y) * p.y,\n    scale: {\n      x: 1 + (outer.scale.x - 1) * z.x,\n      y: 1 + (outer.scale.y - 1) * z.y,\n    },\n  };\n}\n\n/** How a point of the camera's world lands in a plane's world, per axis:\n *  `plane = world * scale + offset`. A plane draws its content through its\n *  own view; this is what lets a pointer, a marquee or a selection box cross\n *  between that view and the camera's. */\nexport interface PlaneMap {\n  scale: { x: number; y: number };\n  offset: { x: number; y: number };\n}\n\n/** The map from `outer`'s world into the world of a plane drawn through\n *  `deriveParallaxView(outer, opts)` — the one that puts both points under the\n *  same pixel. */\nexport function planeMap(outer: View, opts: ParallaxOpts): PlaneMap {\n  const inner = deriveParallaxView(outer, opts);\n  const kx = outer.scale.x / inner.scale.x;\n  const ky = outer.scale.y / inner.scale.y;\n  return {\n    scale: { x: kx, y: ky },\n    offset: { x: inner.x - kx * outer.x, y: inner.y - ky * outer.y },\n  };\n}\n\n/** Map a point from the outer view's world into the plane's world. */\nexport function toPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: p.x * m.scale.x + m.offset.x, y: p.y * m.scale.y + m.offset.y };\n}\n\n/** Map a point from the plane's world back into the outer view's world. */\nexport function fromPlane(m: PlaneMap, p: { x: number; y: number }): { x: number; y: number } {\n  return { x: (p.x - m.offset.x) / m.scale.x, y: (p.y - m.offset.y) / m.scale.y };\n}\n\ninterface Rect { x: number; y: number; width: number; height: number }\n\nfunction mapRect(r: Rect, map: (p: { x: number; y: number }) => { x: number; y: number }): Rect {\n  const a = map({ x: r.x, y: r.y });\n  const b = map({ x: r.x + r.width, y: r.y + r.height });\n  return {\n    x: Math.min(a.x, b.x),\n    y: Math.min(a.y, b.y),\n    width: Math.abs(b.x - a.x),\n    height: Math.abs(b.y - a.y),\n  };\n}\n\n/** A camera-world rect in the plane's world. The map is axis-aligned, so a\n *  rect stays a rect; a flipped axis is normalized back to a positive size. */\nexport function rectToPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => toPlane(m, p)) };\n}\n\n/** A plane-world rect in the camera's world — see {@link rectToPlane}. */\nexport function rectFromPlane<R extends Rect>(m: PlaneMap, r: R): R {\n  return { ...r, ...mapRect(r, (p) => fromPlane(m, p)) };\n}\n\n/** The map from one world into another, where `null` is the camera's own:\n *  `fromPlane(from)`, then `toPlane(to)`. Null when the two are the same\n *  world, so a caller can skip the work. */\nexport function planeToPlane(from: PlaneMap | null, to: PlaneMap | null): PlaneMap | null {\n  if (from === to) return null;\n  const f = from ?? IDENTITY_MAP;\n  const t = to ?? IDENTITY_MAP;\n  const sx = t.scale.x / f.scale.x;\n  const sy = t.scale.y / f.scale.y;\n  const m = {\n    scale: { x: sx, y: sy },\n    offset: { x: t.offset.x - f.offset.x * sx, y: t.offset.y - f.offset.y * sy },\n  };\n  return m.scale.x === 1 && m.scale.y === 1 && m.offset.x === 0 && m.offset.y === 0 ? null : m;\n}\n\nconst IDENTITY_MAP: PlaneMap = { scale: { x: 1, y: 1 }, offset: { x: 0, y: 0 } };\n\n/** The map as an affine matrix in `@weasel-js/geom`'s `[a, b, c, d, e, f]`\n *  order, for `transformPath` and friends. */\nexport function planeMatrix(m: PlaneMap): [number, number, number, number, number, number] {\n  return [m.scale.x, 0, 0, m.scale.y, m.offset.x, m.offset.y];\n}\n"],"mappings":";AAgBA,SAASA,EAAK,GAAyC;CACrD,OAAO,OAAOC,KAAM,WAAW;EAAE,GAAGA;EAAG,GAAGA;CAAE,IAAIA;AAClD;AAaA,SAAgBC,EAAmB,GAAa,GAA0B;CACxE,IAAMC,IAAIH,EAAKI,EAAK,GAAG,GACjBC,IAAIL,EAAKI,EAAK,QAAQ,CAAC,GACvB,IAAIA,EAAK,UAAU;EAAE,GAAG;EAAG,GAAG;CAAE;CACtC,OAAO;EACL,GAAG,EAAE,KAAKE,EAAM,IAAI,EAAE,KAAKH,EAAE;EAC7B,GAAG,EAAE,KAAKG,EAAM,IAAI,EAAE,KAAKH,EAAE;EAC7B,OAAO;GACL,GAAG,KAAKG,EAAM,MAAM,IAAI,KAAKD,EAAE;GAC/B,GAAG,KAAKC,EAAM,MAAM,IAAI,KAAKD,EAAE;EACjC;CACF;AACF;AAcA,SAAgBE,EAAS,GAAa,GAA8B;CAClE,IAAMC,IAAQN,EAAmBI,GAAOF,CAAI,GACtCK,IAAKH,EAAM,MAAM,IAAIE,EAAM,MAAM,GACjCE,IAAKJ,EAAM,MAAM,IAAIE,EAAM,MAAM;CACvC,OAAO;EACL,OAAO;GAAE,GAAGC;GAAI,GAAGC;EAAG;EACtB,QAAQ;GAAE,GAAGF,EAAM,IAAIC,IAAKH,EAAM;GAAG,GAAGE,EAAM,IAAIE,IAAKJ,EAAM;EAAE;CACjE;AACF;AAGA,SAAgBK,EAAQ,GAAa,GAAuD;CAC1F,OAAO;EAAE,GAAGR,EAAE,IAAIS,EAAE,MAAM,IAAIA,EAAE,OAAO;EAAG,GAAGT,EAAE,IAAIS,EAAE,MAAM,IAAIA,EAAE,OAAO;CAAE;AAC5E;AAGA,SAAgBC,EAAU,GAAa,GAAuD;CAC5F,OAAO;EAAE,IAAIV,EAAE,IAAIS,EAAE,OAAO,KAAKA,EAAE,MAAM;EAAG,IAAIT,EAAE,IAAIS,EAAE,OAAO,KAAKA,EAAE,MAAM;CAAE;AAChF;AAIA,SAASE,EAAQ,GAAS,GAAsE;CAC9F,IAAMC,IAAIC,EAAI;EAAE,GAAGC,EAAE;EAAG,GAAGA,EAAE;CAAE,CAAC,GAC1BC,IAAIF,EAAI;EAAE,GAAGC,EAAE,IAAIA,EAAE;EAAO,GAAGA,EAAE,IAAIA,EAAE;CAAO,CAAC;CACrD,OAAO;EACL,GAAG,KAAK,IAAIF,EAAE,GAAGG,EAAE,CAAC;EACpB,GAAG,KAAK,IAAIH,EAAE,GAAGG,EAAE,CAAC;EACpB,OAAO,KAAK,IAAIA,EAAE,IAAIH,EAAE,CAAC;EACzB,QAAQ,KAAK,IAAIG,EAAE,IAAIH,EAAE,CAAC;CAC5B;AACF;AAIA,SAAgBI,EAA4B,GAAa,GAAS;CAChE,OAAO;EAAE,GAAGF;EAAG,GAAGH,EAAQG,IAAI,MAAMN,EAAQC,GAAGT,CAAC,CAAC;CAAE;AACrD;AAGA,SAAgBiB,EAA8B,GAAa,GAAS;CAClE,OAAO;EAAE,GAAGH;EAAG,GAAGH,EAAQG,IAAI,MAAMJ,EAAUD,GAAGT,CAAC,CAAC;CAAE;AACvD;AAKA,SAAgBkB,EAAa,GAAuB,GAAsC;CACxF,IAAIC,MAASC,GAAI,OAAO;CACxB,IAAMC,IAAIF,KAAQG,GACZC,IAAIH,KAAME,GACVE,IAAKD,EAAE,MAAM,IAAIF,EAAE,MAAM,GACzBI,IAAKF,EAAE,MAAM,IAAIF,EAAE,MAAM,GACzBZ,IAAI;EACR,OAAO;GAAE,GAAGe;GAAI,GAAGC;EAAG;EACtB,QAAQ;GAAE,GAAGF,EAAE,OAAO,IAAIF,EAAE,OAAO,IAAIG;GAAI,GAAGD,EAAE,OAAO,IAAIF,EAAE,OAAO,IAAII;EAAG;CAC7E;CACA,OAAOhB,EAAE,MAAM,MAAM,KAAKA,EAAE,MAAM,MAAM,KAAKA,EAAE,OAAO,MAAM,KAAKA,EAAE,OAAO,MAAM,IAAI,OAAOA;AAC7F;AAEA,IAAMa,IAAyB;CAAE,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;CAAG,QAAQ;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAI/E,SAAgBI,EAAY,GAA+D;CACzF,OAAO;EAACjB,EAAE,MAAM;EAAG;EAAG;EAAGA,EAAE,MAAM;EAAGA,EAAE,OAAO;EAAGA,EAAE,OAAO;CAAC;AAC5D"}

package/dist/core/viewport/pxExtent.js

@@ -0,0 +1,42 @@
+//#region src/core/viewport/pxExtent.ts
+function e(e, t, n = 0) {
+	if (!n) return {
+		x: e / Math.abs(t.x),
+		y: e / Math.abs(t.y)
+	};
+	let r = Math.cos(n), i = Math.sin(n);
+	return {
+		x: e * Math.hypot(r / t.x, i / t.y),
+		y: e * Math.hypot(i / t.x, r / t.y)
+	};
+}
+function t(e, t, n) {
+	return {
+		x: e * n.x,
+		y: t * n.y
+	};
+}
+function n(e, n, r, i) {
+	let a = t(e, n, i);
+	return Math.abs(a.x) <= r && Math.abs(a.y) <= r;
+}
+function r(e, n, r, i) {
+	let a = t(e, n, i);
+	return a.x * a.x + a.y * a.y <= r * r;
+}
+function i(e, t, n, r) {
+	let i = Math.sign(r.x * r.y) || 1, a = t.x * r.y * i, o = t.y * r.x * i, s = Math.hypot(a, o) || 1;
+	return a /= s, o /= s, {
+		x: e.x + a * n / r.x,
+		y: e.y + o * n / r.y,
+		nx: a,
+		ny: o
+	};
+}
+function a(e, t) {
+	return Math.atan2(Math.sin(e) * t.y, Math.cos(e) * t.x);
+}
+//#endregion
+export { e as pxExtent, t as scaleDelta, a as screenAngleOf, i as standoff, n as withinPxBox, r as withinPxRadius };
+
+//# sourceMappingURL=pxExtent.js.map

package/dist/core/viewport/pxExtent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pxExtent.js","names":["pxExtent","rotation","px","scale","c","s","scaleDelta","dx","dy","withinPxBox","withinPxRadius","standoff","k","nx","normal","ny","l","anchor","screenAngleOf"],"sources":["../../../src/core/viewport/pxExtent.ts"],"sourcesContent":["/**\n * Screen-pixel lengths in world units, per axis.\n *\n * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at\n * every zoom, because it paints in screen space. Converting one such length to\n * world units with a single scalar (see `meanScale`) is exact only under\n * uniform zoom; per-axis it is too generous on one axis and too mean on the\n * other, so the pickable region stops matching the painted one.\n *\n * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen\n * space and so can't drift from the paint at all. {@link pxExtent} is for the\n * cases that must stay in world units — a tolerance handed to geometry that\n * doesn't know about the view.\n */\n\nexport interface Scale2 {\n  x: number;\n  y: number;\n}\n\n/** One screen-pixel length as world-space extents, per axis. `scale` is a\n *  view's, so neither axis is zero (see `View`).\n *\n *  With `rotation`, the axes are a frame turned that far from world, and each\n *  extent is how far along it an edge across it must move to move `px` on\n *  screen — which, under non-uniform zoom, is not the extent along the screen\n *  axis nearest to it. */\nexport function pxExtent(px: number, scale: Scale2, rotation = 0): { x: number; y: number } {\n  if (!rotation) {\n    return {\n      x: px / Math.abs(scale.x),\n      y: px / Math.abs(scale.y),\n    };\n  }\n  const c = Math.cos(rotation), s = Math.sin(rotation);\n  return {\n    x: px * Math.hypot(c / scale.x, s / scale.y),\n    y: px * Math.hypot(s / scale.x, c / scale.y),\n  };\n}\n\n/** World delta → screen delta. Only the scale participates: translation\n *  cancels in a difference, and the kit's views carry no skew. */\nexport function scaleDelta(dx: number, dy: number, scale: Scale2): { x: number; y: number } {\n  return { x: dx * scale.x, y: dy * scale.y };\n}\n\n/**\n * Is a world-space delta inside a screen-space square of half-extent `px`?\n *\n * The square is axis-aligned **on screen**, which is what a handle painted in\n * screen space actually is — so this stays true under non-uniform zoom and\n * under a rotated target, where an axis-aligned world-space test is a rotated\n * rectangle on screen.\n */\nexport function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;\n}\n\n/** Is a world-space delta inside a screen-space circle of radius `px`? */\nexport function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return s.x * s.x + s.y * s.y <= px * px;\n}\n\n/**\n * A world point pushed `px` screen pixels off an edge, along the edge's normal\n * as it lands on screen. `normal` is the edge's outward normal in world space.\n *\n * Scaling the world normal by the view is not the same thing: under\n * non-uniform zoom the image of a normal is no longer perpendicular to the\n * image of its edge, so chrome placed that way drifts sideways and sits closer\n * than `px`. Returns the point in world coords and the on-screen unit normal.\n */\nexport function standoff(\n  anchor: { x: number; y: number },\n  normal: { x: number; y: number },\n  px: number,\n  scale: Scale2,\n): { x: number; y: number; nx: number; ny: number } {\n  // The edge's screen normal is S⁻ᵀn, here scaled by det S to stay finite.\n  const k = Math.sign(scale.x * scale.y) || 1;\n  let nx = normal.x * scale.y * k;\n  let ny = normal.y * scale.x * k;\n  const l = Math.hypot(nx, ny) || 1;\n  nx /= l;\n  ny /= l;\n  return { x: anchor.x + (nx * px) / scale.x, y: anchor.y + (ny * px) / scale.y, nx, ny };\n}\n\n/** The screen angle a frame turned `rotation` from world lands its x axis at.\n *  Equals `rotation` under uniform zoom; non-uniform zoom bends it. */\nexport function screenAngleOf(rotation: number, scale: Scale2): number {\n  return Math.atan2(Math.sin(rotation) * scale.y, Math.cos(rotation) * scale.x);\n}\n"],"mappings":";AA2BA,SAAgBA,EAAS,GAAY,GAAe,IAAW,GAA6B;CAC1F,IAAI,CAACC,GACH,OAAO;EACL,GAAGC,IAAK,KAAK,IAAIC,EAAM,CAAC;EACxB,GAAGD,IAAK,KAAK,IAAIC,EAAM,CAAC;CAC1B;CAEF,IAAMC,IAAI,KAAK,IAAIH,CAAQ,GAAGI,IAAI,KAAK,IAAIJ,CAAQ;CACnD,OAAO;EACL,GAAGC,IAAK,KAAK,MAAME,IAAID,EAAM,GAAGE,IAAIF,EAAM,CAAC;EAC3C,GAAGD,IAAK,KAAK,MAAMG,IAAIF,EAAM,GAAGC,IAAID,EAAM,CAAC;CAC7C;AACF;AAIA,SAAgBG,EAAW,GAAY,GAAY,GAAyC;CAC1F,OAAO;EAAE,GAAGC,IAAKJ,EAAM;EAAG,GAAGK,IAAKL,EAAM;CAAE;AAC5C;AAUA,SAAgBM,EAAY,GAAY,GAAY,GAAY,GAAwB;CACtF,IAAMJ,IAAIC,EAAWC,GAAIC,GAAIL,CAAK;CAClC,OAAO,KAAK,IAAIE,EAAE,CAAC,KAAKH,KAAM,KAAK,IAAIG,EAAE,CAAC,KAAKH;AACjD;AAGA,SAAgBQ,EAAe,GAAY,GAAY,GAAY,GAAwB;CACzF,IAAML,IAAIC,EAAWC,GAAIC,GAAIL,CAAK;CAClC,OAAOE,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,KAAKH,IAAKA;AACvC;AAWA,SAAgBS,EACd,GACA,GACA,GACA,GACkD;CAElD,IAAMC,IAAI,KAAK,KAAKT,EAAM,IAAIA,EAAM,CAAC,KAAK,GACtCU,IAAKC,EAAO,IAAIX,EAAM,IAAIS,GAC1BG,IAAKD,EAAO,IAAIX,EAAM,IAAIS,GACxBI,IAAI,KAAK,MAAMH,GAAIE,CAAE,KAAK;CAGhC,OAFA,KAAMC,GACN,KAAMA,GACC;EAAE,GAAGC,EAAO,IAAKJ,IAAKX,IAAMC,EAAM;EAAG,GAAGc,EAAO,IAAKF,IAAKb,IAAMC,EAAM;EAAG;EAAI;CAAG;AACxF;AAIA,SAAgBe,EAAc,GAAkB,GAAuB;CACrE,OAAO,KAAK,MAAM,KAAK,IAAIjB,CAAQ,IAAIE,EAAM,GAAG,KAAK,IAAIF,CAAQ,IAAIE,EAAM,CAAC;AAC9E"}

package/dist/core/viewport/sceneNodeClientRect.js

@@ -0,0 +1,18 @@
+import { viewToTransform as e } from "./view.js";
+import { worldToScreen as t } from "./viewTransform.js";
+//#region src/core/viewport/sceneNodeClientRect.ts
+function n(n) {
+	let r = n.getWorldBounds(n.id);
+	if (r === null) return null;
+	let i = e(n.view), [a, o] = t(r.x, r.y, i), s = n.canvas.getBoundingClientRect();
+	return {
+		x: s.left + a,
+		y: s.top + o,
+		width: r.width * n.view.scale.x,
+		height: r.height * n.view.scale.y
+	};
+}
+//#endregion
+export { n as sceneNodeClientRect };
+
+//# sourceMappingURL=sceneNodeClientRect.js.map

package/dist/core/viewport/sceneNodeClientRect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneNodeClientRect.js","names":["sceneNodeClientRect","bounds","opts","t","viewToTransform","sx","sy","worldToScreen","canvasRect"],"sources":["../../../src/core/viewport/sceneNodeClientRect.ts"],"sourcesContent":["import type { Bounds } from './fitViewToBounds';\nimport type { View } from './view';\nimport { viewToTransform } from './view';\nimport { worldToScreen } from './viewTransform';\n\n/** Options for {@link sceneNodeClientRect}. */\nexport interface SceneNodeClientRectOpts {\n  /** Node (or container) id to locate. */\n  id: string;\n  /**\n   * Resolve an id to its world-space AABB, or null when unknown.\n   * Typically adapts a pose resolver (e.g. from `composeSelectionPose`):\n   * `(id) => { const p = resolvePose(id); return p ? boundsOfPath(p) : null; }`\n   * — for rect poses the pose is its own AABB and can be returned directly.\n   */\n  getWorldBounds: (id: string) => Bounds | null;\n  /** Current viewport. */\n  view: View;\n  /** The canvas element — supplies the client-coordinate origin. */\n  canvas: Element;\n}\n\n/** Client-coordinate rect (viewport space) — the shape `Callout`'s `anchorRect` expects. */\nexport interface NodeClientRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * Project a scene node's world AABB to client (viewport) coordinates,\n * e.g. to anchor a `Callout` at a canvas-drawn object. Snapshot\n * semantics: the rect is where the node is *now* — it does not track\n * subsequent pan/zoom or scene mutations.\n */\nexport function sceneNodeClientRect(opts: SceneNodeClientRectOpts): NodeClientRect | null {\n  const bounds = opts.getWorldBounds(opts.id);\n  if (bounds === null) return null;\n  const t = viewToTransform(opts.view);\n  const [sx, sy] = worldToScreen(bounds.x, bounds.y, t);\n  const canvasRect = opts.canvas.getBoundingClientRect();\n  return {\n    x: canvasRect.left + sx,\n    y: canvasRect.top + sy,\n    width: bounds.width * opts.view.scale.x,\n    height: bounds.height * opts.view.scale.y,\n  };\n}\n"],"mappings":";;;AAoCA,SAAgBA,EAAoB,GAAsD;CACxF,IAAMC,IAASC,EAAK,eAAeA,EAAK,EAAE;CAC1C,IAAID,MAAW,MAAM,OAAO;CAC5B,IAAME,IAAIC,EAAgBF,EAAK,IAAI,GAC7B,CAACG,GAAIC,KAAMC,EAAcN,EAAO,GAAGA,EAAO,GAAGE,CAAC,GAC9CK,IAAaN,EAAK,OAAO,sBAAsB;CACrD,OAAO;EACL,GAAGM,EAAW,OAAOH;EACrB,GAAGG,EAAW,MAAMF;EACpB,OAAOL,EAAO,QAAQC,EAAK,KAAK,MAAM;EACtC,QAAQD,EAAO,SAASC,EAAK,KAAK,MAAM;CAC1C;AACF"}

package/dist/core/viewport/screenSlop.js

@@ -0,0 +1,27 @@
+import { multiply as e, rotate as t, scale as n } from "@weasel-js/geom";
+//#region src/core/viewport/screenSlop.ts
+function r(r, i = 0) {
+	if (r === void 0) return {
+		extra: 0,
+		opts: {}
+	};
+	if (typeof r == "number") return {
+		extra: r,
+		opts: {}
+	};
+	let a = n(r.scale.x, r.scale.y);
+	return {
+		extra: 0,
+		opts: { slop: {
+			px: r.px,
+			transform: i ? e(a, t(i)) : a
+		} }
+	};
+}
+function i(e) {
+	return e === void 0 ? !1 : typeof e == "number" ? e > 0 : e.px > 0;
+}
+//#endregion
+export { i as hasSlop, r as slopForStrokeHit };
+
+//# sourceMappingURL=screenSlop.js.map

package/dist/core/viewport/screenSlop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenSlop.js","names":["scaleMat","slopForStrokeHit","slop","s","scale","rotation","multiply","rotate","hasSlop"],"sources":["../../../src/core/viewport/screenSlop.ts"],"sourcesContent":["/**\n * Pointer forgiveness measured on screen.\n *\n * A pick slop is a screen distance: \"within 4px of the outline\". Converting it\n * to a world distance — per axis or as one scalar — is exact only when the\n * frame the geometry lives in reaches the screen by a similarity. A rotated\n * node under non-uniform zoom does not: a screen circle pulled back into its\n * frame is a tilted ellipse, so the test is run against the geometry's screen\n * image instead (`strokeHitTest`'s `slop`).\n */\nimport { multiply, rotate, scale as scaleMat, type Mat3 } from '@weasel-js/geom';\nimport type { Scale2 } from './pxExtent';\n\n/** `px` screen pixels under a view whose per-axis scale is `scale`. */\nexport interface ScreenSlop {\n  px: number;\n  scale: Scale2;\n}\n\n/** A slop in world units (a number, the view-less form) or on screen. */\nexport type PickSlop = number | ScreenSlop;\n\n/**\n * How `strokeHitTest` should apply a slop to geometry in a frame turned by\n * `rotation` from world: a world slop adds to the threshold, a screen slop is\n * handed over with the frame's map to the screen.\n */\nexport function slopForStrokeHit(\n  slop: PickSlop | undefined,\n  rotation = 0,\n): { extra: number; opts: { slop?: { px: number; transform: Mat3 } } } {\n  if (slop === undefined) return { extra: 0, opts: {} };\n  if (typeof slop === 'number') return { extra: slop, opts: {} };\n  const s = scaleMat(slop.scale.x, slop.scale.y);\n  return {\n    extra: 0,\n    opts: { slop: { px: slop.px, transform: rotation ? multiply(s, rotate(rotation)) : s } },\n  };\n}\n\n/** Is any slop set at all? A zero reach plus a zero slop hits nothing. */\nexport function hasSlop(slop: PickSlop | undefined): boolean {\n  if (slop === undefined) return false;\n  return typeof slop === 'number' ? slop > 0 : slop.px > 0;\n}\n"],"mappings":";;AA2BA,SAAgBC,EACd,GACA,IAAW,GAC0D;CACrE,IAAIC,MAAS,KAAA,GAAW,OAAO;EAAE,OAAO;EAAG,MAAM,CAAC;CAAE;CACpD,IAAI,OAAOA,KAAS,UAAU,OAAO;EAAE,OAAOA;EAAM,MAAM,CAAC;CAAE;CAC7D,IAAMC,IAAIH,EAASE,EAAK,MAAM,GAAGA,EAAK,MAAM,CAAC;CAC7C,OAAO;EACL,OAAO;EACP,MAAM,EAAE,MAAM;GAAE,IAAIA,EAAK;GAAI,WAAWG,IAAWC,EAASH,GAAGI,EAAOF,CAAQ,CAAC,IAAIF;EAAE,EAAE;CACzF;AACF;AAGA,SAAgBK,EAAQ,GAAqC;CAE3D,OADIN,MAAS,KAAA,IAAkB,KACxB,OAAOA,KAAS,WAAWA,IAAO,IAAIA,EAAK,KAAK;AACzD"}

package/dist/core/viewport/useAutoCenter.js

@@ -0,0 +1,32 @@
+import { fitZoom as e } from "./fitToBounds.js";
+import { useEffect as t, useRef as n } from "react";
+//#region src/core/viewport/useAutoCenter.ts
+function r(t, n, r, i, a = .85) {
+	let o = e(t * a, n * a, r, i), s = r * o, c = i * o;
+	return {
+		zoom: o,
+		panX: (t - s) / 2,
+		panY: (n - c) / 2
+	};
+}
+function i(e, i, a, o, s, c) {
+	let l = n(!1);
+	t(() => {
+		if (e > 0 && i > 0 && !l.current) {
+			l.current = !0;
+			let t = r(e, i, a, o);
+			s(t.zoom), c(t.panX, t.panY);
+		}
+	}, [
+		e,
+		i,
+		a,
+		o,
+		s,
+		c
+	]);
+}
+//#endregion
+export { r as computeFitViewport, i as useAutoCenter };
+
+//# sourceMappingURL=useAutoCenter.js.map

package/dist/core/viewport/useAutoCenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoCenter.js","names":["computeFitViewport","zoom","fitZoom","viewportW","padRatio","viewportH","contentW","contentH","cw","ch","useAutoCenter","hasCentered","useRef","width","height","fit","setZoom","setPan"],"sources":["../../../src/core/viewport/useAutoCenter.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\nimport { fitZoom } from './fitToBounds';\n\n/**\n * Compute zoom and pan that fit `contentW x contentH` (in content units)\n * inside `viewportW x viewportH` (in pixels). `padRatio` is the fraction of\n * each axis to fill (default 0.85 — leaves a uniform 15% margin).\n */\nexport function computeFitViewport(\n  viewportW: number,\n  viewportH: number,\n  contentW: number,\n  contentH: number,\n  padRatio = 0.85,\n): { zoom: number; panX: number; panY: number } {\n  const zoom = fitZoom(viewportW * padRatio, viewportH * padRatio, contentW, contentH);\n  const cw = contentW * zoom;\n  const ch = contentH * zoom;\n  return { zoom, panX: (viewportW - cw) / 2, panY: (viewportH - ch) / 2 };\n}\n\n/**\n * Run `computeFitViewport` once when the viewport first has non-zero size, and\n * apply the result via the supplied setters. Subsequent size changes are\n * ignored — this hook centers exactly once.\n */\nexport function useAutoCenter(\n  width: number,\n  height: number,\n  contentW: number,\n  contentH: number,\n  setZoom: (z: number) => void,\n  setPan: (x: number, y: number) => void,\n) {\n  const hasCentered = useRef(false);\n\n  useEffect(() => {\n    if (width > 0 && height > 0 && !hasCentered.current) {\n      hasCentered.current = true;\n      const fit = computeFitViewport(width, height, contentW, contentH);\n      setZoom(fit.zoom);\n      setPan(fit.panX, fit.panY);\n    }\n  }, [width, height, contentW, contentH, setZoom, setPan]);\n}\n"],"mappings":";;;AAQA,SAAgBA,EACd,GACA,GACA,GACA,GACA,IAAW,KACmC;CAC9C,IAAMC,IAAOC,EAAQC,IAAYC,GAAUC,IAAYD,GAAUE,GAAUC,CAAQ,GAC7EC,IAAKF,IAAWL,GAChBQ,IAAKF,IAAWN;CACtB,OAAO;EAAE;EAAM,OAAOE,IAAYK,KAAM;EAAG,OAAOH,IAAYI,KAAM;CAAE;AACxE;AAOA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,GACA;CACA,IAAMC,IAAcC,EAAO,EAAK;CAEhC,QAAgB;EACd,IAAIC,IAAQ,KAAKC,IAAS,KAAK,CAACH,EAAY,SAAS;GACnD,EAAY,UAAU;GACtB,IAAMI,IAAMf,EAAmBa,GAAOC,GAAQR,GAAUC,CAAQ;GAEhE,AADAS,EAAQD,EAAI,IAAI,GAChBE,EAAOF,EAAI,MAAMA,EAAI,IAAI;EAC3B;CACF,GAAG;EAACF;EAAOC;EAAQR;EAAUC;EAAUS;EAASC;CAAM,CAAC;AACzD"}

package/dist/core/viewport/useCanvasSize.js

@@ -0,0 +1,29 @@
+import { useDeviceProfile as e } from "../device/useDeviceProfile.js";
+import { useCallback as t, useEffect as n, useState as r } from "react";
+//#region src/core/viewport/useCanvasSize.ts
+function i(i) {
+	let { dpr: a } = e(), [o, s] = r({
+		width: 0,
+		height: 0
+	}), c = t(() => {
+		if (!i.current) return;
+		let e = i.current.getBoundingClientRect();
+		s((t) => t.width === e.width && t.height === e.height ? t : {
+			width: e.width,
+			height: e.height
+		});
+	}, [i]);
+	return n(() => {
+		c();
+		let e = new ResizeObserver(c);
+		return i.current && e.observe(i.current), () => e.disconnect();
+	}, [c, i]), {
+		width: o.width,
+		height: o.height,
+		dpr: a
+	};
+}
+//#endregion
+export { i as useCanvasSize };
+
+//# sourceMappingURL=useCanvasSize.js.map

package/dist/core/viewport/useCanvasSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasSize.js","names":["useCanvasSize","useDeviceProfile","size","setSize","useState","measure","useCallback","containerRef","rect","prev","useEffect","observer"],"sources":["../../../src/core/viewport/useCanvasSize.ts"],"sourcesContent":["import { type RefObject, useCallback, useEffect, useState } from 'react';\nimport type { CanvasSize } from './clampView';\nimport { useDeviceProfile } from '../device/useDeviceProfile';\n\n/** Size snapshot returned by `useCanvasSize` — the kit-wide `CanvasSize`\n *  (width × height in CSS pixels) plus the current devicePixelRatio. */\nexport interface CanvasSizeSnapshot extends CanvasSize {\n  dpr: number;\n}\n\n/** Track a container's content-rect size via `ResizeObserver`, and density via\n *  the ambient `DeviceProfile`.\n *\n *  This hook is the screen path's designated ambient-density source —\n *  rendering code should take density as a parameter (cf.\n *  `renderSceneToPixels`, `renderSceneToCanvas`'s `dpr`) rather than reading\n *  `window.devicePixelRatio` inline.\n *\n *  Density deliberately does NOT come from a `window.devicePixelRatio` read\n *  inside the resize callback: that only refreshes when the element resizes,\n *  so dragging a window to a different-density display without resizing it\n *  left the snapshot stale. The profile watches a re-armed resolution media\n *  query instead. */\nexport function useCanvasSize(containerRef: RefObject<HTMLElement | null>): CanvasSizeSnapshot {\n  const { dpr } = useDeviceProfile();\n  const [size, setSize] = useState<CanvasSize>({ width: 0, height: 0 });\n\n  const measure = useCallback(() => {\n    if (!containerRef.current) return;\n    const rect = containerRef.current.getBoundingClientRect();\n    setSize((prev) =>\n      prev.width === rect.width && prev.height === rect.height\n        ? prev\n        : { width: rect.width, height: rect.height },\n    );\n  }, [containerRef]);\n\n  useEffect(() => {\n    measure();\n    const observer = new ResizeObserver(measure);\n    if (containerRef.current) {\n      observer.observe(containerRef.current);\n    }\n    return () => observer.disconnect();\n  }, [measure, containerRef]);\n\n  return { width: size.width, height: size.height, dpr };\n}\n"],"mappings":";;;AAuBA,SAAgBA,EAAc,GAAiE;CAC7F,IAAM,EAAE,WAAQC,EAAiB,GAC3B,CAACC,GAAMC,KAAWC,EAAqB;EAAE,OAAO;EAAG,QAAQ;CAAE,CAAC,GAE9DC,IAAUC,QAAkB;EAChC,IAAI,CAACC,EAAa,SAAS;EAC3B,IAAMC,IAAOD,EAAa,QAAQ,sBAAsB;EACxD,GAAS,MACPE,EAAK,UAAUD,EAAK,SAASC,EAAK,WAAWD,EAAK,SAC9CC,IACA;GAAE,OAAOD,EAAK;GAAO,QAAQA,EAAK;EAAO,CAC/C;CACF,GAAG,CAACD,CAAY,CAAC;CAWjB,OATAG,QAAgB;EACd,EAAQ;EACR,IAAMC,IAAW,IAAI,eAAeN,CAAO;EAI3C,OAHIE,EAAa,WACfI,EAAS,QAAQJ,EAAa,OAAO,SAE1BI,EAAS,WAAW;CACnC,GAAG,CAACN,GAASE,CAAY,CAAC,GAEnB;EAAE,OAAOL,EAAK;EAAO,QAAQA,EAAK;EAAQ;CAAI;AACvD"}

package/dist/core/viewport/useDecayLoop.js

@@ -0,0 +1,63 @@
+import { useVisibleRaf as e } from "../../scheduling/useVisibleRaf.js";
+import { useCallback as t, useEffect as n, useRef as r } from "react";
+//#region src/core/viewport/useDecayLoop.ts
+var i = .5;
+function a() {
+	let a = r(null), o = e((e) => {
+		c(e);
+	}, { onResume: t(() => {
+		a.current && (a.current.lastTime = null);
+	}, []) }), s = t(() => {
+		o.cancel(), a.current = null;
+	}, [o]), c = t((e) => {
+		let t = a.current;
+		if (!t) return;
+		if (t.lastTime === null) {
+			t.lastTime = e, o.request();
+			return;
+		}
+		let n = Math.min(e - t.lastTime, 64);
+		t.lastTime = e;
+		let r = t.friction ** (n / 16.67);
+		if (t.vx *= r, t.vy *= r, Math.sqrt(t.vx * t.vx + t.vy * t.vy) < t.minSpeed) {
+			a.current = null, o.cancel(), t.onEnd?.();
+			return;
+		}
+		let s = t.vx * n, c = t.vy * n;
+		if (t.viewBounds && t.boundary) {
+			let { minX: e, maxX: n, minY: r, maxY: a } = t.viewBounds, o = t.posX + s, l = t.posY + c;
+			t.boundary === "stop" ? (e !== void 0 && o < e ? (s = e - t.posX, t.vx = 0) : n !== void 0 && o > n && (s = n - t.posX, t.vx = 0), r !== void 0 && l < r ? (c = r - t.posY, t.vy = 0) : a !== void 0 && l > a && (c = a - t.posY, t.vy = 0)) : t.boundary === "spring" ? (e !== void 0 && o < e ? (s = e - t.posX, t.vx = Math.abs(t.vx) * i) : n !== void 0 && o > n && (s = n - t.posX, t.vx = -Math.abs(t.vx) * i), r !== void 0 && l < r ? (c = r - t.posY, t.vy = Math.abs(t.vy) * i) : a !== void 0 && l > a && (c = a - t.posY, t.vy = -Math.abs(t.vy) * i)) : (e !== void 0 && o < e ? (s = e - t.posX, t.vx = Math.abs(t.vx)) : n !== void 0 && o > n && (s = n - t.posX, t.vx = -Math.abs(t.vx)), r !== void 0 && l < r ? (c = r - t.posY, t.vy = Math.abs(t.vy)) : a !== void 0 && l > a && (c = a - t.posY, t.vy = -Math.abs(t.vy))), t.posX += s, t.posY += c;
+		}
+		t.onTick(s, c), o.request();
+	}, [o]), l = t((e) => {
+		s();
+		let { velocity: t, friction: n = .92, minSpeed: r = .01, viewBounds: i, boundary: c, initialPosition: l, onTick: u, onEnd: d } = e;
+		if (Math.sqrt(t.vx ** 2 + t.vy ** 2) < r) {
+			d?.();
+			return;
+		}
+		a.current = {
+			vx: t.vx,
+			vy: t.vy,
+			friction: n,
+			minSpeed: r,
+			lastTime: null,
+			posX: l?.x ?? 0,
+			posY: l?.y ?? 0,
+			viewBounds: i,
+			boundary: c,
+			onTick: u,
+			onEnd: d
+		}, o.request();
+	}, [s, o]);
+	return n(() => () => {
+		s();
+	}, [s]), {
+		start: l,
+		cancel: s
+	};
+}
+//#endregion
+export { a as useDecayLoop };
+
+//# sourceMappingURL=useDecayLoop.js.map

package/dist/core/viewport/useDecayLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDecayLoop.js","names":["SPRING_DAMPING","useDecayLoop","stateRef","useRef","frameLoop","useVisibleRaf","now","useCallback","cancel","tick","s","dt","f","dx","dy","newX","newY","minX","maxX","minY","maxY","start","config","velocity","minSpeed","initialPosition","useEffect"],"sources":["../../../src/core/viewport/useDecayLoop.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\nimport { useVisibleRaf } from '../../scheduling/useVisibleRaf';\n\n/** Per-axis limits on a view's position. Any side may be left open. */\nexport interface PanBounds {\n  minX?: number;\n  maxX?: number;\n  minY?: number;\n  maxY?: number;\n}\n\n/** Momentum settings for a pan: how quickly a flung view slows, when it stops,\n *  and what happens at the pan limits. The `DecayLoopConfig` fields a caller\n *  chooses up front, without the per-gesture `velocity` / `onTick`. */\nexport interface InertiaConfig {\n  friction?: number;\n  minSpeed?: number;\n  /** What to do when inertial pan reaches `bounds`. Default: no clamping. */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** View-coordinate limits for boundary clamping. Requires `boundary` to take effect. */\n  bounds?: PanBounds;\n}\n\n/** How a decay should run: its starting velocity, how fast it slows, and what\n *  happens if it reaches the pan limits. */\nexport interface DecayLoopConfig {\n  velocity: { vx: number; vy: number };\n  friction?: number;\n  minSpeed?: number;\n  /** Bounds for boundary clamping. Requires `boundary` to take effect. */\n  viewBounds?: PanBounds;\n  /**\n   * What to do when the accumulated position hits `viewBounds`. Default: no clamping.\n   * - `'stop'`: clamp at boundary, kill velocity component.\n   * - `'bounce'`: linear reflection — flip velocity sign, magnitude preserved.\n   * - `'spring'`: damped reflection — flip velocity sign and shrink magnitude\n   *   by `SPRING_DAMPING` per bounce so the motion settles naturally.\n   */\n  boundary?: 'stop' | 'bounce' | 'spring';\n  /** Starting position for internal boundary tracking. Required when `viewBounds` is set. */\n  initialPosition?: { x: number; y: number };\n  onTick: (dx: number, dy: number) => void;\n  onEnd?: () => void;\n}\n\n/**\n * Fraction of velocity preserved per `'spring'` bounce. 0.5 means each bounce\n * loses half its energy, giving a quick visible settle (typically 2–4 bounces\n * before `minSpeed` cuts the loop). Fixed for v1; a future `bounceDamping`\n * config option could expose this if a consumer needs control.\n */\nconst SPRING_DAMPING = 0.5;\n\n/** A rAF loop that coasts a value to a stop under friction, reporting the\n *  per-frame delta. What turns a released pan drag into momentum scrolling. */\nexport function useDecayLoop() {\n  const stateRef = useRef<{\n    vx: number; vy: number;\n    friction: number; minSpeed: number;\n    lastTime: number | null;\n    posX: number; posY: number;\n    viewBounds: PanBounds | undefined;\n    boundary: 'stop' | 'bounce' | 'spring' | undefined;\n    onTick: (dx: number, dy: number) => void;\n    onEnd?: () => void;\n  } | null>(null);\n\n  const frameLoop = useVisibleRaf(\n    (now: number) => { tick(now); },\n    {\n      // Coasting does not continue while suspended: dropping `lastTime` makes\n      // the resuming frame seed a fresh interval instead of applying an hour of\n      // friction at once, which would end the decay before it was seen.\n      onResume: useCallback(() => {\n        if (stateRef.current) stateRef.current.lastTime = null;\n      }, []),\n    },\n  );\n\n  const cancel = useCallback(() => {\n    frameLoop.cancel();\n    stateRef.current = null;\n  }, [frameLoop]);\n\n  const tick = useCallback((now: number) => {\n    const s = stateRef.current;\n    if (!s) return;\n    if (s.lastTime === null) {\n      s.lastTime = now;\n      frameLoop.request();\n      return;\n    }\n    const dt = Math.min(now - s.lastTime, 64);  // cap at 64ms to avoid huge jumps\n    s.lastTime = now;\n    // Time-normalize friction to 60fps baseline\n    const f = Math.pow(s.friction, dt / 16.67);\n    s.vx *= f;\n    s.vy *= f;\n    const speed = Math.sqrt(s.vx * s.vx + s.vy * s.vy);\n    if (speed < s.minSpeed) {\n      stateRef.current = null;\n      frameLoop.cancel();\n      s.onEnd?.();\n      return;\n    }\n    let dx = s.vx * dt;\n    let dy = s.vy * dt;\n    if (s.viewBounds && s.boundary) {\n      const { minX, maxX, minY, maxY } = s.viewBounds;\n      const newX = s.posX + dx;\n      const newY = s.posY + dy;\n      if (s.boundary === 'stop') {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = 0; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = 0; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = 0; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = 0; }\n      } else if (s.boundary === 'spring') {\n        // Damped reflection: flip sign AND scale magnitude by SPRING_DAMPING so\n        // each bounce loses energy. Once |v| < minSpeed the outer loop ends.\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx) * SPRING_DAMPING; }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx) * SPRING_DAMPING; }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy) * SPRING_DAMPING; }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy) * SPRING_DAMPING; }\n      } else {\n        if (minX !== undefined && newX < minX) { dx = minX - s.posX; s.vx = Math.abs(s.vx); }\n        else if (maxX !== undefined && newX > maxX) { dx = maxX - s.posX; s.vx = -Math.abs(s.vx); }\n        if (minY !== undefined && newY < minY) { dy = minY - s.posY; s.vy = Math.abs(s.vy); }\n        else if (maxY !== undefined && newY > maxY) { dy = maxY - s.posY; s.vy = -Math.abs(s.vy); }\n      }\n      s.posX += dx;\n      s.posY += dy;\n    }\n    s.onTick(dx, dy);\n    frameLoop.request();\n  }, [frameLoop]);\n\n  const start = useCallback((config: DecayLoopConfig) => {\n    cancel();\n    const { velocity, friction = 0.92, minSpeed = 0.01, viewBounds, boundary, initialPosition, onTick, onEnd } = config;\n    const speed = Math.sqrt(velocity.vx ** 2 + velocity.vy ** 2);\n    if (speed < minSpeed) { onEnd?.(); return; }\n    stateRef.current = {\n      vx: velocity.vx, vy: velocity.vy, friction, minSpeed, lastTime: null,\n      posX: initialPosition?.x ?? 0, posY: initialPosition?.y ?? 0,\n      viewBounds, boundary,\n      onTick, onEnd,\n    };\n    frameLoop.request();\n  }, [cancel, frameLoop]);\n\n  useEffect(() => () => { cancel(); }, [cancel]);\n\n  return { start, cancel };\n}\n"],"mappings":"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"}

package/dist/core/viewport/useVelocityTracker.js

@@ -0,0 +1,10 @@
+import { createVelocityTracker as e } from "./createVelocityTracker.js";
+import { useMemo as t } from "react";
+//#region src/core/viewport/useVelocityTracker.ts
+function n() {
+	return t(() => e(), []);
+}
+//#endregion
+export { n as useVelocityTracker };
+
+//# sourceMappingURL=useVelocityTracker.js.map

package/dist/core/viewport/useVelocityTracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVelocityTracker.js","names":["useVelocityTracker","useMemo","createVelocityTracker"],"sources":["../../../src/core/viewport/useVelocityTracker.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { createVelocityTracker, type VelocityTracker } from './createVelocityTracker';\n\nexport type { VelocityTracker };\n\n/** Records recent pointer deltas and reports the current velocity, averaged\n *  over the last 100ms — the throw speed a momentum decay starts from. */\nexport function useVelocityTracker(): VelocityTracker {\n  return useMemo(() => createVelocityTracker(), []);\n}\n"],"mappings":";;;AAOA,SAAgBA,IAAsC;CACpD,OAAOC,QAAcC,EAAsB,GAAG,CAAC,CAAC;AAClD"}

package/dist/core/viewport/useViewAnimation.js

@@ -0,0 +1,63 @@
+import { normalizeView as e } from "./view.js";
+import { fitViewToBounds as t } from "./fitViewToBounds.js";
+import { interpolateView as n } from "./interpolateView.js";
+import { useAnimator as r } from "../../animation/useAnimator.js";
+import { easeOutCubic as i } from "@weasel-js/geom";
+import { useId as a, useMemo as o, useRef as s } from "react";
+import { useLatest as c } from "@weasel-js/react";
+//#region src/core/viewport/useViewAnimation.ts
+var l = "view", u = 250;
+function d(e, t) {
+	let n = r();
+	return f(e, t ?? n);
+}
+function f(r, d) {
+	let f = `${l}:${a()}`, p = c(r), m = c(d), h = s(null), g = s(!1);
+	return o(() => {
+		let r = () => m.current.isActive(f), a = () => r() ? h.current : null, o = () => {
+			m.current.cancelKey(f), h.current = null;
+		}, s = (t, r = {}) => {
+			let s = p.current.get(), c = e(typeof t == "function" ? t(a() ?? s) : t);
+			o(), h.current = c, m.current.tween({
+				from: s,
+				to: c,
+				ms: r.ms ?? u,
+				easing: r.easing ?? i,
+				interpolator: r.interpolator ?? n,
+				cancelKey: f,
+				onTick: (e) => {
+					g.current = !0;
+					try {
+						p.current.set(e);
+					} finally {
+						g.current = !1;
+					}
+				},
+				onDone: () => {
+					h.current = null, r.onDone?.();
+				}
+			});
+		};
+		return {
+			animate: s,
+			animateToBounds: (e, n, r = {}) => {
+				let i = p.current.get(), a = t(e, n, i, r);
+				a !== i && s(a, r);
+			},
+			stop: o,
+			isAnimating: r,
+			target: a,
+			stopIfExternal: () => {
+				g.current || o();
+			}
+		};
+	}, [
+		f,
+		p,
+		m
+	]);
+}
+//#endregion
+export { l as VIEW_ANIMATION_KEY, d as useViewAnimation, f as useViewAnimationOn };
+
+//# sourceMappingURL=useViewAnimation.js.map

package/dist/core/viewport/useViewAnimation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewAnimation.js","names":["VIEW_ANIMATION_KEY","DEFAULT_MS","useViewAnimation","own","useAnimator","useViewAnimationOn","view","animator","key","useId","viewRef","useLatest","animatorRef","targetRef","useRef","writingRef","useMemo","isAnimating","target","stop","animate","from","resolved","normalizeView","to","opts","easeOutCubic","interpolateView","v","current","fitted","fitViewToBounds","bounds","dims"],"sources":["../../../src/core/viewport/useViewAnimation.ts"],"sourcesContent":["import { useId, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useAnimator } from '../../animation/useAnimator';\nimport { easeOutCubic } from '@weasel-js/geom';\nimport type { Animator, EasingSpec, InterpolatorFactory } from '../../animation/types';\nimport { interpolateView } from './interpolateView';\nimport { fitViewToBounds } from './fitViewToBounds';\nimport type { Bounds, FitViewToBoundsOptions, ViewportDims } from './fitViewToBounds';\nimport { normalizeView, type View } from './view';\n\n/** Cancel-key prefix. Each hook instance appends its own id, so two runners\n *  sharing an animator do not cancel each other. */\nexport const VIEW_ANIMATION_KEY = 'view';\n\nconst DEFAULT_MS = 250;\n\n/** How the camera should move. */\nexport interface ViewAnimationOptions {\n  /** Duration in ms. Default 250. */\n  ms?: number;\n  /** Easing curve. Default `easeOutCubic`. */\n  easing?: EasingSpec;\n  /** Replace the kit's log-scale / fixed-anchor curve. */\n  interpolator?: InterpolatorFactory<View>;\n  /** Fires when the target is reached. Not called on cancel. */\n  onDone?: () => void;\n}\n\n/** Options accepted by {@link ViewAnimationApi.animateToBounds}. */\nexport interface AnimateToBoundsOptions extends FitViewToBoundsOptions, ViewAnimationOptions {}\n\n/** What the runner reads and writes. On `<SceneCanvas>` this is the same\n *  channel `view.set` uses, so a camera animation on an uncontrolled canvas\n *  costs no React render. */\nexport interface ViewChannel {\n  get(): View;\n  set(v: View): void;\n}\n\n/** The camera animation surface. One animation at a time. */\nexport interface ViewAnimationApi {\n  /** Glide from the live view to `to`. A thunk receives the pending target when\n   *  one is in flight, so successive discrete steps compound. */\n  animate(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;\n  /** `fitViewToBounds` composed with `animate`. */\n  animateToBounds(bounds: Bounds, dims: ViewportDims, opts?: AnimateToBoundsOptions): void;\n  /** Cancel. The view stays where it is — no jump to the target. */\n  stop(): void;\n  isAnimating(): boolean;\n  /** Where the in-flight animation is heading, or null when none is. */\n  target(): View | null;\n  /** Cancel unless the write that prompted this came from the runner's own\n   *  per-frame write. Feed it from every channel that can move the camera. */\n  stopIfExternal(): void;\n}\n\n/**\n * Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to\n * share a canvas's animator, or omit it and the hook makes its own. A caller\n * that always has one should use {@link useViewAnimationOn}, which builds none.\n *\n * Every animation from one instance registers under that instance's cancel key,\n * so starting one cancels whatever *it* had in flight, and each starts from the\n * *live* view rather than a captured value — an interrupted camera never jumps.\n * Two instances on one animator are independent.\n */\nexport function useViewAnimation(view: ViewChannel, animator?: Animator): ViewAnimationApi {\n  const own = useAnimator();\n  return useViewAnimationOn(view, animator ?? own);\n}\n\n/** {@link useViewAnimation} on an animator the caller owns. Constructs no\n *  animator of its own, so the camera runs on exactly the one passed. */\nexport function useViewAnimationOn(view: ViewChannel, animator: Animator): ViewAnimationApi {\n  const key = `${VIEW_ANIMATION_KEY}:${useId()}`;\n  const viewRef = useLatest(view);\n  const animatorRef = useLatest(animator);\n  const targetRef = useRef<View | null>(null);\n  const writingRef = useRef(false);\n\n  return useMemo<ViewAnimationApi>(() => {\n    const isAnimating = () => animatorRef.current.isActive(key);\n    const target = () => (isAnimating() ? targetRef.current : null);\n    const stop = () => {\n      animatorRef.current.cancelKey(key);\n      targetRef.current = null;\n    };\n\n    const animate: ViewAnimationApi['animate'] = (to, opts = {}) => {\n      const from = viewRef.current.get();\n      const resolved = normalizeView(typeof to === 'function' ? to(target() ?? from) : to);\n      stop();\n      targetRef.current = resolved;\n      animatorRef.current.tween<View>({\n        from,\n        to: resolved,\n        ms: opts.ms ?? DEFAULT_MS,\n        easing: opts.easing ?? easeOutCubic,\n        interpolator: opts.interpolator ?? interpolateView,\n        cancelKey: key,\n        onTick: (v) => {\n          writingRef.current = true;\n          try { viewRef.current.set(v); } finally { writingRef.current = false; }\n        },\n        onDone: () => {\n          targetRef.current = null;\n          opts.onDone?.();\n        },\n      });\n    };\n\n    return {\n      animate,\n      animateToBounds: (bounds, dims, opts = {}) => {\n        const current = viewRef.current.get();\n        const fitted = fitViewToBounds(bounds, dims, current, opts);\n        if (fitted === current) return; // helper bailed (zero-area bounds/viewport)\n        animate(fitted, opts);\n      },\n      stop,\n      isAnimating,\n      target,\n      stopIfExternal: () => { if (!writingRef.current) stop(); },\n    };\n  }, [key, viewRef, animatorRef]);\n}\n"],"mappings":";;;;;;;;AAYA,IAAaA,IAAqB,QAE5BC,IAAa;AAoDnB,SAAgBC,EAAiB,GAAmB,GAAuC;CACzF,IAAMC,IAAMC,EAAY;CACxB,OAAOC,EAAmBC,GAAMC,KAAYJ,CAAG;AACjD;AAIA,SAAgBE,EAAmB,GAAmB,GAAsC;CAC1F,IAAMG,IAAM,GAAGR,EAAmB,GAAGS,EAAM,KACrCC,IAAUC,EAAUL,CAAI,GACxBM,IAAcD,EAAUJ,CAAQ,GAChCM,IAAYC,EAAoB,IAAI,GACpCC,IAAaD,EAAO,EAAK;CAE/B,OAAOE,QAAgC;EACrC,IAAMC,UAAoBL,EAAY,QAAQ,SAASJ,CAAG,GACpDU,UAAgBD,EAAY,IAAIJ,EAAU,UAAU,MACpDM,UAAa;GAEjB,AADAP,EAAY,QAAQ,UAAUJ,CAAG,GACjC,EAAU,UAAU;EACtB,GAEMY,KAAwC,GAAI,IAAO,CAAC,MAAM;GAC9D,IAAMC,IAAOX,EAAQ,QAAQ,IAAI,GAC3BY,IAAWC,EAAc,OAAOC,KAAO,aAAaA,EAAGN,EAAO,KAAKG,CAAI,IAAIG,CAAE;GAGnF,AAFAL,EAAK,GACL,EAAU,UAAUG,GACpBV,EAAY,QAAQ,MAAY;IAC9B;IACA,IAAIU;IACJ,IAAIG,EAAK,MAAMxB;IACf,QAAQwB,EAAK,UAAUC;IACvB,cAAcD,EAAK,gBAAgBE;IACnC,WAAWnB;IACX,SAAS,MAAM;KACb,EAAW,UAAU;KACrB,IAAI;MAAE,EAAQ,QAAQ,IAAIoB,CAAC;KAAG,UAAU;MAAE,EAAW,UAAU;KAAO;IACxE;IACA,cAAc;KAEZ,AADA,EAAU,UAAU,MACpBH,EAAK,SAAS;IAChB;GACF,CAAC;EACH;EAEA,OAAO;GACL;GACA,kBAAkB,GAAQ,GAAM,IAAO,CAAC,MAAM;IAC5C,IAAMI,IAAUnB,EAAQ,QAAQ,IAAI,GAC9BoB,IAASC,EAAgBC,GAAQC,GAAMJ,GAASJ,CAAI;IAC1D,AAAIK,MAAWD,KACfT,EAAQU,GAAQL,CAAI;GACtB;GACA;GACA;GACA;GACA,sBAAsB;IAAE,AAAKV,EAAW,WAASI,EAAK;GAAG;EAC3D;CACF,GAAG;EAACX;EAAKE;EAASE;CAAW,CAAC;AAChC"}

package/dist/core/viewport/view.js

@@ -0,0 +1,37 @@
+import { normalizeZoom as e, warnInvalidView as t } from "./zoomBounds.js";
+//#region src/core/viewport/view.ts
+function n(e) {
+	return {
+		panX: -e.x * e.scale.x + 0,
+		panY: -e.y * e.scale.y + 0,
+		zoom: {
+			x: e.scale.x,
+			y: e.scale.y
+		}
+	};
+}
+function r(e) {
+	let { x: t, y: n } = e.scale;
+	return t === n ? t : Math.sqrt(t * n);
+}
+function i(e) {
+	let t = a(e.scale.x), n = a(e.scale.y), r = o(e.x), i = o(e.y);
+	return t === e.scale.x && n === e.scale.y && r === e.x && i === e.y ? e : {
+		x: r,
+		y: i,
+		scale: {
+			x: t,
+			y: n
+		}
+	};
+}
+function a(t) {
+	return t < 0 && t > -Infinity ? -e(-t) : e(t);
+}
+function o(e) {
+	return Number.isFinite(e) ? e : (t(`a position of ${e}`), 0);
+}
+//#endregion
+export { i as normalizeView, n as viewToTransform, r as viewZoom };
+
+//# sourceMappingURL=view.js.map

package/dist/core/viewport/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","names":["viewToTransform","view","viewZoom","x","y","normalizeView","sx","normalizeAxis","sy","finiteTranslation","s","normalizeZoom","v","warnInvalidView"],"sources":["../../../src/core/viewport/view.ts"],"sourcesContent":["import type { ViewTransform } from './viewTransform';\nimport type { View } from '@weasel-js/routing';\nimport { normalizeZoom, warnInvalidView } from './zoomBounds';\n\n/**\n * `View` is declared in `@weasel-js/routing` — the dispatcher and every\n * viewport action are typed in it. Re-exported here, where core's own call\n * sites have always named it.\n *\n * Core holds the invariant behind the shape: every view the kit keeps is\n * total, so each `scale` axis is finite with a magnitude of at least\n * `ZOOM_FLOOR` and `x` / `y` are finite. A negative axis is a flipped one\n * (y-up), not a degenerate one, and keeps its sign. Canvases, views and\n * animations pass what they are given through {@link normalizeView}, so\n * screen/world conversion never divides by zero.\n *\n * `scale` is always a 2-vector. Input convenience types {@link ZoomFactor}\n * and {@link ZoomBound} let callers pass a scalar when they want both axes\n * treated the same.\n */\nexport type { View };\n\n/**\n * Input convenience for zoom primitives. A `number` is treated as a\n * uniform factor applied to both axes; a `{x, y}` vector applies\n * per-axis factors.\n */\nexport type ZoomFactor = number | { x: number; y: number };\n\n/**\n * Input convenience for zoom-clamp ranges. A `number` is applied as the\n * same bound on both axes; a `{x, y}` vector applies per-axis bounds.\n */\nexport type ZoomBound = number | { x: number; y: number };\n\n/**\n * Bridge `View` into the legacy `ViewTransform` shape so chrome can keep\n * calling `worldToScreen` / `screenToWorld`. `View` and `ViewTransform`\n * use opposite sign conventions for the translation half (`view.x` is\n * camera position; `panX` is canvas translation), so the adapter flips\n * the sign and multiplies by per-axis scale.\n */\nexport function viewToTransform(view: View): ViewTransform {\n  // `+ 0` coerces `-0 → 0` without swallowing NaN (matches viewToMat3).\n  return {\n    panX: -view.x * view.scale.x + 0,\n    panY: -view.y * view.scale.y + 0,\n    zoom: { x: view.scale.x, y: view.scale.y },\n  };\n}\n\n/**\n * How far `view` is zoomed in, as one number — the geometric mean of its two\n * axes, so a uniform view reports its own scale and a stretched one reports\n * the scale that covers the same area.\n *\n * What a `RuleCtx` carries, because the only rule that asks about the\n * viewport asks for a threshold rather than a camera.\n */\nexport function viewZoom(view: View): number {\n  const { x, y } = view.scale;\n  return x === y ? x : Math.sqrt(x * y);\n}\n\n/**\n * `view` inside the invariant {@link View} documents: a zero or non-finite\n * scale axis becomes `ZOOM_FLOOR`, a negative one keeps its sign, and a\n * non-finite translation becomes 0. Returns `view` itself when it already\n * holds, so a valid view keeps its identity.\n */\nexport function normalizeView(view: View): View {\n  const sx = normalizeAxis(view.scale.x);\n  const sy = normalizeAxis(view.scale.y);\n  const x = finiteTranslation(view.x);\n  const y = finiteTranslation(view.y);\n  if (sx === view.scale.x && sy === view.scale.y && x === view.x && y === view.y) return view;\n  return { x, y, scale: { x: sx, y: sy } };\n}\n\nfunction normalizeAxis(s: number): number {\n  return s < 0 && s > -Infinity ? -normalizeZoom(-s) : normalizeZoom(s);\n}\n\nfunction finiteTranslation(v: number): number {\n  if (Number.isFinite(v)) return v;\n  warnInvalidView(`a position of ${v}`);\n  return 0;\n}\n"],"mappings":";;AA0CA,SAAgBA,EAAgB,GAA2B;CAEzD,OAAO;EACL,MAAM,CAACC,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM,CAACA,EAAK,IAAIA,EAAK,MAAM,IAAI;EAC/B,MAAM;GAAE,GAAGA,EAAK,MAAM;GAAG,GAAGA,EAAK,MAAM;EAAE;CAC3C;AACF;AAUA,SAAgBC,EAAS,GAAoB;CAC3C,IAAM,EAAE,MAAG,SAAMD,EAAK;CACtB,OAAOE,MAAMC,IAAID,IAAI,KAAK,KAAKA,IAAIC,CAAC;AACtC;AAQA,SAAgBC,EAAc,GAAkB;CAC9C,IAAMC,IAAKC,EAAcN,EAAK,MAAM,CAAC,GAC/BO,IAAKD,EAAcN,EAAK,MAAM,CAAC,GAC/BE,IAAIM,EAAkBR,EAAK,CAAC,GAC5BG,IAAIK,EAAkBR,EAAK,CAAC;CAElC,OADIK,MAAOL,EAAK,MAAM,KAAKO,MAAOP,EAAK,MAAM,KAAKE,MAAMF,EAAK,KAAKG,MAAMH,EAAK,IAAUA,IAChF;EAAE;EAAG;EAAG,OAAO;GAAE,GAAGK;GAAI,GAAGE;EAAG;CAAE;AACzC;AAEA,SAASD,EAAc,GAAmB;CACxC,OAAOG,IAAI,KAAKA,IAAI,YAAY,CAACC,EAAc,CAACD,CAAC,IAAIC,EAAcD,CAAC;AACtE;AAEA,SAASD,EAAkB,GAAmB;CAG5C,OAFI,OAAO,SAASG,CAAC,IAAUA,KAC/BC,EAAgB,iBAAiBD,GAAG,GAC7B;AACT"}

package/dist/core/viewport/viewTransform.js

@@ -0,0 +1,11 @@
+//#region src/core/viewport/viewTransform.ts
+function e(e, t, n) {
+	return [n.panX + e * n.zoom.x, n.panY + t * n.zoom.y];
+}
+function t(e, t, n) {
+	return [(e - n.panX) / n.zoom.x, (t - n.panY) / n.zoom.y];
+}
+//#endregion
+export { t as screenToWorld, e as worldToScreen };
+
+//# sourceMappingURL=viewTransform.js.map

package/dist/core/viewport/viewTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewTransform.js","names":["worldToScreen","view","worldX","worldY","screenToWorld","screenX","screenY"],"sources":["../../../src/core/viewport/viewTransform.ts"],"sourcesContent":["/** Pan offset (in pixels) plus per-axis zoom (pixels per content unit). */\nexport interface ViewTransform {\n  panX: number;\n  panY: number;\n  zoom: { x: number; y: number };\n}\n\n/** Project a world-space point to screen-space pixels through a `ViewTransform`. */\nexport function worldToScreen(\n  worldX: number,\n  worldY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];\n}\n\n/** Inverse of `worldToScreen` — recover the world-space point under a screen-space pixel. */\nexport function screenToWorld(\n  screenX: number,\n  screenY: number,\n  view: ViewTransform,\n): [number, number] {\n  return [(screenX - view.panX) / view.zoom.x, (screenY - view.panY) / view.zoom.y];\n}\n"],"mappings":";AAQA,SAAgBA,EACd,GACA,GACA,GACkB;CAClB,OAAO,CAACC,EAAK,OAAOC,IAASD,EAAK,KAAK,GAAGA,EAAK,OAAOE,IAASF,EAAK,KAAK,CAAC;AAC5E;AAGA,SAAgBG,EACd,GACA,GACA,GACkB;CAClB,OAAO,EAAEC,IAAUJ,EAAK,QAAQA,EAAK,KAAK,IAAIK,IAAUL,EAAK,QAAQA,EAAK,KAAK,CAAC;AAClF"}

package/dist/core/viewport/viewportWorldRect.js

@@ -0,0 +1,13 @@
+//#region src/core/viewport/viewportWorldRect.ts
+function e(e, t) {
+	return {
+		x: e.x,
+		y: e.y,
+		width: t.width / e.scale.x,
+		height: t.height / e.scale.y
+	};
+}
+//#endregion
+export { e as viewportWorldRect };
+
+//# sourceMappingURL=viewportWorldRect.js.map

package/dist/core/viewport/viewportWorldRect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportWorldRect.js","names":["viewportWorldRect","view","size"],"sources":["../../../src/core/viewport/viewportWorldRect.ts"],"sourcesContent":["import type { View } from './view';\n\n/**\n * The world-space rectangle a camera shows in a host `size` CSS pixels across.\n *\n * One formula, because two callers need it against different hosts: the\n * canvas element for view zero, and a view's own rect for a panel. Paste\n * placement centers on it, so the two disagreeing puts pasted content in a\n * view the user is not looking at.\n */\nexport function viewportWorldRect(\n  view: View,\n  size: { width: number; height: number },\n): { x: number; y: number; width: number; height: number } {\n  return {\n    x: view.x,\n    y: view.y,\n    width: size.width / view.scale.x,\n    height: size.height / view.scale.y,\n  };\n}\n"],"mappings":";AAUA,SAAgBA,EACd,GACA,GACyD;CACzD,OAAO;EACL,GAAGC,EAAK;EACR,GAAGA,EAAK;EACR,OAAOC,EAAK,QAAQD,EAAK,MAAM;EAC/B,QAAQC,EAAK,SAASD,EAAK,MAAM;CACnC;AACF"}