@weasel-js/core 1.7.0 → 1.7.1

package/dist/core/viewport/wheelHandler.js

@@ -0,0 +1,30 @@
+import { zoomAt as e } from "./zoomAt.js";
+//#region src/core/viewport/wheelHandler.ts
+var t = 1.1;
+function n(e) {
+	return t ** (-e / 100);
+}
+function r(t, r, i, a) {
+	return e(t, r, n(i), a);
+}
+function i(e, t, n = {}) {
+	let r = n.axis ?? "both", i = n.swapAxis === !0, a = i && t.deltaX === 0 ? t.deltaY : t.deltaX, o = i ? 0 : t.deltaY;
+	return {
+		scale: e.scale,
+		x: e.x + (r === "y" ? 0 : a / e.scale.x),
+		y: e.y + (r === "x" ? 0 : o / e.scale.y)
+	};
+}
+function a(e, t, n, a = {}) {
+	return t.ctrlKey || t.metaKey ? r(e, {
+		x: t.x,
+		y: t.y
+	}, t.deltaY, n) : i(e, t, {
+		axis: a.axis,
+		swapAxis: t.shiftKey === !0
+	});
+}
+//#endregion
+export { t as WHEEL_ZOOM_STEP, a as computeWheelAction, i as wheelPan, r as wheelZoom, n as wheelZoomFactor };
+
+//# sourceMappingURL=wheelHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wheelHandler.js","names":["WHEEL_ZOOM_STEP","wheelZoomFactor","deltaY","wheelZoom","zoomAt","view","anchor","clamp","wheelPan","axis","opts","swapped","screenX","delta","screenY","computeWheelAction","input"],"sources":["../../../src/core/viewport/wheelHandler.ts"],"sourcesContent":["/**\n * The kit's one wheel convention, as pure functions over `View`.\n *\n * ## Modifiers\n * - bare wheel → pan\n * - shift+wheel → horizontal pan (mouse wheels emit only `deltaY`)\n * - Cmd/Ctrl+wheel → zoom, anchored under the pointer. Ctrl also covers the\n *   trackpad pinch, which browsers deliver as ctrl+wheel.\n *\n * ## Coordinates\n * `View.x` / `View.y` are world-space, so a pan delta — screen pixels, as the\n * DOM reports them — is divided by `View.scale` before it lands. The zoom\n * anchor is canvas-local: client coords minus the canvas's bounding rect.\n *\n * `viewport.wheelPan` and `viewport.zoom` are the wired form of these, and\n * call them rather than restating the math.\n */\n\nimport type { View } from './view';\nimport { zoomAt, type ZoomClampOpts } from './zoomAt';\n\n/** Multiplicative zoom applied per 100 px of wheel `deltaY`. */\nexport const WHEEL_ZOOM_STEP = 1.1;\n\n/** A wheel event, decoupled from the DOM `WheelEvent` shape for testability. */\nexport interface WheelInput {\n  deltaX: number;\n  deltaY: number;\n  /** Zoom anchor, canvas-local: client coords minus the canvas's rect. */\n  x: number;\n  y: number;\n  shiftKey?: boolean;\n  ctrlKey?: boolean;\n  metaKey?: boolean;\n}\n\n/** Which axes a wheel pan is allowed to move, and whether `deltaY` is routed\n *  into the x axis (shift+wheel). An axis lock outranks `swapAxis`. */\nexport interface WheelPanOpts {\n  axis?: 'both' | 'x' | 'y';\n  swapAxis?: boolean;\n}\n\n/** Zoom multiplier for one wheel sample. Reciprocal in `deltaY`, so scrolling\n *  a distance and back returns to the scale you started from. */\nexport function wheelZoomFactor(deltaY: number): number {\n  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);\n}\n\n/** Zoom one wheel sample about `anchor` (canvas-local pixels). */\nexport function wheelZoom(\n  view: View,\n  anchor: { x: number; y: number },\n  deltaY: number,\n  clamp?: ZoomClampOpts,\n): View {\n  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);\n}\n\n/** Pan by one wheel sample. `delta` is in screen pixels. */\nexport function wheelPan(\n  view: View,\n  delta: { deltaX: number; deltaY: number },\n  opts: WheelPanOpts = {},\n): View {\n  const axis = opts.axis ?? 'both';\n  const swapped = opts.swapAxis === true;\n  // Shift+wheel wants a horizontal pan, but a mouse wheel only emits deltaY.\n  const screenX = swapped ? (delta.deltaX !== 0 ? delta.deltaX : delta.deltaY) : delta.deltaX;\n  const screenY = swapped ? 0 : delta.deltaY;\n  return {\n    scale: view.scale,\n    x: view.x + (axis === 'y' ? 0 : screenX / view.scale.x),\n    y: view.y + (axis === 'x' ? 0 : screenY / view.scale.y),\n  };\n}\n\n/** Pure reducer: the whole wheel convention in one call. */\nexport function computeWheelAction(\n  view: View,\n  input: WheelInput,\n  clamp?: ZoomClampOpts,\n  opts: Pick<WheelPanOpts, 'axis'> = {},\n): View {\n  if (input.ctrlKey || input.metaKey) {\n    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);\n  }\n  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });\n}\n"],"mappings":";;AAsBA,IAAaA,IAAkB;AAuB/B,SAAgBC,EAAgB,GAAwB;CACtD,OAAgBD,MAAiB,CAACE,IAAS;AAC7C;AAGA,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,OAAOC,EAAOC,GAAMC,GAAQL,EAAgBC,CAAM,GAAGK,CAAK;AAC5D;AAGA,SAAgBC,EACd,GACA,GACA,IAAqB,CAAC,GAChB;CACN,IAAMC,IAAOC,EAAK,QAAQ,QACpBC,IAAUD,EAAK,aAAa,IAE5BE,IAAUD,KAAWE,EAAM,WAAW,IAAmBA,EAAM,SAArBA,EAAM,QAChDC,IAAUH,IAAU,IAAIE,EAAM;CACpC,OAAO;EACL,OAAOR,EAAK;EACZ,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIG,IAAUP,EAAK,MAAM;EACrD,GAAGA,EAAK,KAAKI,MAAS,MAAM,IAAIK,IAAUT,EAAK,MAAM;CACvD;AACF;AAGA,SAAgBU,EACd,GACA,GACA,GACA,IAAmC,CAAC,GAC9B;CAIN,OAHIC,EAAM,WAAWA,EAAM,UAClBb,EAAUE,GAAM;EAAE,GAAGW,EAAM;EAAG,GAAGA,EAAM;CAAE,GAAGA,EAAM,QAAQT,CAAK,IAEjEC,EAASH,GAAMW,GAAO;EAAE,MAAMN,EAAK;EAAM,UAAUM,EAAM,aAAa;CAAK,CAAC;AACrF"}

package/dist/core/viewport/zoomAt.js

@@ -0,0 +1,22 @@
+import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t, normalizeZoom as n } from "./zoomBounds.js";
+import { normalizeView as r } from "./view.js";
+//#region src/core/viewport/zoomAt.ts
+function i(e, t, r) {
+	let i = n(Math.min(r, Math.max(t, Math.abs(e))));
+	return e < 0 ? -i : i;
+}
+function a(n, a, o, s) {
+	let c = r(n), l = typeof o == "number" ? o : o.x, u = typeof o == "number" ? o : o.y, d = typeof s?.min == "number" ? s.min : s?.min?.x ?? t, f = typeof s?.min == "number" ? s.min : s?.min?.y ?? t, p = typeof s?.max == "number" ? s.max : s?.max?.x ?? e, m = typeof s?.max == "number" ? s.max : s?.max?.y ?? e, h = i(c.scale.x * l, d, p), g = i(c.scale.y * u, f, m), _ = a.x / c.scale.x + c.x, v = a.y / c.scale.y + c.y;
+	return {
+		scale: {
+			x: h,
+			y: g
+		},
+		x: _ - a.x / h,
+		y: v - a.y / g
+	};
+}
+//#endregion
+export { a as zoomAt };
+
+//# sourceMappingURL=zoomAt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoomAt.js","names":["clampScale","magnitude","normalizeZoom","max","min","scale","zoomAt","view","normalizeView","input","fx","factor","fy","minX","opts","DEFAULT_MIN_ZOOM","minY","maxX","DEFAULT_MAX_ZOOM","maxY","nextX","nextY","worldX","anchor","worldY"],"sources":["../../../src/core/viewport/zoomAt.ts"],"sourcesContent":["import { normalizeView, type View, type ZoomFactor, type ZoomBound } from './view';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM, normalizeZoom } from './zoomBounds';\n\n/** Optional clamp bounds for `zoomAt`. Defaults: {@link DEFAULT_MIN_ZOOM} /\n *  {@link DEFAULT_MAX_ZOOM} (per axis). */\nexport interface ZoomClampOpts {\n  min?: ZoomBound;\n  max?: ZoomBound;\n}\n\n/** Bound a scale's *magnitude*, keeping its direction. `scale.y < 0` is how a\n *  `View` spells a y-up camera, so clamping the signed value against positive\n *  bounds would flip the axis and collapse the zoom rather than limit it. */\nfunction clampScale(scale: number, min: number, max: number): number {\n  const magnitude = normalizeZoom(Math.min(max, Math.max(min, Math.abs(scale))));\n  return scale < 0 ? -magnitude : magnitude;\n}\n\n/**\n * Pure zoom primitive. Returns a new `View` whose `scale` is multiplied\n * by `factor` (per-axis, clamped) and whose translation is adjusted so\n * that the world point currently under `anchor` (screen coords relative\n * to the canvas top-left) stays under the same screen pixel after the\n * zoom — independently on each axis.\n *\n * `factor: number` means \"apply uniformly to both axes\". `factor: {x, y}`\n * applies per-axis factors. Likewise for `opts.min` / `opts.max`.\n */\nexport function zoomAt(\n  input: View,\n  anchor: { x: number; y: number },\n  factor: ZoomFactor,\n  opts?: ZoomClampOpts,\n): View {\n  const view = normalizeView(input);\n  const fx = typeof factor === 'number' ? factor : factor.x;\n  const fy = typeof factor === 'number' ? factor : factor.y;\n  const minX = typeof opts?.min === 'number' ? opts.min : opts?.min?.x ?? DEFAULT_MIN_ZOOM;\n  const minY = typeof opts?.min === 'number' ? opts.min : opts?.min?.y ?? DEFAULT_MIN_ZOOM;\n  const maxX = typeof opts?.max === 'number' ? opts.max : opts?.max?.x ?? DEFAULT_MAX_ZOOM;\n  const maxY = typeof opts?.max === 'number' ? opts.max : opts?.max?.y ?? DEFAULT_MAX_ZOOM;\n\n  const nextX = clampScale(view.scale.x * fx, minX, maxX);\n  const nextY = clampScale(view.scale.y * fy, minY, maxY);\n\n  const worldX = anchor.x / view.scale.x + view.x;\n  const worldY = anchor.y / view.scale.y + view.y;\n  return {\n    scale: { x: nextX, y: nextY },\n    x: worldX - anchor.x / nextX,\n    y: worldY - anchor.y / nextY,\n  };\n}\n"],"mappings":";;;AAaA,SAASA,EAAW,GAAe,GAAa,GAAqB;CACnE,IAAMC,IAAYC,EAAc,KAAK,IAAIC,GAAK,KAAK,IAAIC,GAAK,KAAK,IAAIC,CAAK,CAAC,CAAC,CAAC;CAC7E,OAAOA,IAAQ,IAAI,CAACJ,IAAYA;AAClC;AAYA,SAAgBK,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOC,EAAcC,CAAK,GAC1BC,IAAK,OAAOC,KAAW,WAAWA,IAASA,EAAO,GAClDC,IAAK,OAAOD,KAAW,WAAWA,IAASA,EAAO,GAClDE,IAAO,OAAOC,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEC,IAAO,OAAOF,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKC,GAClEE,IAAO,OAAOH,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAClEC,IAAO,OAAOL,GAAM,OAAQ,WAAWA,EAAK,MAAMA,GAAM,KAAK,KAAKI,GAElEE,IAAQpB,EAAWO,EAAK,MAAM,IAAIG,GAAIG,GAAMI,CAAI,GAChDI,IAAQrB,EAAWO,EAAK,MAAM,IAAIK,GAAII,GAAMG,CAAI,GAEhDG,IAASC,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK,GACxCiB,IAASD,EAAO,IAAIhB,EAAK,MAAM,IAAIA,EAAK;CAC9C,OAAO;EACL,OAAO;GAAE,GAAGa;GAAO,GAAGC;EAAM;EAC5B,GAAGC,IAASC,EAAO,IAAIH;EACvB,GAAGI,IAASD,EAAO,IAAIF;CACzB;AACF"}

