@weasel-js/core 1.6.1 → 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-7mCcm6qG.d.ts → cornerHandles-CDcZOV8h.d.ts}

@@ -1,5 +1,56 @@
-import { ResizeAnchor, Bounds, DebugSink, ModifierState } from '@weasel-js/routing';
-import { B as BoundsConstraint, P as PointSnapBehavior, a as PointSnapFrame } from './types-D_74YlWs.js';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-DSjd6W3n.js';
+import { Bounds, ResizeAnchor } from '@weasel-js/routing';
+
+/** Option surface for the `resize` action. */
+
+/** Options for the `resize` action: the constraints applied to the dragged
+ *  bounding box, how a gesture expands a group into its leaves, and its
+ *  history and lifecycle. `<SceneCanvas>` publishes them as the
+ *  `resizePolicy` dep (`resizePolicyOptions`). */
+interface UseResizeOptions<TPose> {
+    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
+     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
+     *  comes from `<SceneCanvas poseDescriptor>`. */
+    behaviors?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never;
+    /** History label for the committed resize. Default `'Resize'`. */
+    resizeLabel?: string;
+    /** Commit without an undo entry (`scene.untracked`), bypassing the
+     *  consumer `applyOps` hook. Unset, a behavior's `defaultTransient` decides. */
+    transient?: boolean;
+    /** Fired when the resize starts, with the ids it writes. */
+    onGestureStart?: (ids: string[]) => void;
+    /** Fired once per `onGestureStart`: `true` when the resize wrote to the
+     *  document, `false` on cancel, a behavior abort, or no change. */
+    onGestureEnd?: (committed: boolean) => void;
+    /** Optional: expand the incoming id into leaf ids before pose lookups.
+     *  Used for group expansion: when the
+     *  gesture is started against a group id, the kit
+     *  resizes by computing the union AABB of the leaves' origin bounds,
+     *  running the compute pipeline on that union rect (group bounds), and
+     *  remapping each leaf via `geometry.remapBounds(leaf, originGroupBounds,
+     *  proposedGroupBounds)`.
+     *
+     *  When `expandIds` is omitted or returns the original single id, the
+     *  gesture takes the single-leaf path (the leaf's own bounds become both
+     *  the origin and the target of the same `remapBounds` call).
+     *
+     *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
+    expandIds?: (ids: string[]) => string[];
+    /** Behaviors that operate on world-space anchor points. Fire after
+     *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
+     *  with world-space frame points and returns at most one `PointSnapResult`;
+     *  the hook back-solves the local pose so the chosen frame's world point
+     *  lands on the snap target. First non-null result wins. */
+    pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
+    /** Per-node resizability predicate. Returns `false` for nodes that should
+     *  never show resize handles (and thus can't start a resize gesture) — e.g.
+     *  fixed-footprint icons, locked layers. `<SceneCanvas>` folds this over the
+     *  current selection into the `selectionResizable` rule-ctx flag, so the
+     *  default `selection.resize-handles` chrome rule hides handles whenever any
+     *  selected node is non-resizable (which also disables the affordance, since
+     *  visible==hittable). Default: every node resizable. */
+    resizable?: (id: string) => boolean;
+}
 
 /** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
 interface CornerHandle {
@@ -63,72 +114,4 @@ declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
     y: number;
 };
 
-/** Option surface for the `resize` action.
- *
- *  Lives in a sibling file (not `resize.ts`) so the type contract stays stable
- *  even after the legacy `useResize` hook is gone.
- *  Consumers should import from here directly; `resize.ts` re-exports the
- *  same symbol for back-compat. */
-
-/** Options for the `resize` action: the constraints applied to the dragged
- *  bounding box, and how a gesture expands a group into its leaves. */
-interface UseResizeOptions<TPose> {
-    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
-     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
-     *  comes from `<SceneCanvas poseDescriptor>`. */
-    behaviors?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never;
-    resizeLabel?: string;
-    /** Reserved; resize is never transient in practice. Ignored. */
-    transient?: boolean;
-    onGestureStart?: (id: string) => void;
-    onGestureEnd?: (committed: boolean) => void;
-    /** Optional: expand the incoming id into leaf ids before pose lookups.
-     *  Mirrors `useMove`'s `expandIds`. Used for group expansion: when the
-     *  gesture is started against a group id, the kit
-     *  resizes by computing the union AABB of the leaves' origin bounds,
-     *  running the compute pipeline on that union rect (group bounds), and
-     *  remapping each leaf via `geometry.remapBounds(leaf, originGroupBounds,
-     *  proposedGroupBounds)`.
-     *
-     *  When `expandIds` is omitted or returns the original single id, the
-     *  gesture takes the single-leaf path (the leaf's own bounds become both
-     *  the origin and the target of the same `remapBounds` call).
-     *
-     *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
-    expandIds?: (ids: string[]) => string[];
-    /** Behaviors that operate on world-space anchor points. Fire after
-     *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
-     *  with world-space frame points and returns at most one `PointSnapResult`;
-     *  the hook back-solves the local pose so the chosen frame's world point
-     *  lands on the snap target. First non-null result wins. */
-    pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
-    /** Optional debug sink. When supplied, records corner-handle positions +
-     *  circular hitboxes when the gesture starts (covers the on-screen
-     *  handles for the resized target). Tree-shakes via optional-chain
-     *  when omitted. */
-    debug?: DebugSink;
-    /** Hit-test radius for corner handles, in screen pixels. Used purely for
-     *  the recorded debug hitbox circle radius — does not affect actual hit
-     *  math (which lives in `usePointerGestures`). Default `8`. */
-    handleHitRadius?: number;
-    /** Per-node resizability predicate. Returns `false` for nodes that should
-     *  never show resize handles (and thus can't start a resize gesture) — e.g.
-     *  fixed-footprint icons, locked layers. `<SceneCanvas>` folds this over the
-     *  current selection into the `selectionResizable` rule-ctx flag, so the
-     *  default `selection.resize-handles` chrome rule hides handles whenever any
-     *  selected node is non-resizable (which also disables the affordance, since
-     *  visible==hittable). Default: every node resizable. */
-    resizable?: (id: string) => boolean;
-}
-
-/** 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":"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"}