@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/useCanvasView.js

@@ -1,9 +1,16 @@
-import { normalizeView as e } from "../core/viewport/view.js";
-import { clampView as t } from "../core/viewport/clampView.js";
-import { useCallback as n, useRef as r } from "react";
-import { useLatest as i } from "@weasel-js/react";
+import { normalizeView, sameView } from "../core/viewport/view.js";
+import { clampView } from "../core/viewport/clampView.js";
+import { useCallback, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/useCanvasView.ts
-var a = {
+/**
+* A camera: held in a ref when uncontrolled, taken from the `view` option when
+* controlled, with one write path and one subscriber list over both.
+* `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each
+* `<CanvasView>` makes its own.
+*/
+var IDENTITY = {
 	x: 0,
 	y: 0,
 	scale: {
@@ -11,57 +18,80 @@ var a = {
 		y: 1
 	}
 };
-function o(o) {
-	let { view: s, defaultView: c, onViewChange: l, viewBounds: u, dims: d, requestRedraw: f } = o, p = typeof s == "function" ? s : void 0, m = s === void 0 || p ? void 0 : e(s), h = r(m ?? e(c ?? a)), g = r(/* @__PURE__ */ new Set()), _ = i({
-		controlled: s !== void 0,
-		derived: p,
-		onViewChange: l,
-		viewBounds: u,
-		dims: d,
-		requestRedraw: f
-	}), v = r(!1), y = n(() => {
-		let t = _.current.derived;
-		return t ? e(t()) : h.current;
-	}, [_]), b = n((n, r) => {
-		let { controlled: i, derived: a, onViewChange: o, viewBounds: s, dims: c, requestRedraw: l } = _.current, u = e(n), d = s ? t(u, s, c()) : u;
-		if (i) {
-			r && !v.current && (v.current = !0, console.warn(o ? "[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path." : "[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.")), o?.(d), a && l();
+function useCanvasView(opts) {
+	const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;
+	const derived = typeof viewProp === "function" ? viewProp : void 0;
+	const controlledView = viewProp === void 0 || derived ? void 0 : normalizeView(viewProp);
+	const viewRef = useRef(controlledView ?? normalizeView(defaultView ?? IDENTITY));
+	const viewSubsRef = useRef(/* @__PURE__ */ new Set());
+	const live = useLatest({
+		controlled: viewProp !== void 0,
+		derived,
+		onViewChange,
+		viewBounds,
+		dims,
+		requestRedraw
+	});
+	const controlledWarnedRef = useRef(false);
+	const getView = useCallback(() => {
+		const thunk = live.current.derived;
+		return thunk ? normalizeView(thunk()) : viewRef.current;
+	}, [live]);
+	const write = useCallback((next, imperative) => {
+		const { controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw } = live.current;
+		const valid = normalizeView(next);
+		const clamped = bounds ? clampView(valid, bounds, size()) : valid;
+		if (controlled) {
+			if (imperative && !controlledWarnedRef.current) {
+				controlledWarnedRef.current = true;
+				console.warn(forward ? "[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path." : "[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.");
+			}
+			forward?.(clamped);
+			if (derived) redraw();
 			return;
 		}
-		h.current = d;
-		for (let e of g.current) e(d);
-		o?.(d), l();
-	}, [_]), x = n((e) => {
-		b(typeof e == "function" ? e(y()) : e, !0);
-	}, [b, y]), S = n((e) => {
-		b(e, !1);
-	}, [b]), C = n((e) => (g.current.add(e), () => {
-		g.current.delete(e);
-	}), []), w = r(!1);
+		viewRef.current = clamped;
+		for (const fn of viewSubsRef.current) fn(clamped);
+		forward?.(clamped);
+		redraw();
+	}, [live]);
+	const setView = useCallback((next) => {
+		write(typeof next === "function" ? next(getView()) : next, true);
+	}, [write, getView]);
+	const setViewFromInput = useCallback((next) => {
+		write(next, false);
+	}, [write]);
+	const subscribeView = useCallback((fn) => {
+		viewSubsRef.current.add(fn);
+		return () => {
+			viewSubsRef.current.delete(fn);
+		};
+	}, []);
+	const controlledMovedRef = useRef(false);
+	const adoptControlled = () => {
+		if (!controlledView) return;
+		controlledMovedRef.current ||= !sameView(viewRef.current, controlledView);
+		viewRef.current = controlledView;
+	};
 	return {
-		viewRef: h,
-		controlled: m,
-		setView: x,
-		setViewFromInput: S,
-		getView: y,
-		subscribeView: C,
-		adoptControlled: () => {
-			if (!m) return;
-			let e = h.current;
-			w.current ||= e.x !== m.x || e.y !== m.y || e.scale.x !== m.scale.x || e.scale.y !== m.scale.y, h.current = m;
-		},
-		announceControlled: n(() => {
-			if (w.current) {
-				w.current = !1;
-				for (let e of g.current) e(h.current);
-			}
+		viewRef,
+		controlled: controlledView,
+		setView,
+		setViewFromInput,
+		getView,
+		subscribeView,
+		adoptControlled,
+		announceControlled: useCallback(() => {
+			if (!controlledMovedRef.current) return;
+			controlledMovedRef.current = false;
+			for (const fn of viewSubsRef.current) fn(viewRef.current);
 		}, []),
-		clearSubscribers: n(() => {
-			g.current.clear();
+		clearSubscribers: useCallback(() => {
+			viewSubsRef.current.clear();
 		}, [])
 	};
 }
-//#endregion
-export { o as useCanvasView };
 
+//#endregion
+export { useCanvasView };
 //# sourceMappingURL=useCanvasView.js.map

package/dist/canvas/useCanvasView.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasView.js","names":["IDENTITY","useCanvasView","viewProp","opts","derived","controlledView","normalizeView","viewRef","useRef","defaultView","viewSubsRef","live","useLatest","controlledWarnedRef","getView","useCallback","thunk","write","forward","bounds","size","redraw","valid","next","clamped","clampView","controlled","imperative","fn","setView","setViewFromInput","subscribeView","controlledMovedRef","was"],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A camera: held in a ref when uncontrolled, taken from the `view` option when\n * controlled, with one write path and one subscriber list over both.\n * `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each\n * `<CanvasView>` makes its own.\n */\nimport { useCallback, useRef, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dims } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { clampView } from 'core/viewport/clampView';\nimport { normalizeView, type View } from 'core/viewport/view';\n\n/** The view props a canvas takes for its camera. */\nexport interface CameraProps {\n  /** Controlled viewport. When supplied, the canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan: every write to the view passes through\n   * `clampView` first, keeping the visible rect inside `viewBounds`. An axis where the\n   * visible rect is larger than the bounds is centered. Has no effect on `scale`.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n}\n\n/** Inputs to {@link useCanvasView}: the camera's view props and what a write\n *  needs from whatever the camera looks through. */\nexport interface CanvasViewOptions {\n  /** Supplied, the camera is controlled. A thunk is a camera derived from\n   *  something else, read fresh at every {@link CanvasViewState.getView}. */\n  view: View | (() => View) | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}\n\n/** What `useCanvasView` hands back. The owner decides when in a commit\n *  the two controlled steps run, since they have to sit among its own effects. */\nexport interface CanvasViewState {\n  /** The view in effect. Written by a write when uncontrolled and by\n   *  `adoptControlled` when controlled. A camera derived by a thunk is not\n   *  kept here: read `getView`. */\n  viewRef: MutableRefObject<View>;\n  /** This render's controlled view, absent when the camera is uncontrolled or\n   *  derived. A new object every render, so compare its numbers. */\n  controlled: View | undefined;\n  /** The imperative write. Controlled, it is forwarded to `onViewChange`\n   *  instead of applied, and says so once per mount. */\n  setView: (next: View | ((current: View) => View)) => void;\n  /** The write input makes. Controlled, forwarding it to `onViewChange` is how\n   *  the owner hears of a pan at all, so nothing is warned. */\n  setViewFromInput: (next: View) => void;\n  getView: () => View;\n  subscribeView: (fn: (v: View) => void) => () => void;\n  /** Take this render's controlled view into `viewRef`. Call from an insertion effect. */\n  adoptControlled: () => void;\n  /** Tell subscribers of a controlled view that moved since the last call.\n   *  A controlled view reaches the ref with no write, so this is where they\n   *  hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nconst IDENTITY: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const derived = typeof viewProp === 'function' ? viewProp : undefined;\n  const controlledView = viewProp === undefined || derived ? undefined : normalizeView(viewProp as View);\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(controlledView ?? normalizeView(defaultView ?? IDENTITY));\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const live = useLatest({\n    controlled: viewProp !== undefined, derived, onViewChange, viewBounds, dims, requestRedraw,\n  });\n  const controlledWarnedRef = useRef(false);\n\n  const getView = useCallback((): View => {\n    const thunk = live.current.derived;\n    return thunk ? normalizeView(thunk()) : viewRef.current;\n  }, [live]);\n\n  const write = useCallback((next: View, imperative: boolean): void => {\n    const {\n      controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw,\n    } = live.current;\n    const valid = normalizeView(next);\n    const clamped = bounds ? clampView(valid, bounds, size()) : valid;\n    if (controlled) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      if (imperative && !controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      // A derived camera has no prop to change, so nothing else repaints it.\n      if (derived) redraw();\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    forward?.(clamped);\n    redraw();\n  }, [live]);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    write(typeof next === 'function' ? next(getView()) : next, true);\n  }, [write, getView]);\n  const setViewFromInput = useCallback((next: View) => { write(next, false); }, [write]);\n\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  const controlledMovedRef = useRef(false);\n  // A closure over this render's prop, not a ref read: the owner calls it\n  // from the same render's insertion effect.\n  const adoptControlled = (): void => {\n    if (!controlledView) return;\n    const was = viewRef.current;\n    controlledMovedRef.current ||= was.x !== controlledView.x || was.y !== controlledView.y\n      || was.scale.x !== controlledView.scale.x || was.scale.y !== controlledView.scale.y;\n    viewRef.current = controlledView;\n  };\n  const announceControlled = useCallback(() => {\n    if (!controlledMovedRef.current) return;\n    controlledMovedRef.current = false;\n    for (const fn of viewSubsRef.current) fn(viewRef.current);\n  }, []);\n  const clearSubscribers = useCallback(() => { viewSubsRef.current.clear(); }, []);\n\n  return {\n    viewRef, controlled: controlledView, setView, setViewFromInput, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;AA0EA,IAAMA,IAAiB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAE3D,SAAgBC,EAAc,GAA0C;CACtE,IAAM,EAAE,MAAMC,GAAU,gBAAa,iBAAc,eAAY,SAAM,qBAAkBC,GACjFC,IAAU,OAAOF,KAAa,aAAaA,IAAW,KAAA,GACtDG,IAAiBH,MAAa,KAAA,KAAaE,IAAU,KAAA,IAAYE,EAAcJ,CAAgB,GAG/FK,IAAUC,EAAaH,KAAkBC,EAAcG,KAAeT,CAAQ,CAAC,GAC/EU,IAAcF,kBAA+B,IAAI,IAAI,CAAC,GACtDG,IAAOC,EAAU;EACrB,YAAYV,MAAa,KAAA;EAAW;EAAS;EAAc;EAAY;EAAM;CAC/E,CAAC,GACKW,IAAsBL,EAAO,EAAK,GAElCM,IAAUC,QAAwB;EACtC,IAAMC,IAAQL,EAAK,QAAQ;EAC3B,OAAOK,IAAQV,EAAcU,EAAM,CAAC,IAAIT,EAAQ;CAClD,GAAG,CAACI,CAAI,CAAC,GAEHM,IAAQF,GAAa,GAAY,MAA8B;EACnE,IAAM,EACJ,eAAY,YAAS,cAAcG,GAAS,YAAYC,GAAQ,MAAMC,GAAM,eAAeC,MACzFV,EAAK,SACHW,IAAQhB,EAAciB,CAAI,GAC1BC,IAAUL,IAASM,EAAUH,GAAOH,GAAQC,EAAK,CAAC,IAAIE;EAC5D,IAAII,GAAY;GAWd,AARIC,KAAc,CAACd,EAAoB,YACrC,EAAoB,UAAU,IAC9B,QAAQ,KAAKK,IACT,wMACA,4LAA4L,IAElMA,IAAUM,CAAO,GAEbpB,KAASiB,EAAO;GACpB;EACF;EACA,EAAQ,UAAUG;EAClB,KAAK,IAAMI,KAAMlB,EAAY,SAAS,EAAGc,CAAO;EAEhD,AADAN,IAAUM,CAAO,GACjBH,EAAO;CACT,GAAG,CAACV,CAAI,CAAC,GAEHkB,IAAUd,GAAa,MAA2C;EACtE,EAAM,OAAOQ,KAAS,aAAaA,EAAKT,EAAQ,CAAC,IAAIS,GAAM,EAAI;CACjE,GAAG,CAACN,GAAOH,CAAO,CAAC,GACbgB,IAAmBf,GAAa,MAAe;EAAE,EAAMQ,GAAM,EAAK;CAAG,GAAG,CAACN,CAAK,CAAC,GAE/Ec,IAAgBhB,GAAa,OACjCL,EAAY,QAAQ,IAAIkB,CAAE,SACb;EAAE,EAAY,QAAQ,OAAOA,CAAE;CAAG,IAC9C,CAAC,CAAC,GAECI,IAAqBxB,EAAO,EAAK;CAiBvC,OAAO;EACL;EAAS,YAAYH;EAAgB;EAAS;EAAkB;EAAS;EACzE,uBAhBkC;GAClC,IAAI,CAACA,GAAgB;GACrB,IAAM4B,IAAM1B,EAAQ;GAGpB,AAFA,EAAmB,YAAY0B,EAAI,MAAM5B,EAAe,KAAK4B,EAAI,MAAM5B,EAAe,KACjF4B,EAAI,MAAM,MAAM5B,EAAe,MAAM,KAAK4B,EAAI,MAAM,MAAM5B,EAAe,MAAM,GACpF,EAAQ,UAAUA;EACpB;EAUmB,oBATQU,QAAkB;GAC3C,IAAKiB,EAAmB,SACxB;MAAmB,UAAU;IAC7B,KAAK,IAAMJ,KAAMlB,EAAY,SAAS,EAAGH,EAAQ,OAAO;GAD3B;EAE/B,GAAG,CAAC,CAKe;EAAoB,kBAJdQ,QAAkB;GAAE,EAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}
+{"version":3,"file":"useCanvasView.js","names":[],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A camera: held in a ref when uncontrolled, taken from the `view` option when\n * controlled, with one write path and one subscriber list over both.\n * `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each\n * `<CanvasView>` makes its own.\n */\nimport { useCallback, useRef, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dims } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { clampView } from 'core/viewport/clampView';\nimport { normalizeView, sameView, type View } from 'core/viewport/view';\n\n/** The view props a canvas takes for its camera. */\nexport interface CameraProps {\n  /** Controlled viewport. When supplied, the canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan: every write to the view passes through\n   * `clampView` first, keeping the visible rect inside `viewBounds`. An axis where the\n   * visible rect is larger than the bounds is centered. Has no effect on `scale`.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n}\n\n/** Inputs to {@link useCanvasView}: the camera's view props and what a write\n *  needs from whatever the camera looks through. */\nexport interface CanvasViewOptions {\n  /** Supplied, the camera is controlled. A thunk is a camera derived from\n   *  something else, read fresh at every {@link CanvasViewState.getView}. */\n  view: View | (() => View) | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}\n\n/** What `useCanvasView` hands back. The owner decides when in a commit\n *  the two controlled steps run, since they have to sit among its own effects. */\nexport interface CanvasViewState {\n  /** The view in effect. Written by a write when uncontrolled and by\n   *  `adoptControlled` when controlled. A camera derived by a thunk is not\n   *  kept here: read `getView`. */\n  viewRef: MutableRefObject<View>;\n  /** This render's controlled view, absent when the camera is uncontrolled or\n   *  derived. A new object every render, so compare its numbers. */\n  controlled: View | undefined;\n  /** The imperative write. Controlled, it is forwarded to `onViewChange`\n   *  instead of applied, and says so once per mount. */\n  setView: (next: View | ((current: View) => View)) => void;\n  /** The write input makes. Controlled, forwarding it to `onViewChange` is how\n   *  the owner hears of a pan at all, so nothing is warned. */\n  setViewFromInput: (next: View) => void;\n  getView: () => View;\n  subscribeView: (fn: (v: View) => void) => () => void;\n  /** Take this render's controlled view into `viewRef`. Call from an insertion effect. */\n  adoptControlled: () => void;\n  /** Tell subscribers of a controlled view that moved since the last call.\n   *  A controlled view reaches the ref with no write, so this is where they\n   *  hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nconst IDENTITY: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const derived = typeof viewProp === 'function' ? viewProp : undefined;\n  const controlledView = viewProp === undefined || derived ? undefined : normalizeView(viewProp as View);\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(controlledView ?? normalizeView(defaultView ?? IDENTITY));\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const live = useLatest({\n    controlled: viewProp !== undefined, derived, onViewChange, viewBounds, dims, requestRedraw,\n  });\n  const controlledWarnedRef = useRef(false);\n\n  const getView = useCallback((): View => {\n    const thunk = live.current.derived;\n    return thunk ? normalizeView(thunk()) : viewRef.current;\n  }, [live]);\n\n  const write = useCallback((next: View, imperative: boolean): void => {\n    const {\n      controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw,\n    } = live.current;\n    const valid = normalizeView(next);\n    const clamped = bounds ? clampView(valid, bounds, size()) : valid;\n    if (controlled) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      if (imperative && !controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      // A derived camera has no prop to change, so nothing else repaints it.\n      if (derived) redraw();\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    forward?.(clamped);\n    redraw();\n  }, [live]);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    write(typeof next === 'function' ? next(getView()) : next, true);\n  }, [write, getView]);\n  const setViewFromInput = useCallback((next: View) => { write(next, false); }, [write]);\n\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  const controlledMovedRef = useRef(false);\n  // A closure over this render's prop, not a ref read: the owner calls it\n  // from the same render's insertion effect.\n  const adoptControlled = (): void => {\n    if (!controlledView) return;\n    controlledMovedRef.current ||= !sameView(viewRef.current, controlledView);\n    viewRef.current = controlledView;\n  };\n  const announceControlled = useCallback(() => {\n    if (!controlledMovedRef.current) return;\n    controlledMovedRef.current = false;\n    for (const fn of viewSubsRef.current) fn(viewRef.current);\n  }, []);\n  const clearSubscribers = useCallback(() => { viewSubsRef.current.clear(); }, []);\n\n  return {\n    viewRef, controlled: controlledView, setView, setViewFromInput, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AA0EA,IAAM,WAAiB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAE3D,SAAgB,cAAc,MAA0C;CACtE,MAAM,EAAE,MAAM,UAAU,aAAa,cAAc,YAAY,MAAM,kBAAkB;CACvF,MAAM,UAAU,OAAO,aAAa,aAAa,WAAW;CAC5D,MAAM,iBAAiB,aAAa,UAAa,UAAU,SAAY,cAAc,QAAgB;CAGrG,MAAM,UAAU,OAAa,kBAAkB,cAAc,eAAe,QAAQ,CAAC;CACrF,MAAM,cAAc,uBAA+B,IAAI,IAAI,CAAC;CAC5D,MAAM,OAAO,UAAU;EACrB,YAAY,aAAa;EAAW;EAAS;EAAc;EAAY;EAAM;CAC/E,CAAC;CACD,MAAM,sBAAsB,OAAO,KAAK;CAExC,MAAM,UAAU,kBAAwB;EACtC,MAAM,QAAQ,KAAK,QAAQ;EAC3B,OAAO,QAAQ,cAAc,MAAM,CAAC,IAAI,QAAQ;CAClD,GAAG,CAAC,IAAI,CAAC;CAET,MAAM,QAAQ,aAAa,MAAY,eAA8B;EACnE,MAAM,EACJ,YAAY,SAAS,cAAc,SAAS,YAAY,QAAQ,MAAM,MAAM,eAAe,WACzF,KAAK;EACT,MAAM,QAAQ,cAAc,IAAI;EAChC,MAAM,UAAU,SAAS,UAAU,OAAO,QAAQ,KAAK,CAAC,IAAI;EAC5D,IAAI,YAAY;GAGd,IAAI,cAAc,CAAC,oBAAoB,SAAS;IAC9C,oBAAoB,UAAU;IAC9B,QAAQ,KAAK,UACT,wMACA,4LAA4L;GAClM;GACA,UAAU,OAAO;GAEjB,IAAI,SAAS,OAAO;GACpB;EACF;EACA,QAAQ,UAAU;EAClB,KAAK,MAAM,MAAM,YAAY,SAAS,GAAG,OAAO;EAChD,UAAU,OAAO;EACjB,OAAO;CACT,GAAG,CAAC,IAAI,CAAC;CAET,MAAM,UAAU,aAAa,SAA2C;EACtE,MAAM,OAAO,SAAS,aAAa,KAAK,QAAQ,CAAC,IAAI,MAAM,IAAI;CACjE,GAAG,CAAC,OAAO,OAAO,CAAC;CACnB,MAAM,mBAAmB,aAAa,SAAe;EAAE,MAAM,MAAM,KAAK;CAAG,GAAG,CAAC,KAAK,CAAC;CAErF,MAAM,gBAAgB,aAAa,OAA0B;EAC3D,YAAY,QAAQ,IAAI,EAAE;EAC1B,aAAa;GAAE,YAAY,QAAQ,OAAO,EAAE;EAAG;CACjD,GAAG,CAAC,CAAC;CAEL,MAAM,qBAAqB,OAAO,KAAK;CAGvC,MAAM,wBAA8B;EAClC,IAAI,CAAC,gBAAgB;EACrB,mBAAmB,YAAY,CAAC,SAAS,QAAQ,SAAS,cAAc;EACxE,QAAQ,UAAU;CACpB;CAQA,OAAO;EACL;EAAS,YAAY;EAAgB;EAAS;EAAkB;EAAS;EACzE;EAAiB,oBATQ,kBAAkB;GAC3C,IAAI,CAAC,mBAAmB,SAAS;GACjC,mBAAmB,UAAU;GAC7B,KAAK,MAAM,MAAM,YAAY,SAAS,GAAG,QAAQ,OAAO;EAC1D,GAAG,CAAC,CAKe;EAAoB,kBAJd,kBAAkB;GAAE,YAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}

package/dist/canvas/useClientToWorld.js

@@ -0,0 +1,27 @@
+import { clientToWorld } from "../core/viewport/clientToWorld.js";
+import { useCallback } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useClientToWorld.ts
+/**
+* The canvas's one client→world conversion: hover, the view registry and both handles answer
+* with it, so a `clientToWorld` override reaches all of them or none.
+*/
+function useClientToWorld(elementRef, clientToWorld$1, viewRef) {
+	const clientToWorldRef = useLatest(clientToWorld$1);
+	return useCallback((clientX, clientY) => {
+		const el = elementRef.current;
+		if (!el) return [clientX, clientY];
+		const override = clientToWorldRef.current;
+		if (override) return override(el, clientX, clientY);
+		return clientToWorld(clientX, clientY, el.getBoundingClientRect(), viewRef.current);
+	}, [
+		elementRef,
+		clientToWorldRef,
+		viewRef
+	]);
+}
+
+//#endregion
+export { useClientToWorld };
+//# sourceMappingURL=useClientToWorld.js.map

package/dist/canvas/useClientToWorld.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useClientToWorld.js","names":["clientToWorld","clientToWorldHelper"],"sources":["../../src/canvas/useClientToWorld.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld as clientToWorldHelper } from 'core/viewport/clientToWorld';\nimport type { CanvasProps } from './canvasProps';\n\n/**\n * The canvas's one client→world conversion: hover, the view registry and both handles answer\n * with it, so a `clientToWorld` override reaches all of them or none.\n */\nexport function useClientToWorld(\n  elementRef: { readonly current: HTMLElement | null },\n  clientToWorld: CanvasProps<unknown>['clientToWorld'],\n  viewRef: { readonly current: View },\n): (clientX: number, clientY: number) => [number, number] {\n  const clientToWorldRef = useLatest(clientToWorld);\n  return useCallback((clientX: number, clientY: number): [number, number] => {\n    const el = elementRef.current;\n    if (!el) return [clientX, clientY];\n    const override = clientToWorldRef.current;\n    if (override) return override(el, clientX, clientY);\n    return clientToWorldHelper(clientX, clientY, el.getBoundingClientRect(), viewRef.current);\n  }, [elementRef, clientToWorldRef, viewRef]);\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,iBACd,YACA,iBACA,SACwD;CACxD,MAAM,mBAAmB,UAAUA,eAAa;CAChD,OAAO,aAAa,SAAiB,YAAsC;EACzE,MAAM,KAAK,WAAW;EACtB,IAAI,CAAC,IAAI,OAAO,CAAC,SAAS,OAAO;EACjC,MAAM,WAAW,iBAAiB;EAClC,IAAI,UAAU,OAAO,SAAS,IAAI,SAAS,OAAO;EAClD,OAAOC,cAAoB,SAAS,SAAS,GAAG,sBAAsB,GAAG,QAAQ,OAAO;CAC1F,GAAG;EAAC;EAAY;EAAkB;CAAO,CAAC;AAC5C"}

package/dist/canvas/useExtraLayers.js

@@ -0,0 +1,45 @@
+import { isLayerPainted } from "../core/layers/render.js";
+import { useCallback, useRef, useState } from "react";
+
+//#region src/canvas/useExtraLayers.ts
+var alwaysVisible = (_id) => true;
+var NO_LAYER_VISIBILITY = {};
+/** Layers attached from outside the `layers` prop (a HUD, a loupe), and hit-testing over them. */
+function useExtraLayers(gateRef) {
+	const [extrasVersion, setExtrasVersion] = useState(0);
+	const extrasRef = useRef(/* @__PURE__ */ new Set());
+	return {
+		extrasRef,
+		extrasVersion,
+		registerLayer: useCallback((layer) => {
+			extrasRef.current.add(layer);
+			setExtrasVersion((n) => n + 1);
+			return () => {
+				extrasRef.current.delete(layer);
+				setExtrasVersion((n) => n + 1);
+			};
+		}, []),
+		hitTestExtrasIn: useCallback((worldX, worldY, view, dims, data, only) => {
+			const layers = [...extrasRef.current].reverse();
+			const gate = gateRef.current;
+			const isVisible = gate.getIsVisible?.() ?? alwaysVisible;
+			const visibility = gate.layerVisibility ?? NO_LAYER_VISIBILITY;
+			const order = gate.layerOrder;
+			for (const layer of layers) {
+				if (!layer.hitTest) continue;
+				if (only && !only.includes(layer)) continue;
+				if (!isLayerPainted(layer, visibility, order)) continue;
+				const hit = layer.hitTest(worldX, worldY, data, view, dims, isVisible);
+				if (hit) return {
+					layerId: layer.id,
+					hit
+				};
+			}
+			return null;
+		}, [gateRef])
+	};
+}
+
+//#endregion
+export { NO_LAYER_VISIBILITY, alwaysVisible, useExtraLayers };
+//# sourceMappingURL=useExtraLayers.js.map

package/dist/canvas/useExtraLayers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtraLayers.js","names":[],"sources":["../../src/canvas/useExtraLayers.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\nimport { isLayerPainted, type RenderLayer } from 'core/layers/render';\nimport type { CanvasProps } from './canvasProps';\nimport type { SurfaceHandle } from './viewRegistry';\n\n/** Which layers reach the screen, and which chrome within them. */\nexport type LayerGate = Pick<CanvasProps<unknown>, 'getIsVisible' | 'layerVisibility' | 'layerOrder'>;\n\nexport const alwaysVisible = (_id: string): boolean => true;\nexport const NO_LAYER_VISIBILITY: Record<string, boolean> = {};\n\n/** Hit-test registered layers against a given frame, topmost first. */\nexport type HitTestExtrasIn = SurfaceHandle['hitTestExtras'];\n\nexport interface ExtraLayers {\n  /** Registered layers, in registration order. */\n  extrasRef: { readonly current: ReadonlySet<RenderLayer<unknown>> };\n  /** Bumped on every registration and removal, so a memo reading `extrasRef` re-runs. */\n  extrasVersion: number;\n  registerLayer(layer: RenderLayer<unknown>): () => void;\n  hitTestExtrasIn: HitTestExtrasIn;\n}\n\n/** Layers attached from outside the `layers` prop (a HUD, a loupe), and hit-testing over them. */\nexport function useExtraLayers(gateRef: { readonly current: LayerGate }): ExtraLayers {\n  const [extrasVersion, setExtrasVersion] = useState(0);\n  const extrasRef = useRef<Set<RenderLayer<unknown>>>(new Set());\n  const registerLayer = useCallback((layer: RenderLayer<unknown>) => {\n    extrasRef.current.add(layer);\n    setExtrasVersion(n => n + 1);\n    return () => {\n      extrasRef.current.delete(layer);\n      setExtrasVersion(n => n + 1);\n    };\n  }, []);\n\n  // Registration order is draw order, so the last-registered layer gets first\n  // refusal. `<SceneCanvas>` folds this into its `affordanceAt` thunk; Canvas\n  // has the layers but not the dispatcher.\n  const hitTestExtrasIn = useCallback<HitTestExtrasIn>((worldX, worldY, view, dims, data, only) => {\n    const layers = [...extrasRef.current].reverse();\n    const gate = gateRef.current;\n    const isVisible = gate.getIsVisible?.() ?? alwaysVisible;\n    const visibility = gate.layerVisibility ?? NO_LAYER_VISIBILITY;\n    const order = gate.layerOrder;\n    for (const layer of layers) {\n      if (!layer.hitTest) continue;\n      if (only && !only.includes(layer)) continue;\n      if (!isLayerPainted(layer, visibility, order)) continue;\n      const hit = layer.hitTest(worldX, worldY, data, view, dims, isVisible);\n      if (hit) return { layerId: layer.id, hit };\n    }\n    return null;\n  }, [gateRef]);\n\n  return { extrasRef, extrasVersion, registerLayer, hitTestExtrasIn };\n}\n"],"mappings":";;;;AAQA,IAAa,iBAAiB,QAAyB;AACvD,IAAa,sBAA+C,CAAC;;AAe7D,SAAgB,eAAe,SAAuD;CACpF,MAAM,CAAC,eAAe,oBAAoB,SAAS,CAAC;CACpD,MAAM,YAAY,uBAAkC,IAAI,IAAI,CAAC;CA6B7D,OAAO;EAAE;EAAW;EAAe,eA5Bb,aAAa,UAAgC;GACjE,UAAU,QAAQ,IAAI,KAAK;GAC3B,kBAAiB,MAAK,IAAI,CAAC;GAC3B,aAAa;IACX,UAAU,QAAQ,OAAO,KAAK;IAC9B,kBAAiB,MAAK,IAAI,CAAC;GAC7B;EACF,GAAG,CAAC,CAqB+B;EAAe,iBAhB1B,aAA8B,QAAQ,QAAQ,MAAM,MAAM,MAAM,SAAS;GAC/F,MAAM,SAAS,CAAC,GAAG,UAAU,OAAO,CAAC,CAAC,QAAQ;GAC9C,MAAM,OAAO,QAAQ;GACrB,MAAM,YAAY,KAAK,eAAe,KAAK;GAC3C,MAAM,aAAa,KAAK,mBAAmB;GAC3C,MAAM,QAAQ,KAAK;GACnB,KAAK,MAAM,SAAS,QAAQ;IAC1B,IAAI,CAAC,MAAM,SAAS;IACpB,IAAI,QAAQ,CAAC,KAAK,SAAS,KAAK,GAAG;IACnC,IAAI,CAAC,eAAe,OAAO,YAAY,KAAK,GAAG;IAC/C,MAAM,MAAM,MAAM,QAAQ,QAAQ,QAAQ,MAAM,MAAM,MAAM,SAAS;IACrE,IAAI,KAAK,OAAO;KAAE,SAAS,MAAM;KAAI;IAAI;GAC3C;GACA,OAAO;EACT,GAAG,CAAC,OAAO,CAEuC;CAAgB;AACpE"}

package/dist/canvas/useFrameLoop.js

@@ -1,68 +1,128 @@
-import { useCallback as e, useInsertionEffect as t, useLayoutEffect as n, useRef as r } from "react";
-import { useLatest as i, useVisibleRaf as a } from "@weasel-js/react";
+import { useCallback, useInsertionEffect, useLayoutEffect, useRef } from "react";
+import { useLatest, useVisibleRaf } from "@weasel-js/react";
+
 //#region src/canvas/useFrameLoop.ts
-function o(o, s = {}) {
-	let c = r(!0), l = r(!0), u = r(!1), d = i(o), f = i(s.syncPaint ?? !1), p = r(/* @__PURE__ */ new Set()), m = r(/* @__PURE__ */ new Set()), h = r(/* @__PURE__ */ new Set()), g = r(-Infinity), _ = r(!1), v = r(null), y = e((e) => {
-		let t = Math.max(e, g.current);
-		g.current = t, c.current = !1, u.current = !0;
-		let n = !1;
+/**
+* The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a
+* time, and a subscriber set notified after a paint lands. When frames may run
+* at all is `useVisibleRaf`'s question, not this hook's — a redraw requested
+* while nothing can see the surface is held there and re-armed on resume.
+*
+* @internal Not consumer surface. Canvas exposes `requestRedraw` and
+*   `subscribeFrame` on its ref handle; this is how they are implemented.
+*/
+/**
+* @param paint Runs on the frame; returns whether pixels landed. A `false`
+*   leaves the surface dirty and notifies nobody, so the next request retries.
+*/
+function useFrameLoop(paint, options = {}) {
+	const dirtyRef = useRef(true);
+	const aliveRef = useRef(true);
+	const paintingRef = useRef(false);
+	const paintRef = useLatest(paint);
+	const syncRef = useLatest(options.syncPaint ?? false);
+	const subsRef = useRef(/* @__PURE__ */ new Set());
+	const beforeRef = useRef(/* @__PURE__ */ new Set());
+	const resumeRef = useRef(/* @__PURE__ */ new Set());
+	/** The last time handed to subscribers. A sync paint reads the clock at the
+	*  call and a rAF frame carries its frame's start, so within one animation
+	*  frame the second can be the earlier of the two. */
+	const lastTimeRef = useRef(-Infinity);
+	/** Set while recovering from a paint that threw, so one bad frame is retried
+	*  and a permanently throwing one still doesn't spin at frame rate. */
+	const retriedRef = useRef(false);
+	/** `frame.request`, which doesn't exist until after `runPaint` is built. */
+	const rearmRef = useRef(null);
+	const runPaint = useCallback((at) => {
+		const time = Math.max(at, lastTimeRef.current);
+		lastTimeRef.current = time;
+		dirtyRef.current = false;
+		paintingRef.current = true;
+		let landed = false;
 		try {
-			for (let e of m.current) e(t);
-			if (n = d.current(), !n) {
-				c.current = !0;
+			for (const fn of beforeRef.current) fn(time);
+			landed = paintRef.current();
+			if (!landed) {
+				dirtyRef.current = true;
 				return;
 			}
-			_.current = !1;
-			for (let e of p.current) e(t);
-		} catch (e) {
-			throw c.current = !0, _.current || (_.current = !0, v.current?.()), e;
+			retriedRef.current = false;
+			for (const fn of subsRef.current) fn(time);
+		} catch (err) {
+			dirtyRef.current = true;
+			if (!retriedRef.current) {
+				retriedRef.current = true;
+				rearmRef.current?.();
+			}
+			throw err;
 		} finally {
-			u.current = !1;
+			paintingRef.current = false;
 		}
-	}, [d]), b = a(e((e) => {
-		l.current && c.current && y(e);
-	}, [y]), {
-		target: s.target,
-		onResume: e(() => {
-			for (let e of h.current) e();
+	}, [paintRef]);
+	const frame = useVisibleRaf(useCallback((time) => {
+		if (!aliveRef.current || !dirtyRef.current) return;
+		runPaint(time);
+	}, [runPaint]), {
+		target: options.target,
+		onResume: useCallback(() => {
+			for (const fn of resumeRef.current) fn();
 		}, [])
 	});
-	t(() => {
-		v.current = () => {
-			b.request();
+	useInsertionEffect(() => {
+		rearmRef.current = () => {
+			frame.request();
 		};
 	});
-	let x = e(() => {
-		if (c.current = !0, f.current && l.current && !u.current && b.isVisible()) {
-			y(performance.now());
+	const requestRedraw = useCallback(() => {
+		dirtyRef.current = true;
+		if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {
+			runPaint(performance.now());
 			return;
 		}
-		b.request();
+		frame.request();
 	}, [
-		b,
-		y,
-		f
-	]), S = e((e) => (p.current.add(e), () => {
-		p.current.delete(e);
-	}), []), C = e((e) => (m.current.add(e), () => {
-		m.current.delete(e);
-	}), []), w = e((e) => (h.current.add(e), () => {
-		h.current.delete(e);
-	}), []);
-	return n(() => {
-		l.current = !0;
-		let e = p.current, t = m.current, n = h.current;
+		frame,
+		runPaint,
+		syncRef
+	]);
+	const subscribeFrame = useCallback((fn) => {
+		subsRef.current.add(fn);
+		return () => {
+			subsRef.current.delete(fn);
+		};
+	}, []);
+	const subscribeBeforePaint = useCallback((fn) => {
+		beforeRef.current.add(fn);
+		return () => {
+			beforeRef.current.delete(fn);
+		};
+	}, []);
+	const subscribeResume = useCallback((fn) => {
+		resumeRef.current.add(fn);
+		return () => {
+			resumeRef.current.delete(fn);
+		};
+	}, []);
+	useLayoutEffect(() => {
+		aliveRef.current = true;
+		const subs = subsRef.current;
+		const before = beforeRef.current;
+		const resume = resumeRef.current;
 		return () => {
-			l.current = !1, e.clear(), t.clear(), n.clear();
+			aliveRef.current = false;
+			subs.clear();
+			before.clear();
+			resume.clear();
 		};
-	}, []), {
-		requestRedraw: x,
-		subscribeFrame: S,
-		subscribeBeforePaint: C,
-		subscribeResume: w
+	}, []);
+	return {
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume
 	};
 }
-//#endregion
-export { o as useFrameLoop };
 
+//#endregion
+export { useFrameLoop };
 //# sourceMappingURL=useFrameLoop.js.map

package/dist/canvas/useFrameLoop.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFrameLoop.js","names":["useFrameLoop","dirtyRef","useRef","aliveRef","paintingRef","paintRef","useLatest","paint","syncRef","options","subsRef","beforeRef","resumeRef","lastTimeRef","retriedRef","rearmRef","runPaint","useCallback","time","at","landed","fn","err","frame","useVisibleRaf","requestRedraw","subscribeFrame","subscribeBeforePaint","subscribeResume","useLayoutEffect","subs","before","resume"],"sources":["../../src/canvas/useFrameLoop.ts"],"sourcesContent":["/**\n * The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a\n * time, and a subscriber set notified after a paint lands. When frames may run\n * at all is `useVisibleRaf`'s question, not this hook's — a redraw requested\n * while nothing can see the surface is held there and re-armed on resume.\n *\n * @internal Not consumer surface. Canvas exposes `requestRedraw` and\n *   `subscribeFrame` on its ref handle; this is how they are implemented.\n */\n\nimport { useCallback, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport { useLatest, useVisibleRaf, type VisibleRafTarget } from '@weasel-js/react';\n\nexport interface FrameLoop {\n  /** Mark the surface dirty and schedule a frame. Identity is stable for the\n   *  lifetime of the component — consumers capture it. */\n  requestRedraw(): void;\n  /** Run `fn` after every landed paint, with the frame's time. Returns an\n   *  unsubscribe. */\n  subscribeFrame(fn: (time: number) => void): () => void;\n  /** Run `fn` on every frame just before its paint, with the frame's time.\n   *  Returns an unsubscribe. */\n  subscribeBeforePaint(fn: (time: number) => void): () => void;\n  /** Run `fn` when the loop leaves suspension, before the frame that follows.\n   *  Returns an unsubscribe. */\n  subscribeResume(fn: () => void): () => void;\n}\n\nexport interface FrameLoopOptions {\n  /** Paint in the caller's own stack — the commit or event that asked for the\n   *  redraw — instead of on the next animation frame. Read live, so toggling\n   *  it takes effect from the next `requestRedraw` on. */\n  syncPaint?: boolean;\n  /** The surface being painted. Given one, the loop also stops while that\n   *  element sits outside the viewport, not only while the tab is hidden. */\n  target?: VisibleRafTarget;\n}\n\n/**\n * @param paint Runs on the frame; returns whether pixels landed. A `false`\n *   leaves the surface dirty and notifies nobody, so the next request retries.\n */\nexport function useFrameLoop(paint: () => boolean, options: FrameLoopOptions = {}): FrameLoop {\n  const dirtyRef = useRef(true);\n  const aliveRef = useRef(true);\n  const paintingRef = useRef(false);\n  const paintRef = useLatest(paint);\n  const syncRef = useLatest(options.syncPaint ?? false);\n  const subsRef = useRef<Set<(time: number) => void>>(new Set());\n  const beforeRef = useRef<Set<(time: number) => void>>(new Set());\n  const resumeRef = useRef<Set<() => void>>(new Set());\n  /** The last time handed to subscribers. A sync paint reads the clock at the\n   *  call and a rAF frame carries its frame's start, so within one animation\n   *  frame the second can be the earlier of the two. */\n  const lastTimeRef = useRef(-Infinity);\n\n  /** Set while recovering from a paint that threw, so one bad frame is retried\n   *  and a permanently throwing one still doesn't spin at frame rate. */\n  const retriedRef = useRef(false);\n  /** `frame.request`, which doesn't exist until after `runPaint` is built. */\n  const rearmRef = useRef<(() => void) | null>(null);\n\n  const runPaint = useCallback((at: number) => {\n    const time = Math.max(at, lastTimeRef.current);\n    lastTimeRef.current = time;\n    dirtyRef.current = false;\n    paintingRef.current = true;\n    let landed = false;\n    try {\n      for (const fn of beforeRef.current) fn(time);\n      landed = paintRef.current();\n      if (!landed) {\n        dirtyRef.current = true;\n        return;\n      }\n      retriedRef.current = false;\n      // Notified inside the guard: a subscriber calling `requestRedraw` under\n      // `syncPaint` would otherwise re-enter this synchronously, without bound.\n      for (const fn of subsRef.current) fn(time);\n    } catch (err) {\n      // A throw skips the `!landed` branch above, so without this the surface\n      // is left clean but unpainted — the pixels on screen are whatever the\n      // last landed frame left, and nothing repaints until something\n      // unrelated happens to request a redraw. That is how a single\n      // malformed node blanked a whole document until the pointer moved.\n      dirtyRef.current = true;\n      if (!retriedRef.current) {\n        retriedRef.current = true;\n        rearmRef.current?.();\n      }\n      throw err;\n    } finally {\n      paintingRef.current = false;\n    }\n  }, [paintRef]);\n\n  const frame = useVisibleRaf(\n    useCallback((time: number) => {\n      if (!aliveRef.current || !dirtyRef.current) return;\n      runPaint(time);\n    }, [runPaint]),\n    {\n      target: options.target,\n      onResume: useCallback(() => { for (const fn of resumeRef.current) fn(); }, []),\n    },\n  );\n  useInsertionEffect(() => {\n    rearmRef.current = () => { frame.request(); };\n  });\n\n  const requestRedraw = useCallback(() => {\n    dirtyRef.current = true;\n    // The gate suppresses the sync path too: a background tab still commits\n    // React updates, and that is the one paint browser throttling does not stop.\n    // A request made from inside a draw or a frame subscriber would recurse\n    // forever if it painted here, so re-entrant ones fall through to a frame.\n    if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {\n      runPaint(performance.now());\n      return;\n    }\n    frame.request();\n  }, [frame, runPaint, syncRef]);\n\n  const subscribeFrame = useCallback((fn: (time: number) => void) => {\n    subsRef.current.add(fn);\n    return () => { subsRef.current.delete(fn); };\n  }, []);\n  const subscribeBeforePaint = useCallback((fn: (time: number) => void) => {\n    beforeRef.current.add(fn);\n    return () => { beforeRef.current.delete(fn); };\n  }, []);\n\n  const subscribeResume = useCallback((fn: () => void) => {\n    resumeRef.current.add(fn);\n    return () => { resumeRef.current.delete(fn); };\n  }, []);\n\n  // `requestRedraw` outlives the component: `@weasel-js/hud` calls it from a\n  // `.then()`, and `viewRegistry.attachSurface` hands it to the consumer.\n  // Re-armed in setup because refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes Canvas's own layout effects — the\n  // sync-paint path runs in one of those.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    const subs = subsRef.current;\n    const before = beforeRef.current;\n    const resume = resumeRef.current;\n    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n      resume.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume };\n}\n"],"mappings":";;;AA0CA,SAAgBA,EAAa,GAAsB,IAA4B,CAAC,GAAc;CAC5F,IAAMC,IAAWC,EAAO,EAAI,GACtBC,IAAWD,EAAO,EAAI,GACtBE,IAAcF,EAAO,EAAK,GAC1BG,IAAWC,EAAUC,CAAK,GAC1BC,IAAUF,EAAUG,EAAQ,aAAa,EAAK,GAC9CC,IAAUR,kBAAoC,IAAI,IAAI,CAAC,GACvDS,IAAYT,kBAAoC,IAAI,IAAI,CAAC,GACzDU,IAAYV,kBAAwB,IAAI,IAAI,CAAC,GAI7CW,IAAcX,EAAO,SAAS,GAI9BY,IAAaZ,EAAO,EAAK,GAEzBa,IAAWb,EAA4B,IAAI,GAE3Cc,IAAWC,GAAa,MAAe;EAC3C,IAAMC,IAAO,KAAK,IAAIC,GAAIN,EAAY,OAAO;EAG7C,AAFA,EAAY,UAAUK,GACtB,EAAS,UAAU,IACnB,EAAY,UAAU;EACtB,IAAIE,IAAS;EACb,IAAI;GACF,KAAK,IAAMC,KAAMV,EAAU,SAAS,EAAGO,CAAI;GAE3C,IADA,IAASb,EAAS,QAAQ,GACtB,CAACe,GAAQ;IACX,EAAS,UAAU;IACnB;GACF;GACA,EAAW,UAAU;GAGrB,KAAK,IAAMC,KAAMX,EAAQ,SAAS,EAAGQ,CAAI;EAC3C,SAASI,GAAK;GAWZ,MALA,EAAS,UAAU,IACdR,EAAW,YACd,EAAW,UAAU,IACrBC,EAAS,UAAU,IAEfO;EACR,UAAU;GACR,EAAY,UAAU;EACxB;CACF,GAAG,CAACjB,CAAQ,CAAC,GAEPkB,IAAQC,EACZP,GAAa,MAAiB;EAC5B,AAAKd,EAAS,WAAYF,EAAS,WACnCe,EAASE,CAAI;CACf,GAAG,CAACF,CAAQ,CAAC,GACb;EACE,QAAQP,EAAQ;EAChB,UAAUQ,QAAkB;GAAE,KAAK,IAAMI,KAAMT,EAAU,SAAS,EAAG;EAAG,GAAG,CAAC,CAAC;CAC/E,CACF;CACA,QAAyB;EACvB,EAAS,gBAAgB;GAAE,EAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,IAAMa,IAAgBR,QAAkB;EAMtC,IALA,EAAS,UAAU,IAKfT,EAAQ,WAAWL,EAAS,WAAW,CAACC,EAAY,WAAWmB,EAAM,UAAU,GAAG;GACpF,EAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,EAAM,QAAQ;CAChB,GAAG;EAACA;EAAOP;EAAUR;CAAO,CAAC,GAEvBkB,IAAiBT,GAAa,OAClCP,EAAQ,QAAQ,IAAIW,CAAE,SACT;EAAE,EAAQ,QAAQ,OAAOA,CAAE;CAAG,IAC1C,CAAC,CAAC,GACCM,IAAuBV,GAAa,OACxCN,EAAU,QAAQ,IAAIU,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC,GAECO,IAAkBX,GAAa,OACnCL,EAAU,QAAQ,IAAIS,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC;CAoBL,OAbAQ,QAAsB;EACpB,EAAS,UAAU;EACnB,IAAMC,IAAOpB,EAAQ,SACfqB,IAASpB,EAAU,SACnBqB,IAASpB,EAAU;EACzB,aAAa;GAIX,AAHA,EAAS,UAAU,IACnBkB,EAAK,MAAM,GACXC,EAAO,MAAM,GACbC,EAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC,GAEE;EAAE;EAAe;EAAgB;EAAsB;CAAgB;AAChF"}
+{"version":3,"file":"useFrameLoop.js","names":[],"sources":["../../src/canvas/useFrameLoop.ts"],"sourcesContent":["/**\n * The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a\n * time, and a subscriber set notified after a paint lands. When frames may run\n * at all is `useVisibleRaf`'s question, not this hook's — a redraw requested\n * while nothing can see the surface is held there and re-armed on resume.\n *\n * @internal Not consumer surface. Canvas exposes `requestRedraw` and\n *   `subscribeFrame` on its ref handle; this is how they are implemented.\n */\n\nimport { useCallback, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport { useLatest, useVisibleRaf, type VisibleRafTarget } from '@weasel-js/react';\n\nexport interface FrameLoop {\n  /** Mark the surface dirty and schedule a frame. Identity is stable for the\n   *  lifetime of the component — consumers capture it. */\n  requestRedraw(): void;\n  /** Run `fn` after every landed paint, with the frame's time. Returns an\n   *  unsubscribe. */\n  subscribeFrame(fn: (time: number) => void): () => void;\n  /** Run `fn` on every frame just before its paint, with the frame's time.\n   *  Returns an unsubscribe. */\n  subscribeBeforePaint(fn: (time: number) => void): () => void;\n  /** Run `fn` when the loop leaves suspension, before the frame that follows.\n   *  Returns an unsubscribe. */\n  subscribeResume(fn: () => void): () => void;\n}\n\nexport interface FrameLoopOptions {\n  /** Paint in the caller's own stack — the commit or event that asked for the\n   *  redraw — instead of on the next animation frame. Read live, so toggling\n   *  it takes effect from the next `requestRedraw` on. */\n  syncPaint?: boolean;\n  /** The surface being painted. Given one, the loop also stops while that\n   *  element sits outside the viewport, not only while the tab is hidden. */\n  target?: VisibleRafTarget;\n}\n\n/**\n * @param paint Runs on the frame; returns whether pixels landed. A `false`\n *   leaves the surface dirty and notifies nobody, so the next request retries.\n */\nexport function useFrameLoop(paint: () => boolean, options: FrameLoopOptions = {}): FrameLoop {\n  const dirtyRef = useRef(true);\n  const aliveRef = useRef(true);\n  const paintingRef = useRef(false);\n  const paintRef = useLatest(paint);\n  const syncRef = useLatest(options.syncPaint ?? false);\n  const subsRef = useRef<Set<(time: number) => void>>(new Set());\n  const beforeRef = useRef<Set<(time: number) => void>>(new Set());\n  const resumeRef = useRef<Set<() => void>>(new Set());\n  /** The last time handed to subscribers. A sync paint reads the clock at the\n   *  call and a rAF frame carries its frame's start, so within one animation\n   *  frame the second can be the earlier of the two. */\n  const lastTimeRef = useRef(-Infinity);\n\n  /** Set while recovering from a paint that threw, so one bad frame is retried\n   *  and a permanently throwing one still doesn't spin at frame rate. */\n  const retriedRef = useRef(false);\n  /** `frame.request`, which doesn't exist until after `runPaint` is built. */\n  const rearmRef = useRef<(() => void) | null>(null);\n\n  const runPaint = useCallback((at: number) => {\n    const time = Math.max(at, lastTimeRef.current);\n    lastTimeRef.current = time;\n    dirtyRef.current = false;\n    paintingRef.current = true;\n    let landed = false;\n    try {\n      for (const fn of beforeRef.current) fn(time);\n      landed = paintRef.current();\n      if (!landed) {\n        dirtyRef.current = true;\n        return;\n      }\n      retriedRef.current = false;\n      // Notified inside the guard: a subscriber calling `requestRedraw` under\n      // `syncPaint` would otherwise re-enter this synchronously, without bound.\n      for (const fn of subsRef.current) fn(time);\n    } catch (err) {\n      // A throw skips the `!landed` branch above, so without this the surface\n      // is left clean but unpainted — the pixels on screen are whatever the\n      // last landed frame left, and nothing repaints until something\n      // unrelated happens to request a redraw. That is how a single\n      // malformed node blanked a whole document until the pointer moved.\n      dirtyRef.current = true;\n      if (!retriedRef.current) {\n        retriedRef.current = true;\n        rearmRef.current?.();\n      }\n      throw err;\n    } finally {\n      paintingRef.current = false;\n    }\n  }, [paintRef]);\n\n  const frame = useVisibleRaf(\n    useCallback((time: number) => {\n      if (!aliveRef.current || !dirtyRef.current) return;\n      runPaint(time);\n    }, [runPaint]),\n    {\n      target: options.target,\n      onResume: useCallback(() => { for (const fn of resumeRef.current) fn(); }, []),\n    },\n  );\n  useInsertionEffect(() => {\n    rearmRef.current = () => { frame.request(); };\n  });\n\n  const requestRedraw = useCallback(() => {\n    dirtyRef.current = true;\n    // The gate suppresses the sync path too: a background tab still commits\n    // React updates, and that is the one paint browser throttling does not stop.\n    // A request made from inside a draw or a frame subscriber would recurse\n    // forever if it painted here, so re-entrant ones fall through to a frame.\n    if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {\n      runPaint(performance.now());\n      return;\n    }\n    frame.request();\n  }, [frame, runPaint, syncRef]);\n\n  const subscribeFrame = useCallback((fn: (time: number) => void) => {\n    subsRef.current.add(fn);\n    return () => { subsRef.current.delete(fn); };\n  }, []);\n  const subscribeBeforePaint = useCallback((fn: (time: number) => void) => {\n    beforeRef.current.add(fn);\n    return () => { beforeRef.current.delete(fn); };\n  }, []);\n\n  const subscribeResume = useCallback((fn: () => void) => {\n    resumeRef.current.add(fn);\n    return () => { resumeRef.current.delete(fn); };\n  }, []);\n\n  // `requestRedraw` outlives the component: `@weasel-js/hud` calls it from a\n  // `.then()`, and `viewRegistry.attachSurface` hands it to the consumer.\n  // Re-armed in setup because refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes Canvas's own layout effects — the\n  // sync-paint path runs in one of those.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    const subs = subsRef.current;\n    const before = beforeRef.current;\n    const resume = resumeRef.current;\n    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n      resume.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0CA,SAAgB,aAAa,OAAsB,UAA4B,CAAC,GAAc;CAC5F,MAAM,WAAW,OAAO,IAAI;CAC5B,MAAM,WAAW,OAAO,IAAI;CAC5B,MAAM,cAAc,OAAO,KAAK;CAChC,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,UAAU,UAAU,QAAQ,aAAa,KAAK;CACpD,MAAM,UAAU,uBAAoC,IAAI,IAAI,CAAC;CAC7D,MAAM,YAAY,uBAAoC,IAAI,IAAI,CAAC;CAC/D,MAAM,YAAY,uBAAwB,IAAI,IAAI,CAAC;;;;CAInD,MAAM,cAAc,OAAO,SAAS;;;CAIpC,MAAM,aAAa,OAAO,KAAK;;CAE/B,MAAM,WAAW,OAA4B,IAAI;CAEjD,MAAM,WAAW,aAAa,OAAe;EAC3C,MAAM,OAAO,KAAK,IAAI,IAAI,YAAY,OAAO;EAC7C,YAAY,UAAU;EACtB,SAAS,UAAU;EACnB,YAAY,UAAU;EACtB,IAAI,SAAS;EACb,IAAI;GACF,KAAK,MAAM,MAAM,UAAU,SAAS,GAAG,IAAI;GAC3C,SAAS,SAAS,QAAQ;GAC1B,IAAI,CAAC,QAAQ;IACX,SAAS,UAAU;IACnB;GACF;GACA,WAAW,UAAU;GAGrB,KAAK,MAAM,MAAM,QAAQ,SAAS,GAAG,IAAI;EAC3C,SAAS,KAAK;GAMZ,SAAS,UAAU;GACnB,IAAI,CAAC,WAAW,SAAS;IACvB,WAAW,UAAU;IACrB,SAAS,UAAU;GACrB;GACA,MAAM;EACR,UAAU;GACR,YAAY,UAAU;EACxB;CACF,GAAG,CAAC,QAAQ,CAAC;CAEb,MAAM,QAAQ,cACZ,aAAa,SAAiB;EAC5B,IAAI,CAAC,SAAS,WAAW,CAAC,SAAS,SAAS;EAC5C,SAAS,IAAI;CACf,GAAG,CAAC,QAAQ,CAAC,GACb;EACE,QAAQ,QAAQ;EAChB,UAAU,kBAAkB;GAAE,KAAK,MAAM,MAAM,UAAU,SAAS,GAAG;EAAG,GAAG,CAAC,CAAC;CAC/E,CACF;CACA,yBAAyB;EACvB,SAAS,gBAAgB;GAAE,MAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,MAAM,gBAAgB,kBAAkB;EACtC,SAAS,UAAU;EAKnB,IAAI,QAAQ,WAAW,SAAS,WAAW,CAAC,YAAY,WAAW,MAAM,UAAU,GAAG;GACpF,SAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,MAAM,QAAQ;CAChB,GAAG;EAAC;EAAO;EAAU;CAAO,CAAC;CAE7B,MAAM,iBAAiB,aAAa,OAA+B;EACjE,QAAQ,QAAQ,IAAI,EAAE;EACtB,aAAa;GAAE,QAAQ,QAAQ,OAAO,EAAE;EAAG;CAC7C,GAAG,CAAC,CAAC;CACL,MAAM,uBAAuB,aAAa,OAA+B;EACvE,UAAU,QAAQ,IAAI,EAAE;EACxB,aAAa;GAAE,UAAU,QAAQ,OAAO,EAAE;EAAG;CAC/C,GAAG,CAAC,CAAC;CAEL,MAAM,kBAAkB,aAAa,OAAmB;EACtD,UAAU,QAAQ,IAAI,EAAE;EACxB,aAAa;GAAE,UAAU,QAAQ,OAAO,EAAE;EAAG;CAC/C,GAAG,CAAC,CAAC;CAOL,sBAAsB;EACpB,SAAS,UAAU;EACnB,MAAM,OAAO,QAAQ;EACrB,MAAM,SAAS,UAAU;EACzB,MAAM,SAAS,UAAU;EACzB,aAAa;GACX,SAAS,UAAU;GACnB,KAAK,MAAM;GACX,OAAO,MAAM;GACb,OAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC;CAEL,OAAO;EAAE;EAAe;EAAgB;EAAsB;CAAgB;AAChF"}

package/dist/canvas/useHitObserver.js

@@ -1,23 +1,30 @@
-import { useMemo as e } from "react";
-import { useLatest as t } from "@weasel-js/react";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/useHitObserver.ts
-function n(n, r) {
-	let i = t(n), a = !!n;
-	return e(() => {
-		if (a) return (e) => {
-			let t = r.current?.(e.x, e.y);
-			i.current?.(t ? {
-				id: t.id,
-				kind: t.kind
+/** Turns a consumer's hit callback into the world-point observer the gesture
+*  dispatcher takes, resolving the hit with the canvas's own picker. Identity
+*  changes only between wired and not, so the dispatcher isn't rebuilt per
+*  render. */
+function useHitObserver(cb, pickerRef) {
+	const cbRef = useLatest(cb);
+	const wired = Boolean(cb);
+	return useMemo(() => {
+		if (!wired) return void 0;
+		return (world) => {
+			const result = pickerRef.current?.(world.x, world.y);
+			cbRef.current?.(result ? {
+				id: result.id,
+				kind: result.kind
 			} : null);
 		};
 	}, [
-		a,
-		i,
-		r
+		wired,
+		cbRef,
+		pickerRef
 	]);
 }
-//#endregion
-export { n as useHitObserver };
 
+//#endregion
+export { useHitObserver };
 //# sourceMappingURL=useHitObserver.js.map

package/dist/canvas/useHitObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHitObserver.js","names":["useHitObserver","cbRef","useLatest","cb","wired","useMemo","result","pickerRef","world"],"sources":["../../src/canvas/useHitObserver.ts"],"sourcesContent":["import { useMemo, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasHit } from './SceneCanvas';\n\ntype Picker = ((x: number, y: number) => { id: string; kind: string } | null | undefined) | undefined;\n\n/** Turns a consumer's hit callback into the world-point observer the gesture\n *  dispatcher takes, resolving the hit with the canvas's own picker. Identity\n *  changes only between wired and not, so the dispatcher isn't rebuilt per\n *  render. */\nexport function useHitObserver(\n  cb: ((hit: SceneCanvasHit | null) => void) | undefined,\n  pickerRef: MutableRefObject<Picker>,\n): ((world: { x: number; y: number }) => void) | undefined {\n  const cbRef = useLatest(cb);\n  const wired = Boolean(cb);\n  return useMemo(() => {\n    if (!wired) return undefined;\n    return (world) => {\n      const result = pickerRef.current?.(world.x, world.y);\n      cbRef.current?.(result ? { id: result.id, kind: result.kind } : null);\n    };\n  }, [wired, cbRef, pickerRef]);\n}\n"],"mappings":";;;AAUA,SAAgBA,EACd,GACA,GACyD;CACzD,IAAMC,IAAQC,EAAUC,CAAE,GACpBC,IAAQ,EAAQD;CACtB,OAAOE,QAAc;EACnB,IAAKD,GACL,QAAQ,MAAU;GAChB,IAAME,IAASC,EAAU,UAAUC,EAAM,GAAGA,EAAM,CAAC;GACnD,EAAM,UAAUF,IAAS;IAAE,IAAIA,EAAO;IAAI,MAAMA,EAAO;GAAK,IAAI,IAAI;EACtE;CACF,GAAG;EAACF;EAAOH;EAAOM;CAAS,CAAC;AAC9B"}
+{"version":3,"file":"useHitObserver.js","names":[],"sources":["../../src/canvas/useHitObserver.ts"],"sourcesContent":["import { useMemo, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SceneCanvasHit } from './SceneCanvas';\n\ntype Picker = ((x: number, y: number) => { id: string; kind: string } | null | undefined) | undefined;\n\n/** Turns a consumer's hit callback into the world-point observer the gesture\n *  dispatcher takes, resolving the hit with the canvas's own picker. Identity\n *  changes only between wired and not, so the dispatcher isn't rebuilt per\n *  render. */\nexport function useHitObserver(\n  cb: ((hit: SceneCanvasHit | null) => void) | undefined,\n  pickerRef: MutableRefObject<Picker>,\n): ((world: { x: number; y: number }) => void) | undefined {\n  const cbRef = useLatest(cb);\n  const wired = Boolean(cb);\n  return useMemo(() => {\n    if (!wired) return undefined;\n    return (world) => {\n      const result = pickerRef.current?.(world.x, world.y);\n      cbRef.current?.(result ? { id: result.id, kind: result.kind } : null);\n    };\n  }, [wired, cbRef, pickerRef]);\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,eACd,IACA,WACyD;CACzD,MAAM,QAAQ,UAAU,EAAE;CAC1B,MAAM,QAAQ,QAAQ,EAAE;CACxB,OAAO,cAAc;EACnB,IAAI,CAAC,OAAO,OAAO;EACnB,QAAQ,UAAU;GAChB,MAAM,SAAS,UAAU,UAAU,MAAM,GAAG,MAAM,CAAC;GACnD,MAAM,UAAU,SAAS;IAAE,IAAI,OAAO;IAAI,MAAM,OAAO;GAAK,IAAI,IAAI;EACtE;CACF,GAAG;EAAC;EAAO;EAAO;CAAS,CAAC;AAC9B"}