package/dist/core/viewport/zoomBounds.js

@@ -0,0 +1,20 @@
+//#region src/core/viewport/zoomBounds.ts
+var e = .1, t = 8, n = 1e-9;
+function r(e) {
+	return e >= n && e < Infinity ? e : ((!(e > 0) || e === Infinity) && a(`a zoom of ${e}`), n);
+}
+var i = !1;
+function a(e) {
+	!i && o && (i = !0, console.warn(`[weasel] a view was given ${e} and has been clamped. A view's zoom is always positive and finite, and its position finite; see ZOOM_FLOOR.`));
+}
+var o = (() => {
+	try {
+		return !1;
+	} catch {
+		return !1;
+	}
+})();
+//#endregion
+export { t as DEFAULT_MAX_ZOOM, e as DEFAULT_MIN_ZOOM, n as ZOOM_FLOOR, r as normalizeZoom, a as warnInvalidView };
+
+//# sourceMappingURL=zoomBounds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoomBounds.js","names":["DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","ZOOM_FLOOR","normalizeZoom","zoom","warnInvalidView","warned","IS_DEV","what"],"sources":["../../../src/core/viewport/zoomBounds.ts"],"sourcesContent":["/**\n * The kit's system-wide zoom clamp, in `View.scale` units (pixels per world\n * unit): `1` is 100%, `0.1` is 10%, `8` is 800%.\n *\n * Every zoom path defaults from these — `zoomAt`, the `viewport.zoom` and\n * pinch actions, `fitViewToBounds`, `computeWheelAction`. They\n * used to carry two disagreeing pairs, so a fit could legally land at 10x\n * and the next pinch frame would clamp it back to 8x.\n */\nexport const DEFAULT_MIN_ZOOM = 0.1;\n/** Upper end of the kit's default zoom clamp — 800%. See {@link DEFAULT_MIN_ZOOM}. */\nexport const DEFAULT_MAX_ZOOM = 8;\n\n/**\n * The smallest zoom magnitude a view can hold, in `View.scale` units.\n *\n * A view's zoom is always finite and at least this far from 0. Nothing can be\n * drawn or picked through a zoom of 0, and every screen↔world conversion\n * divides by it, so it is ruled out where views are made rather than handled\n * by each conversion. This is validity, not an interaction limit: that is\n * {@link DEFAULT_MIN_ZOOM}, which a consumer may set far below.\n */\nexport const ZOOM_FLOOR = 1e-9;\n\n/**\n * The one rule for a zoom magnitude: a finite number no smaller than\n * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the\n * floor. Dev builds warn once when a zoom that was never valid arrives; a\n * positive zoom that merely undershoots the floor clamps silently.\n */\nexport function normalizeZoom(zoom: number): number {\n  if (zoom >= ZOOM_FLOOR && zoom < Infinity) return zoom;\n  if (!(zoom > 0) || zoom === Infinity) warnInvalidView(`a zoom of ${zoom}`);\n  return ZOOM_FLOOR;\n}\n\nlet warned = false;\n\n/** @internal Once per session, in dev builds only. */\nexport function warnInvalidView(what: string): void {\n  if (warned || !IS_DEV) return;\n  warned = true;\n  console.warn(\n    `[weasel] a view was given ${what} and has been clamped. A view's zoom is ` +\n    'always positive and finite, and its position finite; see ZOOM_FLOOR.',\n  );\n}\n\n/** `import.meta.env.DEV` read through a cast, as in SceneCanvas.tsx. */\nconst IS_DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";AASA,IAAaA,IAAmB,IAEnBC,IAAmB,GAWnBC,IAAa;AAQ1B,SAAgBC,EAAc,GAAsB;CAGlD,OAFIC,KAAQF,KAAcE,IAAO,WAAiBA,MAC9C,EAAEA,IAAO,MAAMA,MAAS,aAAUC,EAAgB,aAAaD,GAAM,GAClEF;AACT;AAEA,IAAII,IAAS;AAGb,SAAgBD,EAAgB,GAAoB;CAClD,AAAI,MAAWE,MACf,IAAS,IACT,QAAQ,KACN,6BAA6BC,EAAK,6GAEpC;AACF;AAGA,IAAMD,WAAyB;CAC7B,IAAI;EACF,OAAO,CAAA;CACT,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}

package/dist/{pointSnapToGrid-Dp2IxLGb.d.ts → cornerHandles-CDcZOV8h.d.ts}

@@ -1,5 +1,5 @@
-import { B as BoundsConstraint, P as PointSnapBehavior, a as PointSnapFrame } from './types-qYpyTAiZ.js';
-import { Bounds, ResizeAnchor, ModifierState } from '@weasel-js/routing';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-DSjd6W3n.js';
+import { Bounds, ResizeAnchor } from '@weasel-js/routing';
 
 /** Option surface for the `resize` action. */
 
@@ -114,14 +114,4 @@ declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
     y: number;
 };
 
-/** Resize behavior that snaps one reference point of the resize — the dragged
- *  corner, the fixed corner, or the center, per `frame` — to a grid, moving
- *  the whole pose by the same delta. Unlike the bounds-level `snapToGrid`,
- *  this preserves the node's dimensions. */
-declare function pointSnapToGrid<TPose extends Bounds>(args: {
-    spacing: number;
-    frame?: PointSnapFrame;
-    bypassKey?: keyof ModifierState;
-}): PointSnapBehavior<TPose>;
-
-export { CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, pointSnapToGrid as p };
+export { CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h };

package/dist/debug/createDebugOverlayLayer.js

@@ -0,0 +1,358 @@
+import { viewToTransform as e } from "../core/viewport/view.js";
+import { worldToScreen as t } from "../core/viewport/viewTransform.js";
+import { rotatePoint as n } from "../interactions/actions/rotate/geometry.js";
+import { textCommandFromRuns as r } from "../features/text/textCommand.js";
+import { DEFAULT_DEBUG_STROKES as i, DEFAULT_DEBUG_THEME as a } from "./defaultTheme.js";
+import { PATH_L as o, PATH_M as s, PATH_Z as c } from "@weasel-js/geom";
+//#region src/debug/createDebugOverlayLayer.ts
+var l = 60;
+function u({ sink: e, config: t }) {
+	let n = [];
+	return {
+		id: "debug-overlay",
+		label: "Debug overlay",
+		space: "screen",
+		alwaysOn: !0,
+		draw: (r, i, a) => (t.fps ? (n.push(typeof performance < "u" ? performance.now() : Date.now()), n.length > l && n.shift()) : n.length > 0 && (n.length = 0), d(e.snapshot(), t, i, a, n))
+	};
+}
+function d(t, n, r, o, s = []) {
+	let c = {
+		...a,
+		...n.theme ?? {}
+	}, l = {
+		...i,
+		...n.strokes ?? {}
+	}, u = t, d = e(r), f = [];
+	return n.viewport && u.viewport && A(f, u.viewport, r, o, c, l), n.hitboxes && _(f, u, r, d, c, l), n.bounds && v(f, u, r, d, c, l), n.handles && y(f, u, d, c, l), n.origins && b(f, u, d, c), n.snap && x(f, u, d, c, l), n.ids && S(f, u, d, c), n.layers && C(f, u, o, c), n.fps && k(f, s, u.frame, c), f;
+}
+function f(e, t, n, r = 24) {
+	return p(e, t, n, n, r);
+}
+function p(e, t, n, r, i = 24) {
+	let a = new Uint8Array(i + 1), l = new Float32Array(i * 2);
+	a[0] = s, l[0] = e + n, l[1] = t;
+	for (let s = 1; s < i; s++) {
+		a[s] = o;
+		let c = s / i * Math.PI * 2;
+		l[s * 2] = e + n * Math.cos(c), l[s * 2 + 1] = t + r * Math.sin(c);
+	}
+	return a[i] = c, {
+		kind: "polygon",
+		commands: a,
+		coords: l,
+		fillRule: "nonzero"
+	};
+}
+function m(e, r) {
+	let i = e.x + e.width / 2, a = e.y + e.height / 2, l = /* @__PURE__ */ new Float32Array(8);
+	return [
+		[e.x, e.y],
+		[e.x + e.width, e.y],
+		[e.x + e.width, e.y + e.height],
+		[e.x, e.y + e.height]
+	].forEach(([o, s], c) => {
+		let u = n(o, s, i, a, e.rotation), [d, f] = t(u.x, u.y, r);
+		l[c * 2] = d, l[c * 2 + 1] = f;
+	}), {
+		kind: "polygon",
+		commands: new Uint8Array([
+			s,
+			o,
+			o,
+			o,
+			c
+		]),
+		coords: l,
+		fillRule: "nonzero"
+	};
+}
+function h(e, t, n, r) {
+	return {
+		kind: "rect",
+		x: e,
+		y: t,
+		width: n,
+		height: r
+	};
+}
+function g(e, t) {
+	return {
+		paint: {
+			fill: "solid",
+			color: t
+		},
+		width: e.width,
+		...e.dash && e.dash.length > 0 ? { dash: [...e.dash] } : {}
+	};
+}
+function _(e, n, r, i, a, l) {
+	let u = {
+		fill: "solid",
+		color: a.hitboxFill
+	}, d = g(l.hitbox, a.hitboxStroke);
+	for (let a of n.hitboxes) if (a.shape.kind === "rect" && a.shape.rotation) {
+		let t = m({
+			...a.shape,
+			rotation: a.shape.rotation
+		}, i);
+		e.push({
+			kind: "path",
+			path: t,
+			fill: u,
+			stroke: d
+		});
+	} else if (a.shape.kind === "rect") {
+		let [n, o] = t(a.shape.x, a.shape.y, i), s = a.shape.width * r.scale.x, c = a.shape.height * r.scale.y;
+		e.push({
+			kind: "path",
+			path: h(n, o, s, c),
+			fill: u,
+			stroke: d
+		});
+	} else if (a.shape.kind === "circle") {
+		let [n, o] = t(a.shape.cx, a.shape.cy, i), s = a.shape.r * Math.abs(r.scale.x), c = a.shape.r * Math.abs(r.scale.y);
+		e.push({
+			kind: "path",
+			path: p(n, o, s, c),
+			fill: u,
+			stroke: d
+		});
+	} else if (a.shape.kind === "polygon" && a.shape.points.length > 2) {
+		let n = a.shape.points, r = new Float32Array(n.length * 2);
+		n.forEach((e, n) => {
+			let [a, o] = t(e.x, e.y, i);
+			r[n * 2] = a, r[n * 2 + 1] = o;
+		});
+		let l = new Uint8Array(n.length + 1).fill(o);
+		l[0] = s, l[n.length] = c, e.push({
+			kind: "path",
+			path: {
+				kind: "polygon",
+				commands: l,
+				coords: r,
+				fillRule: "nonzero"
+			},
+			fill: u,
+			stroke: d
+		});
+	}
+}
+function v(e, n, r, i, a, o) {
+	let s = g(o.bounds, a.bounds);
+	for (let a of n.bounds) {
+		let [n, o] = t(a.bounds.x, a.bounds.y, i), c = a.bounds.width * r.scale.x, l = a.bounds.height * r.scale.y;
+		e.push({
+			kind: "path",
+			path: h(n, o, c, l),
+			stroke: s
+		});
+	}
+}
+function y(e, n, r, i, a) {
+	let c = g(a.handle, i.handle);
+	for (let i of n.handles) {
+		let [n, a] = t(i.position.x, i.position.y, r), l = {
+			kind: "polygon",
+			commands: new Uint8Array([s, o]),
+			coords: new Float32Array([
+				n - 4,
+				a,
+				n + 4,
+				a
+			]),
+			fillRule: "nonzero"
+		}, u = {
+			kind: "polygon",
+			commands: new Uint8Array([s, o]),
+			coords: new Float32Array([
+				n,
+				a - 4,
+				n,
+				a + 4
+			]),
+			fillRule: "nonzero"
+		};
+		e.push({
+			kind: "path",
+			path: l,
+			stroke: c
+		}), e.push({
+			kind: "path",
+			path: u,
+			stroke: c
+		});
+	}
+}
+function b(e, n, r, i) {
+	let a = {
+		fill: "solid",
+		color: i.origin
+	};
+	for (let i of n.origins) {
+		let [n, o] = t(i.point.x, i.point.y, r);
+		e.push({
+			kind: "path",
+			path: f(n, o, 3),
+			fill: a
+		});
+	}
+}
+function x(e, n, r, i, a) {
+	let o = i.snap;
+	for (let i of n.snap) {
+		let [n, s] = t(i.point.x, i.point.y, r), c = {
+			kind: "path",
+			path: f(n, s, 4),
+			...i.accepted ? { fill: {
+				fill: "solid",
+				color: o
+			} } : { stroke: g(a.snap, o) }
+		};
+		e.push(c);
+	}
+}
+function S(e, n, i, a) {
+	for (let o of n.bounds) {
+		let [n, s] = t(o.bounds.x, o.bounds.y, i);
+		e.push(r(n + 2, s + 11, [{
+			text: o.id,
+			fill: {
+				fill: "solid",
+				color: a.idText
+			}
+		}], {
+			fontFamily: "ui-monospace, Menlo, monospace",
+			fontSize: 10
+		}));
+	}
+}
+function C(e, t, n, i) {
+	if (t.layers.length === 0) return;
+	let a = t.layers.map((e) => `[${e.index}] ${e.id} (${e.space})`), o = 0;
+	for (let e of a) o = Math.max(o, e.length * 6.6);
+	let s = o + 12, c = a.length * 14 + 8, l = n.width - s - 8;
+	e.push({
+		kind: "path",
+		path: h(l, 8, s, c),
+		fill: {
+			fill: "solid",
+			color: i.layerTextBg
+		}
+	});
+	for (let t = 0; t < a.length; t++) e.push(r(l + 6, 12 + t * 14, [{
+		text: a[t],
+		fill: {
+			fill: "solid",
+			color: i.layerText
+		}
+	}], {
+		fontFamily: "ui-monospace, Menlo, monospace",
+		fontSize: 11
+	}));
+}
+var w = {
+	fontFamily: "ui-monospace, Menlo, monospace",
+	fontSize: 11
+}, T = 6.6, E = 14;
+function D(e, t, n, i, a, o) {
+	let s = 0;
+	for (let e of t) s = Math.max(s, e.length);
+	e.push({
+		kind: "path",
+		path: h(n, i, s * T + 12, t.length * E + 8),
+		fill: {
+			fill: "solid",
+			color: o
+		}
+	});
+	for (let o = 0; o < t.length; o++) e.push(r(n + 6, i + 4 + o * E, [{
+		text: t[o],
+		fill: {
+			fill: "solid",
+			color: a
+		}
+	}], w));
+}
+function O(e, t, n) {
+	return e.toFixed(n).padStart(t);
+}
+function k(e, t, n, r) {
+	let i = t.length >= 2 ? t[t.length - 1] - t[0] : 0, a = i > 0 ? i / (t.length - 1) : null, o = [[
+		"fps",
+		null,
+		a ? 1e3 / a : null,
+		"  "
+	], [
+		"frame",
+		null,
+		a,
+		"ms"
+	]];
+	if (n) {
+		o.push([
+			"paint",
+			n.drawCalls,
+			n.paintMs,
+			"ms"
+		]);
+		for (let e of n.layers) o.push([
+			e.id,
+			e.drawCalls,
+			e.ms,
+			"ms"
+		]);
+	}
+	let s = 0;
+	for (let [e] of o) s = Math.max(s, e.length);
+	let c = (e, t, n, r) => `${e.padEnd(s)} ${t.padStart(5)} ${n.padStart(7)} ${r}`, l = o.map(([e, t, n, r]) => c(e, t === null ? "" : String(t), n === null ? "—" : O(n, 7, 2), r));
+	n && l.splice(2, 0, c("", "draws", "cpu", "  ")), D(e, l, 8, 8, r.fpsText, r.fpsTextBg);
+}
+function A(n, r, i, a, o, s) {
+	let c = e(i), l = g(s.viewport, o.viewport), { from: u, to: d } = r, [p, m] = t(u.x, u.y, c);
+	if (n.push({
+		kind: "path",
+		path: h(p, m, a.width / u.scale.x * i.scale.x, a.height / u.scale.y * i.scale.y),
+		stroke: l
+	}), r.anchor) {
+		let [i, a] = t(r.anchor.x, r.anchor.y, e(u)), [d, p] = t(r.anchor.x, r.anchor.y, c);
+		n.push({
+			kind: "path",
+			path: f(i, a, 2.5),
+			fill: {
+				fill: "solid",
+				color: o.viewport
+			}
+		}), Math.hypot(d - i, p - a) > .5 && n.push({
+			kind: "path",
+			path: M(i, a, d, p),
+			stroke: l
+		}), n.push({
+			kind: "path",
+			path: f(d, p, 6),
+			stroke: g({ width: s.viewport.width }, o.viewport)
+		});
+	}
+	D(n, [r.kind === "pan" ? `pan   Δ ${j((u.x - d.x) * d.scale.x)} ${j((u.y - d.y) * d.scale.y)} px` : `zoom  ×${(d.scale.x / u.scale.x).toFixed(3)}  ${u.scale.x.toFixed(3)} → ${d.scale.x.toFixed(3)}`], 8, a.height - E - 16, o.viewport, o.layerTextBg);
+}
+function j(e) {
+	let t = Math.abs(e) < .05 ? 0 : e;
+	return `${t >= 0 ? "+" : "-"}${Math.abs(t).toFixed(1)}`.padStart(8);
+}
+function M(e, t, n, r) {
+	return {
+		kind: "polygon",
+		commands: new Uint8Array([s, o]),
+		coords: new Float32Array([
+			e,
+			t,
+			n,
+			r
+		]),
+		fillRule: "nonzero"
+	};
+}
+//#endregion
+export { d as buildDebugOverlayCommands, u as createDebugOverlayLayer };
+
+//# sourceMappingURL=createDebugOverlayLayer.js.map

package/dist/debug/createDebugOverlayLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDebugOverlayLayer.js","names":["rectPath","FPS_WINDOW","createDebugOverlayLayer","fpsHistory","config","buildDebugOverlayCommands","sink","view","dims","theme","DEFAULT_DEBUG_THEME","strokes","DEFAULT_DEBUG_STROKES","s","snapshot","t","viewToTransform","out","emitViewport","emitHitboxes","emitBounds","emitHandles","emitOrigins","emitSnap","emitIds","emitLayersPanel","emitFramePanel","frameTimes","approxCircleScreen","approxEllipseScreen","cx","cy","r","segments","cmds","coords","PATH_M","rx","i","PATH_L","theta","ry","PATH_Z","rotatedRectScreen","x","y","w","rotatePoint","sx","sy","worldToScreen","rectPath$1","h","strokeOf","fill","stroke","path","sw","sh","pts","p","commands","b","horiz","vert","o","color","c","cmd","textCommandFromRuns","lines","l","maxW","line","boxW","boxH","MONO","MONO_CHAR_W","LINE_H","emitTextPanel","maxLen","bg","fixed","v","decimals","width","span","history","interval","rows","frame","labelW","label","count","value","unit","rec","fx","fy","from","ax0","ay0","ax1","ay1","segment","signed","to","x0","y0","x1","y1"],"sources":["../../src/debug/createDebugOverlayLayer.ts"],"sourcesContent":["import type { DrawCommand, PathDrawCommand } from '../renderer';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { rotatePoint } from 'interactions/actions/rotate/geometry';\nimport { PATH_L, PATH_M, PATH_Z, type PolygonPath } from '@weasel-js/geom';\nimport { textCommandFromRuns } from 'features/text/textCommand';\nimport type {\n  DebugConfig,\n  DebugSnapshot,\n  DebugStroke,\n  DebugStrokes,\n  DebugTheme,\n  FrameStats,\n  RecordedViewport,\n} from './types';\nimport { DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME } from './defaultTheme';\n\n/** @internal */\ninterface CreateDebugOverlayLayerOpts {\n  sink: { snapshot(): DebugSnapshot };\n  config: DebugConfig;\n}\n\nconst FPS_WINDOW = 60;\n\n/**\n * Screen-space `RenderLayer` that paints the sink's snapshot. Appended at\n * the top of the Canvas's layer stack when `debug` is enabled. World-space\n * coords in the snapshot are projected through `view` here, since the\n * layer itself runs at identity transform.\n */\nexport function createDebugOverlayLayer({\n  sink,\n  config,\n}: CreateDebugOverlayLayerOpts): RenderLayer<unknown> {\n  // Timestamps of the last FPS_WINDOW draws; survives across draws within\n  // one Canvas mount.\n  const fpsHistory: number[] = [];\n  return {\n    id: 'debug-overlay',\n    label: 'Debug overlay',\n    space: 'screen',\n    alwaysOn: true,\n    draw: (_data, view, dims) => {\n      if (config.fps) {\n        fpsHistory.push(typeof performance !== 'undefined' ? performance.now() : Date.now());\n        if (fpsHistory.length > FPS_WINDOW) fpsHistory.shift();\n      } else if (fpsHistory.length > 0) {\n        fpsHistory.length = 0;\n      }\n      return buildDebugOverlayCommands(sink.snapshot(), config, view, dims, fpsHistory);\n    },\n  };\n}\n\n/**\n * The debug overlay's draw commands for one snapshot, in screen space (CSS\n * pixels of a `dims`-sized canvas looking through `view`). What the overlay\n * layer paints each frame, and what `renderDebugSnapshot` rasterizes.\n *\n * `frameTimes` are `performance.now()` stamps of recent paints, oldest first;\n * the frame panel derives its rate from them and shows none without two.\n */\nexport function buildDebugOverlayCommands(\n  snapshot: DebugSnapshot,\n  config: DebugConfig,\n  view: View,\n  dims: Dims,\n  frameTimes: readonly number[] = [],\n): DrawCommand[] {\n  const theme: DebugTheme = { ...DEFAULT_DEBUG_THEME, ...(config.theme ?? {}) };\n  const strokes: DebugStrokes = { ...DEFAULT_DEBUG_STROKES, ...(config.strokes ?? {}) };\n  const s = snapshot;\n  const t = viewToTransform(view);\n  const out: DrawCommand[] = [];\n\n  if (config.viewport && s.viewport) emitViewport(out, s.viewport, view, dims, theme, strokes);\n  if (config.hitboxes) emitHitboxes(out, s, view, t, theme, strokes);\n  if (config.bounds) emitBounds(out, s, view, t, theme, strokes);\n  if (config.handles) emitHandles(out, s, t, theme, strokes);\n  if (config.origins) emitOrigins(out, s, t, theme);\n  if (config.snap) emitSnap(out, s, t, theme, strokes);\n  if (config.ids) emitIds(out, s, t, theme);\n  if (config.layers) emitLayersPanel(out, s, dims, theme);\n  if (config.fps) emitFramePanel(out, frameTimes, s.frame, theme);\n  return out;\n}\n\n// --- emitters (screen-space) ---\n\nfunction approxCircleScreen(cx: number, cy: number, r: number, segments = 24): PolygonPath {\n  return approxEllipseScreen(cx, cy, r, r, segments);\n}\n\nfunction approxEllipseScreen(cx: number, cy: number, rx: number, ry: number, segments = 24): PolygonPath {\n  // Commands: M + (segments-1) L + Z. Coords: (segments) × 2 — pairs for\n  // the moveTo and the (segments-1) lineTos. PATH_Z consumes no coords.\n  const cmds = new Uint8Array(segments + 1);\n  const coords = new Float32Array(segments * 2);\n  cmds[0] = PATH_M;\n  coords[0] = cx + rx;\n  coords[1] = cy;\n  for (let i = 1; i < segments; i++) {\n    cmds[i] = PATH_L;\n    const theta = (i / segments) * Math.PI * 2;\n    coords[i * 2] = cx + rx * Math.cos(theta);\n    coords[i * 2 + 1] = cy + ry * Math.sin(theta);\n  }\n  cmds[segments] = PATH_Z;\n  return { kind: 'polygon', commands: cmds, coords, fillRule: 'nonzero' };\n}\n\n/** A world rect turned `rotation` about its center, as the screen quad it\n *  lands on. */\nfunction rotatedRectScreen(\n  r: { x: number; y: number; width: number; height: number; rotation: number },\n  t: ReturnType<typeof viewToTransform>,\n): PolygonPath {\n  const cx = r.x + r.width / 2, cy = r.y + r.height / 2;\n  const coords = new Float32Array(8);\n  const corners = [[r.x, r.y], [r.x + r.width, r.y], [r.x + r.width, r.y + r.height], [r.x, r.y + r.height]];\n  corners.forEach(([x, y], i) => {\n    const w = rotatePoint(x, y, cx, cy, r.rotation);\n    const [sx, sy] = worldToScreen(w.x, w.y, t);\n    coords[i * 2] = sx;\n    coords[i * 2 + 1] = sy;\n  });\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords,\n    fillRule: 'nonzero',\n  };\n}\n\nfunction rectPath(x: number, y: number, w: number, h: number): { kind: 'rect'; x: number; y: number; width: number; height: number } {\n  return { kind: 'rect', x, y, width: w, height: h };\n}\n\n/** A `DebugStroke` + color as the renderer's stroke shape. `dash` is dropped\n *  when empty rather than passed through, so a solid line stays solid. */\nfunction strokeOf(s: DebugStroke, color: string) {\n  return {\n    paint: { fill: 'solid' as const, color },\n    width: s.width,\n    ...(s.dash && s.dash.length > 0 ? { dash: [...s.dash] } : {}),\n  };\n}\n\nfunction emitHitboxes(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  view: View,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n  strokes: DebugStrokes,\n): void {\n  const fill = { fill: 'solid' as const, color: theme.hitboxFill };\n  const stroke = strokeOf(strokes.hitbox, theme.hitboxStroke);\n  for (const h of s.hitboxes) {\n    if (h.shape.kind === 'rect' && h.shape.rotation) {\n      const path = rotatedRectScreen({ ...h.shape, rotation: h.shape.rotation }, t);\n      out.push({ kind: 'path', path, fill, stroke });\n    } else if (h.shape.kind === 'rect') {\n      const [sx, sy] = worldToScreen(h.shape.x, h.shape.y, t);\n      const sw = h.shape.width * view.scale.x;\n      const sh = h.shape.height * view.scale.y;\n      out.push({ kind: 'path', path: rectPath(sx, sy, sw, sh), fill, stroke });\n    } else if (h.shape.kind === 'circle') {\n      const [cx, cy] = worldToScreen(h.shape.cx, h.shape.cy, t);\n      const rx = h.shape.r * Math.abs(view.scale.x);\n      const ry = h.shape.r * Math.abs(view.scale.y);\n      out.push({ kind: 'path', path: approxEllipseScreen(cx, cy, rx, ry), fill, stroke });\n    } else if (h.shape.kind === 'polygon' && h.shape.points.length > 2) {\n      const pts = h.shape.points;\n      const coords = new Float32Array(pts.length * 2);\n      pts.forEach((p, i) => {\n        const [sx, sy] = worldToScreen(p.x, p.y, t);\n        coords[i * 2] = sx;\n        coords[i * 2 + 1] = sy;\n      });\n      const commands = new Uint8Array(pts.length + 1).fill(PATH_L);\n      commands[0] = PATH_M;\n      commands[pts.length] = PATH_Z;\n      out.push({ kind: 'path', path: { kind: 'polygon', commands, coords, fillRule: 'nonzero' }, fill, stroke });\n    }\n    // 'path' kind: v1 punt — matches 2D behavior.\n  }\n}\n\nfunction emitBounds(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  view: View,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n  strokes: DebugStrokes,\n): void {\n  const stroke = strokeOf(strokes.bounds, theme.bounds);\n  for (const b of s.bounds) {\n    const [sx, sy] = worldToScreen(b.bounds.x, b.bounds.y, t);\n    const sw = b.bounds.width * view.scale.x;\n    const sh = b.bounds.height * view.scale.y;\n    out.push({ kind: 'path', path: rectPath(sx, sy, sw, sh), stroke });\n  }\n}\n\nfunction emitHandles(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n  strokes: DebugStrokes,\n): void {\n  const stroke = strokeOf(strokes.handle, theme.handle);\n  for (const h of s.handles) {\n    const [cx, cy] = worldToScreen(h.position.x, h.position.y, t);\n    const horiz: PolygonPath = {\n      kind: 'polygon',\n      commands: new Uint8Array([PATH_M, PATH_L]),\n      coords: new Float32Array([cx - 4, cy, cx + 4, cy]),\n      fillRule: 'nonzero',\n    };\n    const vert: PolygonPath = {\n      kind: 'polygon',\n      commands: new Uint8Array([PATH_M, PATH_L]),\n      coords: new Float32Array([cx, cy - 4, cx, cy + 4]),\n      fillRule: 'nonzero',\n    };\n    out.push({ kind: 'path', path: horiz, stroke });\n    out.push({ kind: 'path', path: vert, stroke });\n  }\n}\n\nfunction emitOrigins(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n): void {\n  const fill = { fill: 'solid' as const, color: theme.origin };\n  for (const o of s.origins) {\n    const [cx, cy] = worldToScreen(o.point.x, o.point.y, t);\n    out.push({ kind: 'path', path: approxCircleScreen(cx, cy, 3), fill });\n  }\n}\n\nfunction emitSnap(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n  strokes: DebugStrokes,\n): void {\n  const color = theme.snap;\n  for (const c of s.snap) {\n    const [cx, cy] = worldToScreen(c.point.x, c.point.y, t);\n    const cmd: PathDrawCommand = {\n      kind: 'path',\n      path: approxCircleScreen(cx, cy, 4),\n      ...(c.accepted\n        ? { fill: { fill: 'solid' as const, color } }\n        : { stroke: strokeOf(strokes.snap, color) }),\n    };\n    out.push(cmd);\n  }\n}\n\nfunction emitIds(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  t: ReturnType<typeof viewToTransform>,\n  theme: DebugTheme,\n): void {\n  // Pulls from the bounds stream — every consumer that records bounds\n  // (selection overlay's handle math, the kit's per-node debug shim) gets\n  // an id label for free.\n  for (const b of s.bounds) {\n    const [sx, sy] = worldToScreen(b.bounds.x, b.bounds.y, t);\n    out.push(textCommandFromRuns(\n      sx + 2,\n      sy + 11,\n      [{ text: b.id, fill: { fill: 'solid', color: theme.idText } }],\n      { fontFamily: 'ui-monospace, Menlo, monospace', fontSize: 10 },\n    ));\n  }\n}\n\nfunction emitLayersPanel(\n  out: DrawCommand[],\n  s: DebugSnapshot,\n  dims: Dims,\n  theme: DebugTheme,\n): void {\n  if (s.layers.length === 0) return;\n  const lineH = 14;\n  const padX = 6;\n  const padY = 4;\n  const lines = s.layers.map((l) => `[${l.index}] ${l.id} (${l.space})`);\n  // Approximate width: 11px font, monospaced — assume each glyph ≈6.6px.\n  // 2D path uses ctx.measureText; we don't have a ctx here, so fall back\n  // to a character-count estimate. Pixel-level accuracy is not load-bearing\n  // for a debug panel; right-edge anchoring stays correct.\n  const charW = 6.6;\n  let maxW = 0;\n  for (const line of lines) maxW = Math.max(maxW, line.length * charW);\n  const boxW = maxW + padX * 2;\n  const boxH = lines.length * lineH + padY * 2;\n  const x = dims.width - boxW - 8;\n  const y = 8;\n  out.push({\n    kind: 'path',\n    path: rectPath(x, y, boxW, boxH),\n    fill: { fill: 'solid', color: theme.layerTextBg },\n  });\n  for (let i = 0; i < lines.length; i++) {\n    out.push(textCommandFromRuns(\n      x + padX,\n      y + padY + i * lineH,\n      [{ text: lines[i], fill: { fill: 'solid', color: theme.layerText } }],\n      { fontFamily: 'ui-monospace, Menlo, monospace', fontSize: 11 },\n    ));\n  }\n}\n\nconst MONO = { fontFamily: 'ui-monospace, Menlo, monospace', fontSize: 11 };\nconst MONO_CHAR_W = 6.6;\nconst LINE_H = 14;\n\n/** A dark box holding monospace lines, at `(x, y)`; `y < 0` anchors its bottom\n *  that far above `bottom`. Width is estimated from the character count — there\n *  is no text measurer here, and a debug panel does not need one. */\nfunction emitTextPanel(\n  out: DrawCommand[],\n  lines: readonly string[],\n  x: number,\n  y: number,\n  color: string,\n  bg: string,\n): void {\n  const padX = 6;\n  const padY = 4;\n  let maxLen = 0;\n  for (const l of lines) maxLen = Math.max(maxLen, l.length);\n  out.push({\n    kind: 'path',\n    path: rectPath(x, y, maxLen * MONO_CHAR_W + padX * 2, lines.length * LINE_H + padY * 2),\n    fill: { fill: 'solid', color: bg },\n  });\n  for (let i = 0; i < lines.length; i++) {\n    out.push(textCommandFromRuns(\n      x + padX,\n      y + padY + i * LINE_H,\n      [{ text: lines[i], fill: { fill: 'solid', color } }],\n      MONO,\n    ));\n  }\n}\n\n/** Fixed-width number, right-aligned, `decimals` places: `%{width}.{decimals}f`. */\nfunction fixed(v: number, width: number, decimals: number): string {\n  return v.toFixed(decimals).padStart(width);\n}\n\nfunction emitFramePanel(\n  out: DrawCommand[],\n  history: readonly number[],\n  frame: FrameStats | null,\n  theme: DebugTheme,\n): void {\n  const span = history.length >= 2 ? history[history.length - 1] - history[0] : 0;\n  const interval = span > 0 ? span / (history.length - 1) : null;\n  // Columns: label, draw-call count, value, unit — every row the same width,\n  // so decimals line up down the panel.\n  const rows: [label: string, count: number | null, value: number | null, unit: string][] = [\n    ['fps', null, interval ? 1000 / interval : null, '  '],\n    ['frame', null, interval, 'ms'],\n  ];\n  if (frame) {\n    rows.push(['paint', frame.drawCalls, frame.paintMs, 'ms']);\n    for (const l of frame.layers) rows.push([l.id, l.drawCalls, l.ms, 'ms']);\n  }\n  let labelW = 0;\n  for (const [label] of rows) labelW = Math.max(labelW, label.length);\n  const line = (label: string, count: string, value: string, unit: string) =>\n    `${label.padEnd(labelW)} ${count.padStart(5)} ${value.padStart(7)} ${unit}`;\n  const lines = rows.map(([label, count, value, unit]) =>\n    line(label, count === null ? '' : String(count), value === null ? '—' : fixed(value, 7, 2), unit));\n  if (frame) lines.splice(2, 0, line('', 'draws', 'cpu', '  '));\n  emitTextPanel(out, lines, 8, 8, theme.fpsText, theme.fpsTextBg);\n}\n\nfunction emitViewport(\n  out: DrawCommand[],\n  rec: RecordedViewport,\n  view: View,\n  dims: Dims,\n  theme: DebugTheme,\n  strokes: DebugStrokes,\n): void {\n  const t = viewToTransform(view);\n  const stroke = strokeOf(strokes.viewport, theme.viewport);\n  // Where the viewport the gesture started from sits in the current camera.\n  const { from, to } = rec;\n  const [fx, fy] = worldToScreen(from.x, from.y, t);\n  out.push({\n    kind: 'path',\n    path: rectPath(fx, fy, (dims.width / from.scale.x) * view.scale.x, (dims.height / from.scale.y) * view.scale.y),\n    stroke,\n  });\n  if (rec.anchor) {\n    const [ax0, ay0] = worldToScreen(rec.anchor.x, rec.anchor.y, viewToTransform(from));\n    const [ax1, ay1] = worldToScreen(rec.anchor.x, rec.anchor.y, t);\n    out.push({ kind: 'path', path: approxCircleScreen(ax0, ay0, 2.5), fill: { fill: 'solid', color: theme.viewport } });\n    if (Math.hypot(ax1 - ax0, ay1 - ay0) > 0.5) {\n      out.push({ kind: 'path', path: segment(ax0, ay0, ax1, ay1), stroke });\n    }\n    out.push({ kind: 'path', path: approxCircleScreen(ax1, ay1, 6), stroke: strokeOf({ width: strokes.viewport.width }, theme.viewport) });\n  }\n  const text = rec.kind === 'pan'\n    ? `pan   Δ ${signed((from.x - to.x) * to.scale.x)} ${signed((from.y - to.y) * to.scale.y)} px`\n    : `zoom  ×${(to.scale.x / from.scale.x).toFixed(3)}  ${from.scale.x.toFixed(3)} → ${to.scale.x.toFixed(3)}`;\n  emitTextPanel(out, [text], 8, dims.height - LINE_H - 16, theme.viewport, theme.layerTextBg);\n}\n\nfunction signed(v: number): string {\n  const r = Math.abs(v) < 0.05 ? 0 : v;\n  return `${r >= 0 ? '+' : '-'}${Math.abs(r).toFixed(1)}`.padStart(8);\n}\n\nfunction segment(x0: number, y0: number, x1: number, y1: number): PolygonPath {\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L]),\n    coords: new Float32Array([x0, y0, x1, y1]),\n    fillRule: 'nonzero',\n  };\n}\n"],"mappings":";;;;;;;AAyBA,IAAMC,IAAa;AAQnB,SAAgBC,EAAwB,EACtC,SACA,aACoD;CAGpD,IAAMC,IAAuB,CAAC;CAC9B,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,UAAU;EACV,OAAO,GAAO,GAAM,OACdC,EAAO,OACTD,EAAW,KAAK,OAAO,cAAgB,MAAc,YAAY,IAAI,IAAI,KAAK,IAAI,CAAC,GAC/EA,EAAW,SAASF,KAAYE,EAAW,MAAM,KAC5CA,EAAW,SAAS,MAC7B,EAAW,SAAS,IAEfE,EAA0BC,EAAK,SAAS,GAAGF,GAAQG,GAAMC,GAAML,CAAU;CAEpF;AACF;AAUA,SAAgBE,EACd,GACA,GACA,GACA,GACA,IAAgC,CAAC,GAClB;CACf,IAAMI,IAAoB;EAAE,GAAGC;EAAqB,GAAIN,EAAO,SAAS,CAAC;CAAG,GACtEO,IAAwB;EAAE,GAAGC;EAAuB,GAAIR,EAAO,WAAW,CAAC;CAAG,GAC9ES,IAAIC,GACJC,IAAIC,EAAgBT,CAAI,GACxBU,IAAqB,CAAC;CAW5B,OATIb,EAAO,YAAYS,EAAE,YAAUK,EAAaD,GAAKJ,EAAE,UAAUN,GAAMC,GAAMC,GAAOE,CAAO,GACvFP,EAAO,YAAUe,EAAaF,GAAKJ,GAAGN,GAAMQ,GAAGN,GAAOE,CAAO,GAC7DP,EAAO,UAAQgB,EAAWH,GAAKJ,GAAGN,GAAMQ,GAAGN,GAAOE,CAAO,GACzDP,EAAO,WAASiB,EAAYJ,GAAKJ,GAAGE,GAAGN,GAAOE,CAAO,GACrDP,EAAO,WAASkB,EAAYL,GAAKJ,GAAGE,GAAGN,CAAK,GAC5CL,EAAO,QAAMmB,EAASN,GAAKJ,GAAGE,GAAGN,GAAOE,CAAO,GAC/CP,EAAO,OAAKoB,EAAQP,GAAKJ,GAAGE,GAAGN,CAAK,GACpCL,EAAO,UAAQqB,EAAgBR,GAAKJ,GAAGL,GAAMC,CAAK,GAClDL,EAAO,OAAKsB,EAAeT,GAAKU,GAAYd,EAAE,OAAOJ,CAAK,GACvDQ;AACT;AAIA,SAASW,EAAmB,GAAY,GAAY,GAAW,IAAW,IAAiB;CACzF,OAAOC,EAAoBC,GAAIC,GAAIC,GAAGA,GAAGC,CAAQ;AACnD;AAEA,SAASJ,EAAoB,GAAY,GAAY,GAAY,GAAY,IAAW,IAAiB;CAGvG,IAAMK,IAAO,IAAI,WAAWD,IAAW,CAAC,GAClCE,IAAS,IAAI,aAAaF,IAAW,CAAC;CAG5C,AAFA,EAAK,KAAKG,GACV,EAAO,KAAKN,IAAKO,GACjB,EAAO,KAAKN;CACZ,KAAK,IAAIO,IAAI,GAAGA,IAAIL,GAAU,KAAK;EACjC,EAAKK,KAAKC;EACV,IAAMC,IAASF,IAAIL,IAAY,KAAK,KAAK;EAEzC,AADA,EAAOK,IAAI,KAAKR,IAAKO,IAAK,KAAK,IAAIG,CAAK,GACxC,EAAOF,IAAI,IAAI,KAAKP,IAAKU,IAAK,KAAK,IAAID,CAAK;CAC9C;CAEA,OADA,EAAKP,KAAYS,GACV;EAAE,MAAM;EAAW,UAAUR;EAAM;EAAQ,UAAU;CAAU;AACxE;AAIA,SAASS,EACP,GACA,GACa;CACb,IAAMb,IAAKE,EAAE,IAAIA,EAAE,QAAQ,GAAGD,IAAKC,EAAE,IAAIA,EAAE,SAAS,GAC9CG,oBAAS,IAAI,aAAa,CAAC;CAQjC,OANA;EADiB,CAACH,EAAE,GAAGA,EAAE,CAAC;EAAG,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,CAAC;EAAG,CAACA,EAAE,IAAIA,EAAE,OAAOA,EAAE,IAAIA,EAAE,MAAM;EAAG,CAACA,EAAE,GAAGA,EAAE,IAAIA,EAAE,MAAM;CACxG,CAAA,CAAQ,SAAS,CAACY,GAAGC,IAAI,MAAM;EAC7B,IAAMC,IAAIC,EAAYH,GAAGC,GAAGf,GAAIC,GAAIC,EAAE,QAAQ,GACxC,CAACgB,GAAIC,KAAMC,EAAcJ,EAAE,GAAGA,EAAE,GAAG/B,CAAC;EAE1C,AADA,EAAOuB,IAAI,KAAKU,GAChB,EAAOV,IAAI,IAAI,KAAKW;CACtB,CAAC,GACM;EACL,MAAM;EACN,UAAU,IAAI,WAAW;GAACb;GAAQG;GAAQA;GAAQA;GAAQG;EAAM,CAAC;EACjE;EACA,UAAU;CACZ;AACF;AAEA,SAAS1C,EAAS,GAAW,GAAW,GAAW,GAAkF;CACnI,OAAO;EAAE,MAAM;EAAQ;EAAG;EAAG,OAAO8C;EAAG,QAAQM;CAAE;AACnD;AAIA,SAASC,EAAS,GAAgB,GAAe;CAC/C,OAAO;EACL,OAAO;GAAE,MAAM;GAAkB;EAAM;EACvC,OAAOxC,EAAE;EACT,GAAIA,EAAE,QAAQA,EAAE,KAAK,SAAS,IAAI,EAAE,MAAM,CAAC,GAAGA,EAAE,IAAI,EAAE,IAAI,CAAC;CAC7D;AACF;AAEA,SAASM,EACP,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMmC,IAAO;EAAE,MAAM;EAAkB,OAAO7C,EAAM;CAAW,GACzD8C,IAASF,EAAS1C,EAAQ,QAAQF,EAAM,YAAY;CAC1D,KAAK,IAAM2C,KAAKvC,EAAE,UAChB,IAAIuC,EAAE,MAAM,SAAS,UAAUA,EAAE,MAAM,UAAU;EAC/C,IAAMI,IAAOb,EAAkB;GAAE,GAAGS,EAAE;GAAO,UAAUA,EAAE,MAAM;EAAS,GAAGrC,CAAC;EAC5E,EAAI,KAAK;GAAE,MAAM;GAAQ;GAAM;GAAM;EAAO,CAAC;CAC/C,OAAO,IAAIqC,EAAE,MAAM,SAAS,QAAQ;EAClC,IAAM,CAACJ,GAAIC,KAAMC,EAAcE,EAAE,MAAM,GAAGA,EAAE,MAAM,GAAGrC,CAAC,GAChD0C,IAAKL,EAAE,MAAM,QAAQ7C,EAAK,MAAM,GAChCmD,IAAKN,EAAE,MAAM,SAAS7C,EAAK,MAAM;EACvC,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMP,EAASgD,GAAIC,GAAIQ,GAAIC,CAAE;GAAG;GAAM;EAAO,CAAC;CACzE,OAAO,IAAIN,EAAE,MAAM,SAAS,UAAU;EACpC,IAAM,CAACtB,GAAIC,KAAMmB,EAAcE,EAAE,MAAM,IAAIA,EAAE,MAAM,IAAIrC,CAAC,GAClDsB,IAAKe,EAAE,MAAM,IAAI,KAAK,IAAI7C,EAAK,MAAM,CAAC,GACtCkC,IAAKW,EAAE,MAAM,IAAI,KAAK,IAAI7C,EAAK,MAAM,CAAC;EAC5C,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMsB,EAAoBC,GAAIC,GAAIM,GAAII,CAAE;GAAG;GAAM;EAAO,CAAC;CACpF,OAAO,IAAIW,EAAE,MAAM,SAAS,aAAaA,EAAE,MAAM,OAAO,SAAS,GAAG;EAClE,IAAMO,IAAMP,EAAE,MAAM,QACdjB,IAAS,IAAI,aAAawB,EAAI,SAAS,CAAC;EAC9C,EAAI,SAAS,GAAG,MAAM;GACpB,IAAM,CAACX,GAAIC,KAAMC,EAAcU,EAAE,GAAGA,EAAE,GAAG7C,CAAC;GAE1C,AADA,EAAOuB,IAAI,KAAKU,GAChB,EAAOV,IAAI,IAAI,KAAKW;EACtB,CAAC;EACD,IAAMY,IAAW,IAAI,WAAWF,EAAI,SAAS,CAAC,CAAC,CAAC,KAAKpB,CAAM;EAG3D,AAFA,EAAS,KAAKH,GACd,EAASuB,EAAI,UAAUjB,GACvBzB,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAM;IAAE,MAAM;IAAW;IAAU;IAAQ,UAAU;GAAU;GAAG;GAAM;EAAO,CAAC;CAC3G;AAGJ;AAEA,SAASG,EACP,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMmC,IAASF,EAAS1C,EAAQ,QAAQF,EAAM,MAAM;CACpD,KAAK,IAAMqD,KAAKjD,EAAE,QAAQ;EACxB,IAAM,CAACmC,GAAIC,KAAMC,EAAcY,EAAE,OAAO,GAAGA,EAAE,OAAO,GAAG/C,CAAC,GAClD0C,IAAKK,EAAE,OAAO,QAAQvD,EAAK,MAAM,GACjCmD,IAAKI,EAAE,OAAO,SAASvD,EAAK,MAAM;EACxC,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMP,EAASgD,GAAIC,GAAIQ,GAAIC,CAAE;GAAG;EAAO,CAAC;CACnE;AACF;AAEA,SAASrC,EACP,GACA,GACA,GACA,GACA,GACM;CACN,IAAMkC,IAASF,EAAS1C,EAAQ,QAAQF,EAAM,MAAM;CACpD,KAAK,IAAM2C,KAAKvC,EAAE,SAAS;EACzB,IAAM,CAACiB,GAAIC,KAAMmB,EAAcE,EAAE,SAAS,GAAGA,EAAE,SAAS,GAAGrC,CAAC,GACtDgD,IAAqB;GACzB,MAAM;GACN,UAAU,IAAI,WAAW,CAAC3B,GAAQG,CAAM,CAAC;GACzC,QAAQ,IAAI,aAAa;IAACT,IAAK;IAAGC;IAAID,IAAK;IAAGC;GAAE,CAAC;GACjD,UAAU;EACZ,GACMiC,IAAoB;GACxB,MAAM;GACN,UAAU,IAAI,WAAW,CAAC5B,GAAQG,CAAM,CAAC;GACzC,QAAQ,IAAI,aAAa;IAACT;IAAIC,IAAK;IAAGD;IAAIC,IAAK;GAAC,CAAC;GACjD,UAAU;EACZ;EAEA,AADAd,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAM8C;GAAO;EAAO,CAAC,GAC9C9C,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAM+C;GAAM;EAAO,CAAC;CAC/C;AACF;AAEA,SAAS1C,EACP,GACA,GACA,GACA,GACM;CACN,IAAMgC,IAAO;EAAE,MAAM;EAAkB,OAAO7C,EAAM;CAAO;CAC3D,KAAK,IAAMwD,KAAKpD,EAAE,SAAS;EACzB,IAAM,CAACiB,GAAIC,KAAMmB,EAAce,EAAE,MAAM,GAAGA,EAAE,MAAM,GAAGlD,CAAC;EACtD,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMa,EAAmBE,GAAIC,GAAI,CAAC;GAAG;EAAK,CAAC;CACtE;AACF;AAEA,SAASR,EACP,GACA,GACA,GACA,GACA,GACM;CACN,IAAM2C,IAAQzD,EAAM;CACpB,KAAK,IAAM0D,KAAKtD,EAAE,MAAM;EACtB,IAAM,CAACiB,GAAIC,KAAMmB,EAAciB,EAAE,MAAM,GAAGA,EAAE,MAAM,GAAGpD,CAAC,GAChDqD,IAAuB;GAC3B,MAAM;GACN,MAAMxC,EAAmBE,GAAIC,GAAI,CAAC;GAClC,GAAIoC,EAAE,WACF,EAAE,MAAM;IAAE,MAAM;IAAkB;GAAM,EAAE,IAC1C,EAAE,QAAQd,EAAS1C,EAAQ,MAAMuD,CAAK,EAAE;EAC9C;EACA,EAAI,KAAKE,CAAG;CACd;AACF;AAEA,SAAS5C,EACP,GACA,GACA,GACA,GACM;CAIN,KAAK,IAAMsC,KAAKjD,EAAE,QAAQ;EACxB,IAAM,CAACmC,GAAIC,KAAMC,EAAcY,EAAE,OAAO,GAAGA,EAAE,OAAO,GAAG/C,CAAC;EACxD,EAAI,KAAKsD,EACPrB,IAAK,GACLC,IAAK,IACL,CAAC;GAAE,MAAMa,EAAE;GAAI,MAAM;IAAE,MAAM;IAAS,OAAOrD,EAAM;GAAO;EAAE,CAAC,GAC7D;GAAE,YAAY;GAAkC,UAAU;EAAG,CAC/D,CAAC;CACH;AACF;AAEA,SAASgB,EACP,GACA,GACA,GACA,GACM;CACN,IAAIZ,EAAE,OAAO,WAAW,GAAG;CAC3B,IAGMyD,IAAQzD,EAAE,OAAO,KAAK,MAAM,IAAI0D,EAAE,MAAM,IAAIA,EAAE,GAAG,IAAIA,EAAE,MAAM,EAAE,GAMjEC,IAAO;CACX,KAAK,IAAMC,KAAQH,GAAO,IAAO,KAAK,IAAIE,GAAMC,EAAK,SAAS,GAAK;CACnE,IAAMC,IAAOF,IAAO,IACdG,IAAOL,EAAM,SAAS,KAAQ,GAC9B1B,IAAIpC,EAAK,QAAQkE,IAAO;CAE9B,EAAI,KAAK;EACP,MAAM;EACN,MAAM1E,EAAS4C,GAAG,GAAG8B,GAAMC,CAAI;EAC/B,MAAM;GAAE,MAAM;GAAS,OAAOlE,EAAM;EAAY;CAClD,CAAC;CACD,KAAK,IAAI6B,IAAI,GAAGA,IAAIgC,EAAM,QAAQ,KAChC,EAAI,KAAKD,EACPzB,IAAI,GACJ,KAAWN,IAAI,IACf,CAAC;EAAE,MAAMgC,EAAMhC;EAAI,MAAM;GAAE,MAAM;GAAS,OAAO7B,EAAM;EAAU;CAAE,CAAC,GACpE;EAAE,YAAY;EAAkC,UAAU;CAAG,CAC/D,CAAC;AAEL;AAEA,IAAMmE,IAAO;CAAE,YAAY;CAAkC,UAAU;AAAG,GACpEC,IAAc,KACdC,IAAS;AAKf,SAASC,EACP,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAEIC,IAAS;CACb,KAAK,IAAMT,KAAKD,GAAO,IAAS,KAAK,IAAIU,GAAQT,EAAE,MAAM;CACzD,EAAI,KAAK;EACP,MAAM;EACN,MAAMvE,EAAS4C,GAAGC,GAAGmC,IAASH,IAAc,IAAUP,EAAM,SAASQ,IAAS,CAAQ;EACtF,MAAM;GAAE,MAAM;GAAS,OAAOG;EAAG;CACnC,CAAC;CACD,KAAK,IAAI3C,IAAI,GAAGA,IAAIgC,EAAM,QAAQ,KAChC,EAAI,KAAKD,EACPzB,IAAI,GACJC,IAAI,IAAOP,IAAIwC,GACf,CAAC;EAAE,MAAMR,EAAMhC;EAAI,MAAM;GAAE,MAAM;GAAS;EAAM;CAAE,CAAC,GACnDsC,CACF,CAAC;AAEL;AAGA,SAASM,EAAM,GAAW,GAAe,GAA0B;CACjE,OAAOC,EAAE,QAAQC,CAAQ,CAAC,CAAC,SAASC,CAAK;AAC3C;AAEA,SAAS3D,EACP,GACA,GACA,GACA,GACM;CACN,IAAM4D,IAAOC,EAAQ,UAAU,IAAIA,EAAQA,EAAQ,SAAS,KAAKA,EAAQ,KAAK,GACxEC,IAAWF,IAAO,IAAIA,KAAQC,EAAQ,SAAS,KAAK,MAGpDE,IAAoF,CACxF;EAAC;EAAO;EAAMD,IAAW,MAAOA,IAAW;EAAM;CAAI,GACrD;EAAC;EAAS;EAAMA;EAAU;CAAI,CAChC;CACA,IAAIE,GAAO;EACT,EAAK,KAAK;GAAC;GAASA,EAAM;GAAWA,EAAM;GAAS;EAAI,CAAC;EACzD,KAAK,IAAMnB,KAAKmB,EAAM,QAAQ,EAAK,KAAK;GAACnB,EAAE;GAAIA,EAAE;GAAWA,EAAE;GAAI;EAAI,CAAC;CACzE;CACA,IAAIoB,IAAS;CACb,KAAK,IAAM,CAACC,MAAUH,GAAM,IAAS,KAAK,IAAIE,GAAQC,EAAM,MAAM;CAClE,IAAMnB,KAAQ,GAAe,GAAe,GAAe,MACzD,GAAGmB,EAAM,OAAOD,CAAM,EAAE,GAAGE,EAAM,SAAS,CAAC,EAAE,GAAGC,EAAM,SAAS,CAAC,EAAE,GAAGC,KACjEzB,IAAQmB,EAAK,KAAK,CAACG,GAAOC,GAAOC,GAAOC,OAC5CtB,EAAKmB,GAAOC,MAAU,OAAO,KAAK,OAAOA,CAAK,GAAGC,MAAU,OAAO,MAAMZ,EAAMY,GAAO,GAAG,CAAC,GAAGC,CAAI,CAAC;CAEnG,AADIL,KAAOpB,EAAM,OAAO,GAAG,GAAGG,EAAK,IAAI,SAAS,OAAO,IAAI,CAAC,GAC5DM,EAAc9D,GAAKqD,GAAO,GAAG,GAAG7D,EAAM,SAASA,EAAM,SAAS;AAChE;AAEA,SAASS,EACP,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMH,IAAIC,EAAgBT,CAAI,GACxBgD,IAASF,EAAS1C,EAAQ,UAAUF,EAAM,QAAQ,GAElD,EAAE,SAAM,UAAOuF,GACf,CAACC,GAAIC,KAAMhD,EAAciD,EAAK,GAAGA,EAAK,GAAGpF,CAAC;CAMhD,IALAE,EAAI,KAAK;EACP,MAAM;EACN,MAAMjB,EAASiG,GAAIC,GAAK1F,EAAK,QAAQ2F,EAAK,MAAM,IAAK5F,EAAK,MAAM,GAAIC,EAAK,SAAS2F,EAAK,MAAM,IAAK5F,EAAK,MAAM,CAAC;EAC9G;CACF,CAAC,GACGyF,EAAI,QAAQ;EACd,IAAM,CAACI,GAAKC,KAAOnD,EAAc8C,EAAI,OAAO,GAAGA,EAAI,OAAO,GAAGhF,EAAgBmF,CAAI,CAAC,GAC5E,CAACG,GAAKC,KAAOrD,EAAc8C,EAAI,OAAO,GAAGA,EAAI,OAAO,GAAGjF,CAAC;EAK9D,AAJAE,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMW,EAAmBwE,GAAKC,GAAK,GAAG;GAAG,MAAM;IAAE,MAAM;IAAS,OAAO5F,EAAM;GAAS;EAAE,CAAC,GAC9G,KAAK,MAAM6F,IAAMF,GAAKG,IAAMF,CAAG,IAAI,MACrCpF,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMuF,EAAQJ,GAAKC,GAAKC,GAAKC,CAAG;GAAG;EAAO,CAAC,GAEtEtF,EAAI,KAAK;GAAE,MAAM;GAAQ,MAAMW,EAAmB0E,GAAKC,GAAK,CAAC;GAAG,QAAQlD,EAAS,EAAE,OAAO1C,EAAQ,SAAS,MAAM,GAAGF,EAAM,QAAQ;EAAE,CAAC;CACvI;CAIA,EAAcQ,GAAK,CAHN+E,EAAI,SAAS,QACtB,WAAWS,GAAQN,EAAK,IAAIO,EAAG,KAAKA,EAAG,MAAM,CAAC,EAAE,GAAGD,GAAQN,EAAK,IAAIO,EAAG,KAAKA,EAAG,MAAM,CAAC,EAAE,OACxF,WAAWA,EAAG,MAAM,IAAIP,EAAK,MAAM,EAAA,CAAG,QAAQ,CAAC,EAAE,IAAIA,EAAK,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAKO,EAAG,MAAM,EAAE,QAAQ,CAAC,GAClF,GAAG,GAAGlG,EAAK,SAASsE,IAAS,IAAIrE,EAAM,UAAUA,EAAM,WAAW;AAC5F;AAEA,SAASgG,EAAO,GAAmB;CACjC,IAAMzE,IAAI,KAAK,IAAImD,CAAC,IAAI,MAAO,IAAIA;CACnC,OAAO,GAAGnD,KAAK,IAAI,MAAM,MAAM,KAAK,IAAIA,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC;AACpE;AAEA,SAASwE,EAAQ,GAAY,GAAY,GAAY,GAAyB;CAC5E,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW,CAACpE,GAAQG,CAAM,CAAC;EACzC,QAAQ,IAAI,aAAa;GAACoE;GAAIC;GAAIC;GAAIC;EAAE,CAAC;EACzC,UAAU;CACZ;AACF"}

package/dist/debug/createDebugSink.js

@@ -0,0 +1,83 @@
+//#region src/debug/createDebugSink.ts
+function e(e) {
+	let t = {
+		hitboxes: [],
+		handles: [],
+		bounds: [],
+		origins: [],
+		snap: [],
+		layers: [],
+		viewport: null,
+		frame: null
+	};
+	return {
+		recordHitbox(n, r, i) {
+			e.hitboxes && t.hitboxes.push({
+				id: n,
+				kind: r,
+				shape: i
+			});
+		},
+		recordHandle(n, r, i) {
+			e.handles && t.handles.push({
+				id: n,
+				position: r,
+				kind: i
+			});
+		},
+		recordBounds(n, r) {
+			e.bounds && t.bounds.push({
+				id: n,
+				bounds: r
+			});
+		},
+		recordOrigin(n, r) {
+			e.origins && t.origins.push({
+				id: n,
+				point: r
+			});
+		},
+		recordSnapCandidate(n, r) {
+			e.snap && t.snap.push({
+				point: n,
+				accepted: r
+			});
+		},
+		recordLayer(n, r, i, a) {
+			e.layers && t.layers.push({
+				id: n,
+				label: r,
+				space: i,
+				index: a
+			});
+		},
+		recordViewport(n, r, i, a) {
+			e.viewport && (t.viewport = a ? {
+				kind: n,
+				from: r,
+				to: i,
+				anchor: a
+			} : {
+				kind: n,
+				from: r,
+				to: i
+			});
+		},
+		recordFrame(n) {
+			e.fps && (t.frame = n);
+		},
+		beginFrame() {
+			t.hitboxes.length = 0, t.handles.length = 0, t.bounds.length = 0, t.origins.length = 0, t.layers.length = 0;
+		},
+		clearSnap() {
+			t.snap.length = 0;
+		},
+		snapshot() {
+			return t;
+		}
+	};
+}
+//#endregion
+export { e as createDebugSink };
+
+//# sourceMappingURL=createDebugSink.js.map

package/dist/debug/createDebugSink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDebugSink.js","names":["createDebugSink","snap","config","anchor","stats"],"sources":["../../src/debug/createDebugSink.ts"],"sourcesContent":["import type {\n  CanvasDebugSink,\n  DebugConfig,\n  DebugSnapshot,\n  HandleKind,\n  HitShape,\n} from './types';\n\n/**\n * Build a sink that stores recorded primitives in arrays keyed by feature.\n * Each `recordX` method checks the matching flag in `config` first — when\n * the feature is off, the call no-ops, so callers can record unconditionally\n * without an extra check.\n *\n * `beginFrame()` clears every per-frame array. `clearSnap()` clears the snap\n * array. Snap, the latest viewport record and the last frame's stats survive\n * across frames.\n *\n * `snapshot()` returns live references — no copy. The overlay layer reads\n * these in the same render frame.\n */\nexport function createDebugSink(config: DebugConfig): CanvasDebugSink {\n  const snap: DebugSnapshot = {\n    hitboxes: [],\n    handles: [],\n    bounds: [],\n    origins: [],\n    snap: [],\n    layers: [],\n    viewport: null,\n    frame: null,\n  };\n  return {\n    recordHitbox(id, kind, shape: HitShape) {\n      if (!config.hitboxes) return;\n      snap.hitboxes.push({ id, kind, shape });\n    },\n    recordHandle(id, position, kind: HandleKind) {\n      if (!config.handles) return;\n      snap.handles.push({ id, position, kind });\n    },\n    recordBounds(id, bounds) {\n      if (!config.bounds) return;\n      snap.bounds.push({ id, bounds });\n    },\n    recordOrigin(id, point) {\n      if (!config.origins) return;\n      snap.origins.push({ id, point });\n    },\n    recordSnapCandidate(point, accepted) {\n      if (!config.snap) return;\n      snap.snap.push({ point, accepted });\n    },\n    recordLayer(id, label, space, index) {\n      if (!config.layers) return;\n      snap.layers.push({ id, label, space, index });\n    },\n    recordViewport(kind, from, to, anchor) {\n      if (!config.viewport) return;\n      snap.viewport = anchor ? { kind, from, to, anchor } : { kind, from, to };\n    },\n    recordFrame(stats) {\n      if (!config.fps) return;\n      snap.frame = stats;\n    },\n    beginFrame() {\n      snap.hitboxes.length = 0;\n      snap.handles.length = 0;\n      snap.bounds.length = 0;\n      snap.origins.length = 0;\n      snap.layers.length = 0;\n    },\n    clearSnap() {\n      snap.snap.length = 0;\n    },\n    snapshot() {\n      return snap;\n    },\n  };\n}\n"],"mappings":";AAqBA,SAAgBA,EAAgB,GAAsC;CACpE,IAAMC,IAAsB;EAC1B,UAAU,CAAC;EACX,SAAS,CAAC;EACV,QAAQ,CAAC;EACT,SAAS,CAAC;EACV,MAAM,CAAC;EACP,QAAQ,CAAC;EACT,UAAU;EACV,OAAO;CACT;CACA,OAAO;EACL,aAAa,GAAI,GAAM,GAAiB;GACtC,AAAKC,EAAO,YACZD,EAAK,SAAS,KAAK;IAAE;IAAI;IAAM;GAAM,CAAC;EACxC;EACA,aAAa,GAAI,GAAU,GAAkB;GAC3C,AAAKC,EAAO,WACZD,EAAK,QAAQ,KAAK;IAAE;IAAI;IAAU;GAAK,CAAC;EAC1C;EACA,aAAa,GAAI,GAAQ;GACvB,AAAKC,EAAO,UACZD,EAAK,OAAO,KAAK;IAAE;IAAI;GAAO,CAAC;EACjC;EACA,aAAa,GAAI,GAAO;GACtB,AAAKC,EAAO,WACZD,EAAK,QAAQ,KAAK;IAAE;IAAI;GAAM,CAAC;EACjC;EACA,oBAAoB,GAAO,GAAU;GACnC,AAAKC,EAAO,QACZD,EAAK,KAAK,KAAK;IAAE;IAAO;GAAS,CAAC;EACpC;EACA,YAAY,GAAI,GAAO,GAAO,GAAO;GACnC,AAAKC,EAAO,UACZD,EAAK,OAAO,KAAK;IAAE;IAAI;IAAO;IAAO;GAAM,CAAC;EAC9C;EACA,eAAe,GAAM,GAAM,GAAI,GAAQ;GACrC,AAAKC,EAAO,aACZ,EAAK,WAAWC,IAAS;IAAE;IAAM;IAAM;IAAI;GAAO,IAAI;IAAE;IAAM;IAAM;GAAG;EACzE;EACA,YAAY,GAAO;GACjB,AAAKD,EAAO,QACZ,EAAK,QAAQE;EACf;EACA,aAAa;GAKX,AAJA,EAAK,SAAS,SAAS,GACvB,EAAK,QAAQ,SAAS,GACtB,EAAK,OAAO,SAAS,GACrB,EAAK,QAAQ,SAAS,GACtB,EAAK,OAAO,SAAS;EACvB;EACA,YAAY;GACV,EAAK,KAAK,SAAS;EACrB;EACA,WAAW;GACT,OAAOH;EACT;CACF;AACF"}