@weasel-js/core 1.9.3 → 1.10.0

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","retriedRef","rearmRef","runPaint","useCallback","landed","fn","time","err","frame","useVisibleRaf","requestRedraw","subscribeFrame","subscribeBeforePaint","useLayoutEffect","subs","before"],"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 } from '@weasel-js/react';\nimport { useVisibleRaf, type VisibleRafTarget } from '../scheduling/useVisibleRaf';\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}\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\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((time: number) => {\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    { target: options.target },\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  // `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    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint };\n}\n"],"mappings":";;;;AAwCA,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,GAIzDU,IAAaV,EAAO,EAAK,GAEzBW,IAAWX,EAA4B,IAAI,GAE3CY,IAAWC,GAAa,MAAiB;EAE7C,AADA,EAAS,UAAU,IACnB,EAAY,UAAU;EACtB,IAAIC,IAAS;EACb,IAAI;GACF,KAAK,IAAMC,KAAMN,EAAU,SAAS,EAAGO,CAAI;GAE3C,IADA,IAASb,EAAS,QAAQ,GACtB,CAACW,GAAQ;IACX,EAAS,UAAU;IACnB;GACF;GACA,EAAW,UAAU;GAGrB,KAAK,IAAMC,KAAMP,EAAQ,SAAS,EAAGQ,CAAI;EAC3C,SAASC,GAAK;GAWZ,MALA,EAAS,UAAU,IACdP,EAAW,YACd,EAAW,UAAU,IACrBC,EAAS,UAAU,IAEfM;EACR,UAAU;GACR,EAAY,UAAU;EACxB;CACF,GAAG,CAACd,CAAQ,CAAC,GAEPe,IAAQC,EACZN,GAAa,MAAiB;EAC5B,AAAKZ,EAAS,WAAYF,EAAS,WACnCa,EAASI,CAAI;CACf,GAAG,CAACJ,CAAQ,CAAC,GACb,EAAE,QAAQL,EAAQ,OAAO,CAC3B;CACA,QAAyB;EACvB,EAAS,gBAAgB;GAAE,EAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,IAAMa,IAAgBP,QAAkB;EAMtC,IALA,EAAS,UAAU,IAKfP,EAAQ,WAAWL,EAAS,WAAW,CAACC,EAAY,WAAWgB,EAAM,UAAU,GAAG;GACpF,EAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,EAAM,QAAQ;CAChB,GAAG;EAACA;EAAON;EAAUN;CAAO,CAAC,GAEvBe,IAAiBR,GAAa,OAClCL,EAAQ,QAAQ,IAAIO,CAAE,SACT;EAAE,EAAQ,QAAQ,OAAOA,CAAE;CAAG,IAC1C,CAAC,CAAC,GACCO,IAAuBT,GAAa,OACxCJ,EAAU,QAAQ,IAAIM,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC;CAkBL,OAXAQ,QAAsB;EACpB,EAAS,UAAU;EACnB,IAAMC,IAAOhB,EAAQ,SACfiB,IAAShB,EAAU;EACzB,aAAa;GAGX,AAFA,EAAS,UAAU,IACnBe,EAAK,MAAM,GACXC,EAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC,GAEE;EAAE;EAAe;EAAgB;CAAqB;AAC/D"}
+{"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"}

package/dist/canvas/useHostAnchor.js

@@ -1,22 +1,22 @@
-import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
-import { hostAnchorCss as t, hostAnchorRect as n } from "./hostAnchor.js";
+import { hostAnchorCss as e, hostAnchorRect as t } from "./hostAnchor.js";
+import { watchElementMove as n } from "./watchElementMove.js";
 import { useCallback as r, useEffect as i, useState as a } from "react";
-import { useLatest as o } from "@weasel-js/react";
+import { useLatest as o, useVisibleRaf as s } from "@weasel-js/react";
 //#region src/canvas/useHostAnchor.ts
-function s(s, c) {
-	let [l, u] = a(null), [d, f] = a(null), p = r((e) => u(e), []), m = o(s), { align: h, offset: g, padding: _ = 0 } = c, { x: v, y } = h, { x: b, y: x } = g, S = r(() => {
-		let e = m.current();
-		if (!e) {
-			f(null);
+function c(c, l) {
+	let [u, d] = a(null), [f, p] = a(null), m = r((e) => d(e), []), h = o(c), { align: g, offset: _, padding: v = 0 } = l, { x: y, y: b } = g, { x, y: S } = _, C = r(() => {
+		let n = h.current();
+		if (!n) {
+			p(null);
 			return;
 		}
-		let r = e.getBoundingClientRect(), i = l?.getBoundingClientRect(), a = {
+		let r = n.getBoundingClientRect(), i = u?.getBoundingClientRect(), a = {
 			width: window.innerWidth,
 			height: window.innerHeight
 		}, o = {
-			x: v,
-			y
-		}, s = n({
+			x: y,
+			y: b
+		}, s = t({
 			host: {
 				x: r.left,
 				y: r.top,
@@ -30,42 +30,44 @@ function s(s, c) {
 			viewport: a,
 			align: o,
 			offset: {
-				x: b,
-				y: x
+				x,
+				y: S
 			},
-			padding: _
+			padding: v
 		});
-		f(t(s, o, a));
+		p(e(s, o, a));
 	}, [
-		m,
-		l,
-		v,
+		h,
+		u,
 		y,
 		b,
 		x,
-		_
-	]), C = e(S);
+		S,
+		v
+	]), w = s(C);
 	return i(() => {
-		S();
-		let e = () => C.request();
+		C();
+		let e = () => w.request();
 		window.addEventListener("scroll", e, !0), window.addEventListener("resize", e);
 		let t = typeof ResizeObserver < "u" ? new ResizeObserver(e) : null;
-		l && t?.observe(l);
-		let n = m.current();
-		return n && t?.observe(n), () => {
-			window.removeEventListener("scroll", e, !0), window.removeEventListener("resize", e), C.cancel(), t?.disconnect();
+		u && t?.observe(u);
+		let r = h.current();
+		r && t?.observe(r);
+		let i = r ? n(r, e) : void 0;
+		return () => {
+			window.removeEventListener("scroll", e, !0), window.removeEventListener("resize", e), w.cancel(), t?.disconnect(), i?.();
 		};
 	}, [
-		S,
 		C,
-		l,
-		m
+		w,
+		u,
+		h
 	]), {
-		ref: p,
-		style: d
+		ref: m,
+		style: f
 	};
 }
 //#endregion
-export { s as useHostAnchor };
+export { c as useHostAnchor };
 
 //# sourceMappingURL=useHostAnchor.js.map

package/dist/canvas/useHostAnchor.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHostAnchor.js","names":["useHostAnchor","panel","setPanel","useState","style","setStyle","ref","useCallback","el","resolve","useLatest","resolveHost","options","alignX","alignY","align","offsetX","offsetY","offset","recompute","hostEl","h","p","viewport","rect","hostAnchorRect","hostAnchorCss","padding","raf","useVisibleRaf","useEffect","schedule","observer"],"sources":["../../src/canvas/useHostAnchor.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../scheduling/useVisibleRaf';\nimport {\n  hostAnchorCss, hostAnchorRect,\n  type HostAnchorAlign, type HostAnchorOffset,\n} from './hostAnchor';\n\n/** Options for {@link useHostAnchor}. */\nexport interface UseHostAnchorOptions {\n  align: HostAnchorAlign;\n  offset: HostAnchorOffset;\n  /** Minimum gap kept between the panel and the viewport edge. Default 0. */\n  padding?: number;\n}\n\n/** CSS the caller spreads onto the panel; which edges appear follows `align`. */\nexport type HostAnchorStyle = { top?: number; right?: number; bottom?: number; left?: number };\n\n/**\n * Hold a fixed-position panel against a host element's corner, kept inside the\n * viewport, following it through scrolls, resizes and reflows.\n *\n * `resolveHost` runs on every recompute, so a host that mounts late or is found\n * by selector works the same as one held in a ref. Put the returned `ref` on the\n * panel: until it is measured the panel counts as zero-sized, which resolves to\n * the bare corner, so the first paint lands where an unclamped anchor would and\n * measurement only ever pulls it back on screen.\n */\nexport function useHostAnchor(\n  resolveHost: () => Element | null,\n  options: UseHostAnchorOptions,\n): { ref: (el: HTMLElement | null) => void; style: HostAnchorStyle | null } {\n  const [panel, setPanel] = useState<HTMLElement | null>(null);\n  const [style, setStyle] = useState<HostAnchorStyle | null>(null);\n  const ref = useCallback((el: HTMLElement | null) => setPanel(el), []);\n\n  // Held in a ref so a caller passing an inline arrow doesn't re-subscribe\n  // every render.\n  const resolve = useLatest(resolveHost);\n\n  const { align, offset, padding = 0 } = options;\n  const { x: alignX, y: alignY } = align;\n  const { x: offsetX, y: offsetY } = offset;\n\n  const recompute = useCallback(() => {\n    const hostEl = resolve.current();\n    if (!hostEl) {\n      setStyle(null);\n      return;\n    }\n    const h = hostEl.getBoundingClientRect();\n    const p = panel?.getBoundingClientRect();\n    const viewport = { width: window.innerWidth, height: window.innerHeight };\n    const align = { x: alignX, y: alignY };\n    const rect = hostAnchorRect({\n      host: { x: h.left, y: h.top, width: h.width, height: h.height },\n      panel: { width: p?.width ?? 0, height: p?.height ?? 0 },\n      viewport,\n      align,\n      offset: { x: offsetX, y: offsetY },\n      padding,\n    });\n    setStyle(hostAnchorCss(rect, align, viewport));\n  }, [resolve, panel, alignX, alignY, offsetX, offsetY, padding]);\n\n  // Coalesces bursts of scroll/resize into one frame, and holds the work while\n  // the tab is hidden rather than dropping it.\n  const raf = useVisibleRaf(recompute);\n\n  useEffect(() => {\n    // eslint-disable-next-line react-hooks/set-state-in-effect -- measures layout\n    recompute();\n    const schedule = () => raf.request();\n    window.addEventListener('scroll', schedule, true);\n    window.addEventListener('resize', schedule);\n    const observer =\n      typeof ResizeObserver !== 'undefined' ? new ResizeObserver(schedule) : null;\n    if (panel) observer?.observe(panel);\n    const hostEl = resolve.current();\n    if (hostEl) observer?.observe(hostEl);\n\n    return () => {\n      window.removeEventListener('scroll', schedule, true);\n      window.removeEventListener('resize', schedule);\n      raf.cancel();\n      observer?.disconnect();\n    };\n  }, [recompute, raf, panel, resolve]);\n\n  return { ref, style };\n}\n"],"mappings":";;;;;AA6BA,SAAgBA,EACd,GACA,GAC0E;CAC1E,IAAM,CAACC,GAAOC,KAAYC,EAA6B,IAAI,GACrD,CAACC,GAAOC,KAAYF,EAAiC,IAAI,GACzDG,IAAMC,GAAa,MAA2BL,EAASM,CAAE,GAAG,CAAC,CAAC,GAI9DC,IAAUC,EAAUC,CAAW,GAE/B,EAAE,UAAO,WAAQ,aAAU,MAAMC,GACjC,EAAE,GAAGC,GAAWC,MAAWC,GAC3B,EAAE,GAAGC,GAAS,GAAGC,MAAYC,GAE7BC,IAAYZ,QAAkB;EAClC,IAAMa,IAASX,EAAQ,QAAQ;EAC/B,IAAI,CAACW,GAAQ;GACX,EAAS,IAAI;GACb;EACF;EACA,IAAMC,IAAID,EAAO,sBAAsB,GACjCE,IAAIrB,GAAO,sBAAsB,GACjCsB,IAAW;GAAE,OAAO,OAAO;GAAY,QAAQ,OAAO;EAAY,GAClER,IAAQ;GAAE,GAAGF;GAAWC;EAAO,GAC/BU,IAAOC,EAAe;GAC1B,MAAM;IAAE,GAAGJ,EAAE;IAAM,GAAGA,EAAE;IAAK,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GAC9D,OAAO;IAAE,OAAOC,GAAG,SAAS;IAAG,QAAQA,GAAG,UAAU;GAAE;GACtD;GACA;GACA,QAAQ;IAAE,GAAGN;IAAS,GAAGC;GAAQ;GACjC;EACF,CAAC;EACD,EAASS,EAAcF,GAAMT,GAAOQ,CAAQ,CAAC;CAC/C,GAAG;EAACd;EAASR;EAAOY;EAAQC;EAAQE;EAASC;EAASU;CAAO,CAAC,GAIxDC,IAAMC,EAAcV,CAAS;CAsBnC,OApBAW,QAAgB;EAEd,EAAU;EACV,IAAMC,UAAiBH,EAAI,QAAQ;EAEnC,AADA,OAAO,iBAAiB,UAAUG,GAAU,EAAI,GAChD,OAAO,iBAAiB,UAAUA,CAAQ;EAC1C,IAAMC,IACJ,OAAO,iBAAmB,MAAc,IAAI,eAAeD,CAAQ,IAAI;EACzE,AAAI9B,KAAO+B,GAAU,QAAQ/B,CAAK;EAClC,IAAMmB,IAASX,EAAQ,QAAQ;EAG/B,OAFIW,KAAQY,GAAU,QAAQZ,CAAM,SAEvB;GAIX,AAHA,OAAO,oBAAoB,UAAUW,GAAU,EAAI,GACnD,OAAO,oBAAoB,UAAUA,CAAQ,GAC7CH,EAAI,OAAO,GACXI,GAAU,WAAW;EACvB;CACF,GAAG;EAACb;EAAWS;EAAK3B;EAAOQ;CAAO,CAAC,GAE5B;EAAE;EAAK;CAAM;AACtB"}
+{"version":3,"file":"useHostAnchor.js","names":["useHostAnchor","panel","setPanel","useState","style","setStyle","ref","useCallback","el","resolve","useLatest","resolveHost","options","alignX","alignY","align","offsetX","offsetY","offset","recompute","hostEl","h","p","viewport","rect","hostAnchorRect","hostAnchorCss","padding","raf","useVisibleRaf","useEffect","schedule","observer","unwatchMove","watchElementMove"],"sources":["../../src/canvas/useHostAnchor.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\nimport { useLatest, useVisibleRaf } from '@weasel-js/react';\nimport {\n  hostAnchorCss, hostAnchorRect,\n  type HostAnchorAlign, type HostAnchorOffset,\n} from './hostAnchor';\nimport { watchElementMove } from './watchElementMove';\n\n/** Options for {@link useHostAnchor}. */\nexport interface UseHostAnchorOptions {\n  align: HostAnchorAlign;\n  offset: HostAnchorOffset;\n  /** Minimum gap kept between the panel and the viewport edge. Default 0. */\n  padding?: number;\n}\n\n/** CSS the caller spreads onto the panel; which edges appear follows `align`. */\nexport type HostAnchorStyle = { top?: number; right?: number; bottom?: number; left?: number };\n\n/**\n * Hold a fixed-position panel against a host element's corner, kept inside the\n * viewport, following it through scrolls, resizes, and reflows, a host moved by\n * its neighbors included.\n *\n * `resolveHost` runs on every recompute, so a host that mounts late or is found\n * by selector works the same as one held in a ref. Put the returned `ref` on the\n * panel: until it is measured the panel counts as zero-sized, which resolves to\n * the bare corner, so the first paint lands where an unclamped anchor would and\n * measurement only ever pulls it back on screen.\n */\nexport function useHostAnchor(\n  resolveHost: () => Element | null,\n  options: UseHostAnchorOptions,\n): { ref: (el: HTMLElement | null) => void; style: HostAnchorStyle | null } {\n  const [panel, setPanel] = useState<HTMLElement | null>(null);\n  const [style, setStyle] = useState<HostAnchorStyle | null>(null);\n  const ref = useCallback((el: HTMLElement | null) => setPanel(el), []);\n\n  // Held in a ref so a caller passing an inline arrow doesn't re-subscribe\n  // every render.\n  const resolve = useLatest(resolveHost);\n\n  const { align, offset, padding = 0 } = options;\n  const { x: alignX, y: alignY } = align;\n  const { x: offsetX, y: offsetY } = offset;\n\n  const recompute = useCallback(() => {\n    const hostEl = resolve.current();\n    if (!hostEl) {\n      setStyle(null);\n      return;\n    }\n    const h = hostEl.getBoundingClientRect();\n    const p = panel?.getBoundingClientRect();\n    const viewport = { width: window.innerWidth, height: window.innerHeight };\n    const align = { x: alignX, y: alignY };\n    const rect = hostAnchorRect({\n      host: { x: h.left, y: h.top, width: h.width, height: h.height },\n      panel: { width: p?.width ?? 0, height: p?.height ?? 0 },\n      viewport,\n      align,\n      offset: { x: offsetX, y: offsetY },\n      padding,\n    });\n    setStyle(hostAnchorCss(rect, align, viewport));\n  }, [resolve, panel, alignX, alignY, offsetX, offsetY, padding]);\n\n  // Coalesces bursts of scroll/resize into one frame, and holds the work while\n  // the tab is hidden rather than dropping it.\n  const raf = useVisibleRaf(recompute);\n\n  useEffect(() => {\n    // eslint-disable-next-line react-hooks/set-state-in-effect -- measures layout\n    recompute();\n    const schedule = () => raf.request();\n    window.addEventListener('scroll', schedule, true);\n    window.addEventListener('resize', schedule);\n    const observer =\n      typeof ResizeObserver !== 'undefined' ? new ResizeObserver(schedule) : null;\n    if (panel) observer?.observe(panel);\n    const hostEl = resolve.current();\n    if (hostEl) observer?.observe(hostEl);\n    const unwatchMove = hostEl ? watchElementMove(hostEl, schedule) : undefined;\n\n    return () => {\n      window.removeEventListener('scroll', schedule, true);\n      window.removeEventListener('resize', schedule);\n      raf.cancel();\n      observer?.disconnect();\n      unwatchMove?.();\n    };\n  }, [recompute, raf, panel, resolve]);\n\n  return { ref, style };\n}\n"],"mappings":";;;;;AA8BA,SAAgBA,EACd,GACA,GAC0E;CAC1E,IAAM,CAACC,GAAOC,KAAYC,EAA6B,IAAI,GACrD,CAACC,GAAOC,KAAYF,EAAiC,IAAI,GACzDG,IAAMC,GAAa,MAA2BL,EAASM,CAAE,GAAG,CAAC,CAAC,GAI9DC,IAAUC,EAAUC,CAAW,GAE/B,EAAE,UAAO,WAAQ,aAAU,MAAMC,GACjC,EAAE,GAAGC,GAAQ,GAAGC,MAAWC,GAC3B,EAAKC,GAAS,GAAGC,MAAYC,GAE7BC,IAAYZ,QAAkB;EAClC,IAAMa,IAASX,EAAQ,QAAQ;EAC/B,IAAI,CAACW,GAAQ;GACX,EAAS,IAAI;GACb;EACF;EACA,IAAMC,IAAID,EAAO,sBAAsB,GACjCE,IAAIrB,GAAO,sBAAsB,GACjCsB,IAAW;GAAE,OAAO,OAAO;GAAY,QAAQ,OAAO;EAAY,GAClER,IAAQ;GAAE,GAAGF;GAAQ,GAAGC;EAAO,GAC/BU,IAAOC,EAAe;GAC1B,MAAM;IAAE,GAAGJ,EAAE;IAAM,GAAGA,EAAE;IAAK,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GAC9D,OAAO;IAAE,OAAOC,GAAG,SAAS;IAAG,QAAQA,GAAG,UAAU;GAAE;GACtD;GACA;GACA,QAAQ;IAAKN;IAAS,GAAGC;GAAQ;GACjC;EACF,CAAC;EACD,EAASS,EAAcF,GAAMT,GAAOQ,CAAQ,CAAC;CAC/C,GAAG;EAACd;EAASR;EAAOY;EAAQC;EAAQE;EAASC;EAASU;CAAO,CAAC,GAIxDC,IAAMC,EAAcV,CAAS;CAwBnC,OAtBAW,QAAgB;EAEd,EAAU;EACV,IAAMC,UAAiBH,EAAI,QAAQ;EAEnC,AADA,OAAO,iBAAiB,UAAUG,GAAU,EAAI,GAChD,OAAO,iBAAiB,UAAUA,CAAQ;EAC1C,IAAMC,IACJ,OAAO,iBAAmB,MAAc,IAAI,eAAeD,CAAQ,IAAI;EACzE,AAAI9B,KAAO+B,GAAU,QAAQ/B,CAAK;EAClC,IAAMmB,IAASX,EAAQ,QAAQ;EAC/B,AAAIW,KAAQY,GAAU,QAAQZ,CAAM;EACpC,IAAMa,IAAcb,IAASc,EAAiBd,GAAQW,CAAQ,IAAI,KAAA;EAElE,aAAa;GAKX,AAJA,OAAO,oBAAoB,UAAUA,GAAU,EAAI,GACnD,OAAO,oBAAoB,UAAUA,CAAQ,GAC7CH,EAAI,OAAO,GACXI,GAAU,WAAW,GACrBC,IAAc;EAChB;CACF,GAAG;EAACd;EAAWS;EAAK3B;EAAOQ;CAAO,CAAC,GAE5B;EAAE;EAAK;CAAM;AACtB"}

package/dist/canvas/useLateContentRedraw.js

@@ -1,17 +1,17 @@
-import { paintKindRegistry as e } from "../core/paintKinds.js";
-import { subscribeImageReady as t } from "../features/images/imageCache.js";
-import { subscribeGlyphReady as n } from "@weasel-js/font";
-import { useEffect as r } from "react";
+import { paintKindRegistry as e } from "../core/paint/paintKinds.js";
+import { subscribeImageReady as t } from "@weasel-js/renderer";
+import { useEffect as n } from "react";
+import { subscribeGlyphReady as r } from "@weasel-js/font";
 //#region src/canvas/useLateContentRedraw.ts
 function i(i) {
-	r(() => {
-		let r = [
+	n(() => {
+		let n = [
 			t(i),
-			n(i),
+			r(i),
 			e.subscribe(i)
 		];
 		return () => {
-			for (let e of r) e();
+			for (let e of n) e();
 		};
 	}, [i]);
 }

package/dist/canvas/useLateContentRedraw.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLateContentRedraw.js","names":["useLateContentRedraw","offs","subscribeImageReady","requestRedraw","subscribeGlyphReady","paintKindRegistry","off"],"sources":["../../src/canvas/useLateContentRedraw.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { subscribeGlyphReady } from '@weasel-js/font';\nimport { subscribeImageReady } from 'features/images/imageCache';\nimport { paintKindRegistry } from 'core/paintKinds';\n\n/**\n * Repaint whenever something a frame could not draw becomes drawable: an image\n * finishes decoding, a deferred glyph bake or font load lands, or a paint kind\n * registers late. Each of these drew nothing (or a placeholder) on the frame\n * that asked for it and says nothing further unless a surface is listening.\n */\nexport function useLateContentRedraw(requestRedraw: () => void): void {\n  useEffect(() => {\n    const offs = [\n      subscribeImageReady(requestRedraw),\n      subscribeGlyphReady(requestRedraw),\n      paintKindRegistry.subscribe(requestRedraw),\n    ];\n    return () => { for (const off of offs) off(); };\n  }, [requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EAAqB,GAAiC;CACpE,QAAgB;EACd,IAAMC,IAAO;GACXC,EAAoBC,CAAa;GACjCC,EAAoBD,CAAa;GACjCE,EAAkB,UAAUF,CAAa;EAC3C;EACA,aAAa;GAAE,KAAK,IAAMG,KAAOL,GAAM,EAAI;EAAG;CAChD,GAAG,CAACE,CAAa,CAAC;AACpB"}
+{"version":3,"file":"useLateContentRedraw.js","names":["useLateContentRedraw","offs","subscribeImageReady","requestRedraw","subscribeGlyphReady","paintKindRegistry","off"],"sources":["../../src/canvas/useLateContentRedraw.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { subscribeGlyphReady } from '@weasel-js/font';\nimport { subscribeImageReady } from '@weasel-js/renderer';\nimport { paintKindRegistry } from 'core/paint/paintKinds';\n\n/**\n * Repaint whenever something a frame could not draw becomes drawable: an image\n * finishes decoding, a deferred glyph bake or font load lands, or a paint kind\n * registers late. Each of these drew nothing (or a placeholder) on the frame\n * that asked for it and says nothing further unless a surface is listening.\n */\nexport function useLateContentRedraw(requestRedraw: () => void): void {\n  useEffect(() => {\n    const offs = [\n      subscribeImageReady(requestRedraw),\n      subscribeGlyphReady(requestRedraw),\n      paintKindRegistry.subscribe(requestRedraw),\n    ];\n    return () => { for (const off of offs) off(); };\n  }, [requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EAAqB,GAAiC;CACpE,QAAgB;EACd,IAAMC,IAAO;GACXC,EAAoBC,CAAa;GACjCC,EAAoBD,CAAa;GACjCE,EAAkB,UAAUF,CAAa;EAC3C;EACA,aAAa;GAAE,KAAK,IAAMG,KAAOL,GAAM,EAAI;EAAG;CAChD,GAAG,CAACE,CAAa,CAAC;AACpB"}

package/dist/canvas/useSceneLayerList.js

@@ -0,0 +1,11 @@
+import { useCallback as e, useSyncExternalStore as t } from "react";
+//#region src/canvas/useSceneLayerList.ts
+var n = () => {}, r = (e) => typeof e?.getLayers == "function" ? e.getLayers().map((e) => e.id).join("\n") : "";
+function i(i) {
+	let a = e((e) => i?.subscribeLayers?.(e) ?? n, [i]), o = e(() => r(i), [i]);
+	return t(a, o, o);
+}
+//#endregion
+export { i as useSceneLayerList };
+
+//# sourceMappingURL=useSceneLayerList.js.map

package/dist/canvas/useSceneLayerList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSceneLayerList.js","names":["UNSUBSCRIBED","read","adapter","l","useSceneLayerList","subscribe","useCallback","listener","snapshot","useSyncExternalStore"],"sources":["../../src/canvas/useSceneLayerList.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\n\ninterface LayerListSource {\n  getLayers?: () => readonly { id: string }[];\n  subscribeLayers?: (listener: () => void) => () => void;\n}\n\nconst UNSUBSCRIBED = (): void => {};\n\nconst read = (adapter: LayerListSource | undefined): string =>\n  typeof adapter?.getLayers === 'function' ? adapter.getLayers().map((l) => l.id).join('\\n') : '';\n\n/**\n * The adapter's scene-layer ids as a render input: a string that changes when\n * a layer is added, removed, or reordered. A scene write repaints without\n * re-rendering, so the adapter's `subscribeLayers` is what tells React.\n */\nexport function useSceneLayerList(adapter: LayerListSource | undefined): string {\n  const subscribe = useCallback(\n    (listener: () => void) => adapter?.subscribeLayers?.(listener) ?? UNSUBSCRIBED,\n    [adapter],\n  );\n  const snapshot = useCallback(() => read(adapter), [adapter]);\n  return useSyncExternalStore(subscribe, snapshot, snapshot);\n}\n"],"mappings":";;AAOA,IAAMA,UAA2B,CAAC,GAE5BC,KAAQ,MACZ,OAAOC,GAAS,aAAc,aAAaA,EAAQ,UAAU,CAAC,CAAC,KAAK,MAAMC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI;AAO/F,SAAgBC,EAAkB,GAA8C;CAC9E,IAAMC,IAAYC,GACf,MAAyBJ,GAAS,kBAAkBK,CAAQ,KAAKP,GAClE,CAACE,CAAO,CACV,GACMM,IAAWF,QAAkBL,EAAKC,CAAO,GAAG,CAACA,CAAO,CAAC;CAC3D,OAAOO,EAAqBJ,GAAWG,GAAUA,CAAQ;AAC3D"}

package/dist/canvas/useSurfaceInput.js

@@ -0,0 +1,42 @@
+import { useLayoutEffect as e, useRef as t } from "react";
+import { useLatest as n } from "@weasel-js/react";
+//#region src/canvas/useSurfaceInput.ts
+function r(r, a) {
+	let o = n(a), s = t(null);
+	e(() => {
+		let e = r.current;
+		s.current?.element !== e && (s.current?.detach(), s.current = e ? {
+			element: e,
+			detach: i(e, o)
+		} : null);
+	}), e(() => () => {
+		s.current?.detach(), s.current = null;
+	}, []);
+}
+function i(e, t) {
+	let n = !1, r = {
+		pointerdown: () => {
+			t.current.focusOnPress && e.focus(), n = !0;
+		},
+		pointermove: (r) => {
+			n || t.current.onHover(e, r);
+		},
+		pointerup: () => {
+			n = !1;
+		},
+		pointerleave: () => {
+			n = !1, t.current.onLeave();
+		},
+		contextmenu: (e) => e.preventDefault(),
+		focus: (e) => t.current.onFocus?.(e),
+		blur: (e) => t.current.onBlur?.(e)
+	};
+	for (let [t, n] of Object.entries(r)) e.addEventListener(t, n);
+	return () => {
+		for (let [t, n] of Object.entries(r)) e.removeEventListener(t, n);
+	};
+}
+//#endregion
+export { r as useSurfaceInput };
+
+//# sourceMappingURL=useSurfaceInput.js.map

package/dist/canvas/useSurfaceInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSurfaceInput.js","names":["useSurfaceInput","live","useLatest","handlers","attached","useRef","useLayoutEffect","element","elementRef","listen","pressed","listeners","event","type","fn"],"sources":["../../src/canvas/useSurfaceInput.ts"],"sourcesContent":["import { useLayoutEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\n\n/** What a surface does with the input its element receives. */\nexport interface SurfaceInputHandlers {\n  /** Focus the element on a press, so keys reach it without a click first. */\n  focusOnPress: boolean;\n  onFocus?: (event: FocusEvent) => void;\n  onBlur?: (event: FocusEvent) => void;\n  /** The pointer moved over the element with no button held. */\n  onHover(element: HTMLElement, event: PointerEvent): void;\n  /** The pointer left the element. */\n  onLeave(): void;\n}\n\n/**\n * Listen on whichever element `elementRef` holds, moving the listeners when\n * it holds another. Handlers are read at event time, so a new set never\n * re-attaches.\n *\n * Tracks one fact about the pointer, whether a button is down, because hover\n * stands down for as long as one is. Everything else about a press is the\n * gesture dispatcher's, which listens on this same element.\n *\n * Suppresses the browser's context menu: right-click is a gesture surface\n * tools may consume.\n */\nexport function useSurfaceInput(\n  elementRef: { readonly current: HTMLElement | null },\n  handlers: SurfaceInputHandlers,\n): void {\n  const live = useLatest(handlers);\n  const attached = useRef<{ element: HTMLElement; detach: () => void } | null>(null);\n\n  useLayoutEffect(() => {\n    const element = elementRef.current;\n    if (attached.current?.element === element) return;\n    attached.current?.detach();\n    attached.current = element ? { element, detach: listen(element, live) } : null;\n  });\n  useLayoutEffect(() => () => {\n    attached.current?.detach();\n    attached.current = null;\n  }, []);\n}\n\nfunction listen(element: HTMLElement, live: { readonly current: SurfaceInputHandlers }): () => void {\n  let pressed = false;\n  const listeners: Record<string, (event: Event) => void> = {\n    pointerdown: () => {\n      if (live.current.focusOnPress) element.focus();\n      pressed = true;\n    },\n    pointermove: (event) => {\n      if (!pressed) live.current.onHover(element, event as PointerEvent);\n    },\n    pointerup: () => { pressed = false; },\n    pointerleave: () => {\n      pressed = false;\n      live.current.onLeave();\n    },\n    contextmenu: (event) => event.preventDefault(),\n    focus: (event) => live.current.onFocus?.(event as FocusEvent),\n    blur: (event) => live.current.onBlur?.(event as FocusEvent),\n  };\n  for (const [type, fn] of Object.entries(listeners)) element.addEventListener(type, fn);\n  return () => {\n    for (const [type, fn] of Object.entries(listeners)) element.removeEventListener(type, fn);\n  };\n}\n"],"mappings":";;;AA2BA,SAAgBA,EACd,GACA,GACM;CACN,IAAMC,IAAOC,EAAUC,CAAQ,GACzBC,IAAWC,EAA4D,IAAI;CAQjF,AANAC,QAAsB;EACpB,IAAMC,IAAUC,EAAW;EAC3B,AAAIJ,EAAS,SAAS,YAAYG,MAClCH,EAAS,SAAS,OAAO,GACzB,EAAS,UAAUG,IAAU;GAAE;GAAS,QAAQE,EAAOF,GAASN,CAAI;EAAE,IAAI;CAC5E,CAAC,GACDK,cAA4B;EAE1B,AADAF,EAAS,SAAS,OAAO,GACzB,EAAS,UAAU;CACrB,GAAG,CAAC,CAAC;AACP;AAEA,SAASK,EAAO,GAAsB,GAA8D;CAClG,IAAIC,IAAU,IACRC,IAAoD;EACxD,mBAAmB;GAEjB,AADIV,EAAK,QAAQ,gBAAcM,EAAQ,MAAM,GAC7C,IAAU;EACZ;EACA,cAAc,MAAU;GACtB,AAAKG,KAAST,EAAK,QAAQ,QAAQM,GAASK,CAAqB;EACnE;EACA,iBAAiB;GAAE,IAAU;EAAO;EACpC,oBAAoB;GAElB,AADA,IAAU,IACVX,EAAK,QAAQ,QAAQ;EACvB;EACA,cAAc,MAAUW,EAAM,eAAe;EAC7C,QAAQ,MAAUX,EAAK,QAAQ,UAAUW,CAAmB;EAC5D,OAAO,MAAUX,EAAK,QAAQ,SAASW,CAAmB;CAC5D;CACA,KAAK,IAAM,CAACC,GAAMC,MAAO,OAAO,QAAQH,CAAS,GAAG,EAAQ,iBAAiBE,GAAMC,CAAE;CACrF,aAAa;EACX,KAAK,IAAM,CAACD,GAAMC,MAAO,OAAO,QAAQH,CAAS,GAAG,EAAQ,oBAAoBE,GAAMC,CAAE;CAC1F;AACF"}

package/dist/canvas/useToolCursor.js

@@ -0,0 +1,29 @@
+import { useLayoutEffect as e } from "react";
+import { resolveCursorTier as t } from "@weasel-js/cursor";
+//#region src/canvas/useToolCursor.ts
+function n(e) {
+	let n = e.hotkeyEngaged ?? e.active, r = n === null ? void 0 : e.registry[n];
+	if (r?.cursor) {
+		if (typeof r.cursor != "function") return t(r.cursor);
+		try {
+			return t(r.cursor());
+		} catch {
+			return;
+		}
+	}
+}
+function r(t, r, i, a) {
+	let o = r ? n(r) : void 0, s = o === void 0 ? "" : o.kind === "css" ? `css|${o.css}` : `${o.glyph}|${o.angle}|${o.size}|${o.worldRadius}`;
+	e(() => {
+		t.setBase(o ?? null, a ?? "");
+	}, [
+		t,
+		s,
+		i,
+		a
+	]);
+}
+//#endregion
+export { r as useToolCursor };
+
+//# sourceMappingURL=useToolCursor.js.map

package/dist/canvas/useToolCursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToolCursor.js","names":["resolveToolsCursor","id","tools","tool","resolveCursorTier","useToolCursor","tier","key","rest","sink","element"],"sources":["../../src/canvas/useToolCursor.ts"],"sourcesContent":["import { useLayoutEffect } from 'react';\nimport { resolveCursorTier, type CursorSink, type ResolvedCursor } from '@weasel-js/cursor';\nimport type { ToolsApi } from '../tools/overlayBinding';\n\nfunction resolveToolsCursor(tools: ToolsApi): ResolvedCursor | undefined {\n  const id = tools.hotkeyEngaged ?? tools.active;\n  const tool = id === null ? undefined : tools.registry[id];\n  if (!tool?.cursor) return undefined;\n  if (typeof tool.cursor !== 'function') return resolveCursorTier(tool.cursor);\n  try {\n    return resolveCursorTier(tool.cursor());\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the active tool's cursor to `sink` as its base, and `rest` (the\n * element's own cursor) for when the tool declares none.\n *\n * `element` is what the sink writes to, named so the base is written again\n * when a detached surface's input element arrives a render late.\n */\nexport function useToolCursor(\n  sink: CursorSink,\n  tools: ToolsApi | undefined,\n  element: HTMLElement | null | undefined,\n  rest: string | undefined,\n): void {\n  const tier = tools ? resolveToolsCursor(tools) : undefined;\n  // Keyed on the value, not the object: the tier is rebuilt every render.\n  const key = tier === undefined\n    ? ''\n    : tier.kind === 'css'\n      ? `css|${tier.css}`\n      : `${tier.glyph}|${tier.angle}|${tier.size}|${tier.worldRadius}`;\n  useLayoutEffect(() => {\n    sink.setBase(tier ?? null, rest ?? '');\n    // `tier` is a fresh object each render; the key is its identity.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [sink, key, element, rest]);\n}\n"],"mappings":";;;AAIA,SAASA,EAAmB,GAA6C;CACvE,IAAMC,IAAKC,EAAM,iBAAiBA,EAAM,QAClCC,IAAOF,MAAO,OAAO,KAAA,IAAYC,EAAM,SAASD;CACtD,IAAKE,GAAM,QACX;MAAI,OAAOA,EAAK,UAAW,YAAY,OAAOC,EAAkBD,EAAK,MAAM;EAC3E,IAAI;GACF,OAAOC,EAAkBD,EAAK,OAAO,CAAC;EACxC,QAAQ;GACN;EACF;CAL2E;AAM7E;AASA,SAAgBE,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAOJ,IAAQF,EAAmBE,CAAK,IAAI,KAAA,GAE3CK,IAAMD,MAAS,KAAA,IACjB,KACAA,EAAK,SAAS,QACZ,OAAOA,EAAK,QACZ,GAAGA,EAAK,MAAM,GAAGA,EAAK,MAAM,GAAGA,EAAK,KAAK,GAAGA,EAAK;CACvD,QAAsB;EACpB,EAAK,QAAQA,KAAQ,MAAME,KAAQ,EAAE;CAGvC,GAAG;EAACC;EAAMF;EAAKG;EAASF;CAAI,CAAC;AAC/B"}

package/dist/canvas/useViewHelpers.js

@@ -1,73 +1,41 @@
 import { unionAABB as e } from "../core/geometry/unionBounds.js";
-import { aggregatePreviewIds as t, firstPreviewBounds as n, firstPreviewPose as r, toolPreviewSources as i } from "./toolPreview.js";
-import { buildChromeState as a } from "../core/selection/chromeState.js";
-import { useCallback as o, useMemo as s } from "react";
-import { useLatest as c } from "@weasel-js/react";
+import { framedBounds as t } from "../core/geometry/poseDescriptor.js";
+import { buildChromeState as n } from "../core/selection/chromeState.js";
+import { useCallback as r, useMemo as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
 //#region src/canvas/useViewHelpers.ts
-var l = () => {}, u = () => !0;
-function d(e, t) {
+var o = () => {}, s = () => !0;
+function c(e, t) {
 	return typeof e.getWorldPose == "function" ? e.getWorldPose(t) : e.getPose(t);
 }
-function f(f) {
-	let { adapter: p, geometry: m, boundsOf: h, boundsOfPose: g, selection: _, tools: v, gestureSource: y, previewPoseExtra: b, previewIdsExtra: x, getIsVisible: S } = f, C = o((e, t) => g ? g(e, t) : m.getBounds(t), [g, m]), w = s(() => {
-		if (h) return h;
-		if (p) return (e) => {
+function l(l) {
+	let { adapter: u, geometry: d, boundsOf: f, boundsOfPose: p, selection: m, gestureSource: h, previewPoseExtra: g, getIsVisible: _ } = l, v = r((e, n) => p ? p(e, n) : t(n, d), [p, d]), y = i(() => {
+		if (f) return f;
+		if (u) return (e) => {
 			try {
-				let t = d(p, e), n = m.getBounds(t), r = m.getRotation?.(t);
-				return r ? {
-					...n,
-					rotation: r
-				} : n;
+				return t(c(u, e), d);
 			} catch {
 				return null;
 			}
 		};
 	}, [
-		h,
-		p,
-		m
-	]), T = o((e) => {
-		if (!p) return null;
+		f,
+		u,
+		d
+	]), b = r((e) => {
+		if (!u) return null;
 		try {
-			return d(p, e);
+			return c(u, e);
 		} catch {
 			return null;
 		}
-	}, [p]), E = _.length > 1, D = c({
-		previewPoseExtra: b,
-		previewIdsExtra: x
-	}), O = s(() => h ?? w, [h, w]), k = o((e) => {
-		if (v) {
-			let t = r(v, e);
-			if (t != null) return t;
-		}
-		let t = D.current.previewPoseExtra;
-		if (t) {
-			let n = t(e);
-			if (n != null) return n;
-		}
-		return null;
-	}, [v, D]), A = o((e) => {
-		if (v) {
-			let t = n(v, e);
-			if (t) return t;
-			let i = r(v, e);
-			if (i != null) return C(e, i);
-		}
-		let t = D.current.previewPoseExtra;
-		if (t) {
-			let n = t(e);
-			if (n != null) return C(e, n);
-		}
-		return null;
-	}, [
-		v,
-		C,
-		D
-	]), j = o((e) => A(e) || (O ? O(e) : null), [A, O]), M = s(() => a({
-		selection: _,
-		multiActive: E,
-		effectiveBoundsOf: j,
+	}, [u]), x = m.length > 1, S = a(g), C = i(() => f ?? y, [f, y]), w = r((e) => S.current?.(e) ?? null, [S]), T = r((e) => {
+		let t = w(e);
+		return t == null ? null : v(e, t);
+	}, [w, v]), E = r((e) => T(e) || (C ? C(e) : null), [T, C]), D = i(() => n({
+		selection: m,
+		multiActive: x,
+		effectiveBoundsOf: E,
 		modifiers: {
 			alt: !1,
 			shift: !1,
@@ -75,46 +43,39 @@ function f(f) {
 			ctrl: !1
 		},
 		canRotate: (e) => {
-			if (!m.supportsRotation) return !0;
-			let t = T(e);
-			return t == null || m.supportsRotation(t);
+			if (!d.supportsRotation) return !0;
+			let t = b(e);
+			return t == null || d.supportsRotation(t);
 		}
 	}), [
-		_,
-		E,
-		j,
 		m,
-		T
+		x,
+		E,
+		d,
+		b
 	]);
 	return {
 		helpers: {
-			getEffectivePose: (e) => k(e) ?? T(e),
-			getEffectiveBounds: j,
+			getEffectivePose: (e) => w(e) ?? b(e),
+			getEffectiveBounds: E,
 			getGestureBounds: () => {
-				let n = t(v), r = y?.ids();
-				if (r) for (let e of r) n.add(e);
-				let i = [];
-				for (let e of n) i.push(A(e));
-				let a = y?.bounds();
-				if (a) for (let e of a) i.push(e);
-				return e(i);
+				let t = [];
+				for (let e of new Set(h?.ids() ?? [])) t.push(T(e));
+				let n = h?.bounds();
+				if (n) for (let e of n) t.push(e);
+				return e(t);
 			},
-			subscribeGestures: (e) => y?.subscribe(e) ?? l,
-			getGestureVersion: () => y?.getVersion() ?? 0,
-			getChromeState: () => M,
-			getPreviewSources: () => [...i(v), ...y?.previewSources() ?? []],
-			getGestureOverlays: () => y?.overlays() ?? [],
-			getIsVisible: () => S?.() ?? u
+			subscribeGestures: (e) => h?.subscribe(e) ?? o,
+			getGestureVersion: () => h?.getVersion() ?? 0,
+			getChromeState: () => D,
+			getPreviewSources: () => h?.previewSources() ?? [],
+			getGestureOverlays: () => h?.overlays() ?? [],
+			getIsVisible: () => _?.() ?? s
 		},
-		chromeState: M,
-		committedPoseOf: T,
-		effectiveBoundsOf: O,
-		previewToolPose: k,
-		previewToolBounds: A,
-		previewExtraRef: D
+		chromeState: D
 	};
 }
 //#endregion
-export { f as useViewHelpers };
+export { l as useViewHelpers };
 
 //# sourceMappingURL=useViewHelpers.js.map

package/dist/canvas/useViewHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"useViewHelpers.js","names":["noOpUnsubscribe","alwaysVisible","worldPoseOf","adapter","id","useViewHelpers","opts","boxOf","useCallback","boundsOfPose","pose","geometry","baseBoundsOf","useMemo","boundsOf","b","rot","committedPoseOf","multiActive","selection","previewExtraRef","useLatest","effectiveBoundsOf","previewToolPose","tools","p","firstPreviewPose","extra","previewToolBounds","firstPreviewBounds","boundsWithPreview","chromeState","buildChromeState","ids","aggregatePreviewIds","extraIds","gestureSource","parts","extraBounds","unionAABB","fn","toolPreviewSources","getIsVisible"],"sources":["../../src/canvas/useViewHelpers.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { firstPreviewPose, firstPreviewBounds, aggregatePreviewIds, toolPreviewSources } from './toolPreview';\nimport type { GestureSource, GesturePreviewSource } from './gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { buildChromeState, type ChromeState } from 'core/selection/chromeState';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { NodeId } from 'core/scene/types';\nimport type { ToolsApi } from '../tools/overlayBinding';\nimport type { DebugSink } from '../debug/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nconst noOpUnsubscribe = (): void => {};\n\nconst alwaysVisible = (): boolean => true;\n\n/**\n * The half of {@link CanvasHelpers} that belongs to one view — everything\n * answered by a camera's own tools, gestures and selection. A canvas hosting\n * several viewports needs one of these per view; the surface half is shared.\n */\nexport interface CanvasViewHelpers<TPose> {\n  /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,\n   *  otherwise the committed pose from the adapter. Returns `null` if the id\n   *  isn't known. */\n  getEffectivePose(id: string): TPose | null;\n  /** Overlay-aware bounds for `id`. */\n  getEffectiveBounds(id: string): Bounds | null;\n  /**\n   * World-space AABB of everything the in-flight gesture proposes — the\n   * displaced poses of nodes being moved / resized / rotated / cloned, plus\n   * any nascent insert that has no scene node yet. `null` when no gesture is\n   * in flight.\n   *\n   * This reports the *gesture*, not the document: committed content the\n   * gesture isn't touching is excluded, so a consumer that wants the union\n   * with the rest of the scene still walks its own ids through\n   * `getEffectiveBounds`. It exists because every other lookup here is keyed\n   * by node id, which can't answer \"where is the shape the user is drawing\n   * right now\" — a drag-to-insert has no id until pointer-up.\n   *\n   * Select-only gestures are deliberately excluded: a marquee or lasso has\n   * geometry but proposes no content, and a consumer sizing itself to the\n   * gesture must not grow because the user swept a selection rectangle.\n   *\n   * The result is a plain AABB — never rotated. Rotated parts are folded in\n   * by their rotated extent (a union of several oriented boxes has no single\n   * orientation to report).\n   */\n  getGestureBounds(): Bounds | null;\n  /**\n   * Subscribe to the gesture layer's change signal — the other half of the\n   * `useSyncExternalStore` contract for everything on this object that moves\n   * during a drag (`getEffectivePose`, `getEffectiveBounds`,\n   * `getGestureBounds`). Returns an unsubscribe.\n   *\n   * Fires once per dispatcher pump: gesture start, every pointermove that\n   * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing\n   * actions (a slider bound to an ongoing action pumps the same way). It\n   * fires on the pump, not on a diff: a pump that changed nothing observable\n   * still notifies, so don't hang expensive work directly off the callback.\n   *\n   * It does **not** cover committed scene edits (subscribe to the scene for\n   * those) or previews a consumer's own tool publishes from React state\n   * (that tool re-renders on its own).\n   *\n   * Without a gesture source wired — a bare `<Canvas>` — this is a no-op\n   * subscription that never fires.\n   */\n  subscribeGestures(fn: () => void): () => void;\n  /**\n   * Monotonic counter bumped on exactly the events `subscribeGestures` fires\n   * on. Pair the two for `useSyncExternalStore`:\n   *\n   * ```ts\n   * const gestureVersion = useSyncExternalStore(\n   *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),\n   *   () => helpersRef.current?.getGestureVersion() ?? 0,\n   * );\n   * ```\n   *\n   * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with\n   * no gesture source reports, forever.\n   */\n  getGestureVersion(): number;\n  /** Returns the live ChromeState built once per render. Affordances and\n   *  custom layers that need overlay-aware selection state (selection ids,\n   *  bounds, multi-union AABB, modifier flags) read from this. */\n  getChromeState(): ChromeState;\n  /**\n   * Everything publishing an in-flight preview for this view, in resolution\n   * order: tool-side first (hotkey → active → registry → ambient), then the\n   * handles in flight on this view's dispatcher. Readers take the first\n   * non-null answer per id.\n   *\n   * A ghost layer must read this off its draw envelope rather than close over\n   * a dispatcher: one layer array paints every view, so a closure ghosts view\n   * zero's drag into every panel.\n   */\n  getPreviewSources(): readonly GesturePreviewSource[];\n  /** Overlay shapes this view's in-flight handles publish — marquee, lasso,\n   *  insert preview, raw commands. Same envelope rule as\n   *  {@link CanvasViewHelpers.getPreviewSources}. */\n  getGestureOverlays(): readonly OngoingOverlay[];\n  /**\n   * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and\n   * affordances call it per element to decide whether to draw / hit-test.\n   *\n   * The rule table is the surface's; the context it resolves against is this\n   * view's selection, camera and in-flight action — so the predicate belongs\n   * here rather than on {@link CanvasSurfaceHelpers}. Unwired, it is the\n   * universal `() => true`.\n   */\n  getIsVisible(): (id: string) => boolean;\n}\n\n/**\n * The half of {@link CanvasHelpers} that belongs to the surface — one GL\n * context, one debug sink, however many views are drawn on it.\n */\nexport interface CanvasSurfaceHelpers {\n  /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that\n   *  want to participate in `hitboxes`/`bounds`/etc. visualization can\n   *  call into this from their `draw` callback. Returns `null` when\n   *  debug is off — no-op for production renders. */\n  getDebug(): DebugSink | null;\n}\n\n/** Live overlay-aware lookups exposed to custom layers via `helpersRef`.\n *  What a layer receives as its `data` argument, unchanged: the two halves\n *  are split so a per-view set can be built independently of the surface's,\n *  not to make layers ask for one. */\nexport interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {\n  /**\n   * The view this draw is for: a `<CanvasView>` id, or `null` for the\n   * surface's own camera. One layer array paints every view, so a layer that\n   * belongs in some views and not others — a minimap's indicator — declines\n   * the rest by this id.\n   */\n  readonly viewId: string | null;\n}\n\nexport interface UseViewHelpersOpts<TPose> {\n  /** Only `getPose` is read here — the narrow slice keeps this hook off the\n   *  full adapter contract. */\n  adapter: { getPose(id: string): TPose } | undefined;\n  geometry: PoseDescriptor<TPose>;\n  /** Consumer-supplied bounds resolver. Falls back to the adapter's pose. */\n  boundsOf: ((id: string) => Bounds | null) | undefined;\n  /** Bounds of `id` drawn at an in-flight `pose`. Falls back to the\n   *  geometry's box of that pose, which is wrong wherever the surface draws a\n   *  node somewhere its pose does not say — a parallax plane. */\n  boundsOfPose?: ((id: string, pose: TPose) => Bounds | null) | undefined;\n  selection: readonly NodeId[];\n  tools: ToolsApi | undefined;\n  gestureSource: GestureSource | undefined;\n  /** Dispatcher-published preview overlays, read through a ref so a change\n   *  mid-gesture doesn't rebuild the memos that depend on them. */\n  previewPoseExtra: ((id: string) => unknown) | undefined;\n  previewIdsExtra: (() => Iterable<string> | null) | undefined;\n  /** Chrome-caps predicate for this view. Absent means everything is visible. */\n  getIsVisible?: (() => (id: string) => boolean) | undefined;\n}\n\nexport interface ViewHelpersBundle<TPose> {\n  helpers: CanvasViewHelpers<TPose>;\n  chromeState: ChromeState;\n  /** Committed pose straight from the adapter, no overlay applied. */\n  committedPoseOf(id: string): TPose | null;\n  /** Bounds resolver after the `boundsOf` / adapter fallback, before previews. */\n  effectiveBoundsOf: ((id: string) => Bounds | null) | undefined;\n  previewToolPose(id: string): TPose | null;\n  previewToolBounds(id: string): Bounds | null;\n  /** Live dispatcher preview extras, for callers outside this bundle. */\n  previewExtraRef: React.MutableRefObject<{\n    previewPoseExtra: ((id: string) => unknown) | undefined;\n    previewIdsExtra: (() => Iterable<string> | null) | undefined;\n  }>;\n}\n\n/**\n * Build one view's overlay-aware state: its chrome and the lookups its layers\n * draw and hit-test against.\n *\n * This is a hook, so it runs once per component. That is the point — N views\n * cannot be a loop inside one component, but they can be N components each\n * calling this once.\n */\n/** The composed pose when the adapter resolves one, its stored pose otherwise.\n *  Adapters predating `getWorldPose` are absolute-pose, where the two agree. */\nfunction worldPoseOf<TPose>(\n  adapter: { getPose(id: string): TPose; getWorldPose?(id: string): TPose },\n  id: string,\n): TPose {\n  return typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id);\n}\n\nexport function useViewHelpers<TPose>(\n  opts: UseViewHelpersOpts<TPose>,\n): ViewHelpersBundle<TPose> {\n  const {\n    adapter, geometry, boundsOf, boundsOfPose, selection, tools, gestureSource,\n    previewPoseExtra, previewIdsExtra, getIsVisible,\n  } = opts;\n  const boxOf = useCallback(\n    (id: string, pose: TPose): Bounds | null =>\n      (boundsOfPose ? boundsOfPose(id, pose) : geometry.getBounds(pose)),\n    [boundsOfPose, geometry],\n  );\n\n  const baseBoundsOf = useMemo(() => {\n    if (boundsOf) return boundsOf;\n    if (!adapter) return undefined;\n    return (id: string): Bounds | null => {\n      try {\n        // World: chrome is drawn over the picture, so it has to agree with\n        // where the renderer put the node, not with where its pose is stored.\n        const pose = worldPoseOf(adapter, id);\n        const b = geometry.getBounds(pose);\n        const rot = geometry.getRotation?.(pose);\n        return rot ? { ...b, rotation: rot } : b;\n      } catch {\n        return null;\n      }\n    };\n  }, [boundsOf, adapter, geometry]);\n\n  const committedPoseOf = useCallback((id: string): TPose | null => {\n    if (!adapter) return null;\n    try {\n      return worldPoseOf(adapter, id);\n    } catch {\n      return null;\n    }\n  }, [adapter]);\n\n  const multiActive = selection.length > 1;\n\n  const previewExtraRef = useLatest({ previewPoseExtra, previewIdsExtra });\n\n  const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);\n\n  // The live overlay a gesture proposes for `id`: the active tool's published\n  // preview first, then the dispatcher's preview extras. `null` when nothing\n  // is mid-gesture — callers fall through to committed state.\n  const previewToolPose = useCallback((id: string): TPose | null => {\n    if (tools) {\n      const p = firstPreviewPose(tools, id);\n      if (p != null) return p as TPose;\n    }\n    const extra = previewExtraRef.current.previewPoseExtra;\n    if (extra) {\n      const p = extra(id);\n      if (p != null) return p as TPose;\n    }\n    return null;\n  }, [tools, previewExtraRef]);\n  const previewToolBounds = useCallback((id: string): Bounds | null => {\n    if (tools) {\n      const b = firstPreviewBounds(tools, id);\n      if (b) return b;\n      const p = firstPreviewPose(tools, id);\n      if (p != null) return boxOf(id, p as TPose);\n    }\n    const extra = previewExtraRef.current.previewPoseExtra;\n    if (extra) {\n      const p = extra(id);\n      if (p != null) return boxOf(id, p as TPose);\n    }\n    return null;\n  }, [tools, boxOf, previewExtraRef]);\n\n  /**\n   * Bounds for `id` with any in-flight gesture folded in — what the user can\n   * see, not what is committed. Both the chrome state and the layer helpers\n   * answer bounds questions with this, so resize handles cannot end up a frame\n   * away from the shape they belong to.\n   */\n  const boundsWithPreview = useCallback((id: string): Bounds | null => {\n    const previewed = previewToolBounds(id);\n    if (previewed) return previewed;\n    return effectiveBoundsOf ? effectiveBoundsOf(id) : null;\n  }, [previewToolBounds, effectiveBoundsOf]);\n\n  const chromeState: ChromeState = useMemo(\n    () => buildChromeState({\n      selection,\n      multiActive,\n      effectiveBoundsOf: boundsWithPreview,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      // Rotation-capability predicate. Reads the committed pose (gestures\n      // don't change descriptor capability) and asks the geometry. Absent\n      // adapter / unknown ids fall back to `true` so the affordance stays\n      // visible — preserves pre-existing behavior for consumers that wire\n      // bounds without an adapter.\n      canRotate: (id) => {\n        if (!geometry.supportsRotation) return true;\n        const pose = committedPoseOf(id);\n        if (pose == null) return true;\n        return geometry.supportsRotation(pose);\n      },\n    }),\n    [selection, multiActive, boundsWithPreview, geometry, committedPoseOf],\n  );\n\n  const helpers: CanvasViewHelpers<TPose> = {\n    getEffectivePose: (id: string): TPose | null => {\n      const tp = previewToolPose(id);\n      if (tp != null) return tp;\n      return committedPoseOf(id);\n    },\n    getEffectiveBounds: boundsWithPreview,\n    getGestureBounds: (): Bounds | null => {\n      // In-flight ids come from both preview sources the ghost layer walks:\n      // tool-published `previewIds()` and the dispatcher's in-flight handles\n      // (via `gestureSource.ids()`). Using the same sets keeps this from\n      // disagreeing with what the user sees ghosted.\n      const ids = aggregatePreviewIds(tools);\n      const extraIds = gestureSource?.ids();\n      if (extraIds) for (const id of extraIds) ids.add(id);\n\n      const parts: (Bounds | null)[] = [];\n      for (const id of ids) parts.push(previewToolBounds(id));\n      // Nascent inserts have no id to look up — they arrive as ready-made\n      // world AABBs.\n      const extraBounds = gestureSource?.bounds();\n      if (extraBounds) for (const b of extraBounds) parts.push(b);\n      return unionAABB(parts);\n    },\n    subscribeGestures: (fn: () => void): (() => void) =>\n      gestureSource?.subscribe(fn) ?? noOpUnsubscribe,\n    getGestureVersion: (): number => gestureSource?.getVersion() ?? 0,\n    getChromeState: () => chromeState,\n    getPreviewSources: (): readonly GesturePreviewSource[] => [\n      ...toolPreviewSources(tools),\n      ...(gestureSource?.previewSources() ?? []),\n    ],\n    getGestureOverlays: (): readonly OngoingOverlay[] => gestureSource?.overlays() ?? [],\n    getIsVisible: (): ((id: string) => boolean) => getIsVisible?.() ?? alwaysVisible,\n  };\n\n  return {\n    helpers,\n    chromeState,\n    committedPoseOf,\n    effectiveBoundsOf,\n    previewToolPose,\n    previewToolBounds,\n    previewExtraRef,\n  };\n}\n"],"mappings":";;;;;;AAaA,IAAMA,UAA8B,CAAC,GAE/BC,UAA+B;AAgLrC,SAASC,EACP,GACA,GACO;CACP,OAAO,OAAOC,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaC,CAAE,IAAID,EAAQ,QAAQC,CAAE;AACnG;AAEA,SAAgBC,EACd,GAC0B;CAC1B,IAAM,EACJ,YAAS,aAAU,aAAU,iBAAc,cAAW,UAAO,kBAC7D,qBAAkB,oBAAiB,oBACjCC,GACEC,IAAQC,GACX,GAAY,MACVC,IAAeA,EAAaL,GAAIM,CAAI,IAAIC,EAAS,UAAUD,CAAI,GAClE,CAACD,GAAcE,CAAQ,CACzB,GAEMC,IAAeC,QAAc;EACjC,IAAIC,GAAU,OAAOA;EACrB,IAAKX,GACL,QAAQ,MAA8B;GACpC,IAAI;IAGF,IAAMO,IAAOR,EAAYC,GAASC,CAAE,GAC9BW,IAAIJ,EAAS,UAAUD,CAAI,GAC3BM,IAAML,EAAS,cAAcD,CAAI;IACvC,OAAOM,IAAM;KAAE,GAAGD;KAAG,UAAUC;IAAI,IAAID;GACzC,QAAQ;IACN,OAAO;GACT;EACF;CACF,GAAG;EAACD;EAAUX;EAASQ;CAAQ,CAAC,GAE1BM,IAAkBT,GAAa,MAA6B;EAChE,IAAI,CAACL,GAAS,OAAO;EACrB,IAAI;GACF,OAAOD,EAAYC,GAASC,CAAE;EAChC,QAAQ;GACN,OAAO;EACT;CACF,GAAG,CAACD,CAAO,CAAC,GAENe,IAAcC,EAAU,SAAS,GAEjCC,IAAkBC,EAAU;EAAE;EAAkB;CAAgB,CAAC,GAEjEC,IAAoBT,QAAcC,KAAYF,GAAc,CAACE,GAAUF,CAAY,CAAC,GAKpFW,IAAkBf,GAAa,MAA6B;EAChE,IAAIgB,GAAO;GACT,IAAMC,IAAIC,EAAiBF,GAAOpB,CAAE;GACpC,IAAIqB,KAAK,MAAM,OAAOA;EACxB;EACA,IAAME,IAAQP,EAAgB,QAAQ;EACtC,IAAIO,GAAO;GACT,IAAMF,IAAIE,EAAMvB,CAAE;GAClB,IAAIqB,KAAK,MAAM,OAAOA;EACxB;EACA,OAAO;CACT,GAAG,CAACD,GAAOJ,CAAe,CAAC,GACrBQ,IAAoBpB,GAAa,MAA8B;EACnE,IAAIgB,GAAO;GACT,IAAMT,IAAIc,EAAmBL,GAAOpB,CAAE;GACtC,IAAIW,GAAG,OAAOA;GACd,IAAMU,IAAIC,EAAiBF,GAAOpB,CAAE;GACpC,IAAIqB,KAAK,MAAM,OAAOlB,EAAMH,GAAIqB,CAAU;EAC5C;EACA,IAAME,IAAQP,EAAgB,QAAQ;EACtC,IAAIO,GAAO;GACT,IAAMF,IAAIE,EAAMvB,CAAE;GAClB,IAAIqB,KAAK,MAAM,OAAOlB,EAAMH,GAAIqB,CAAU;EAC5C;EACA,OAAO;CACT,GAAG;EAACD;EAAOjB;EAAOa;CAAe,CAAC,GAQ5BU,IAAoBtB,GAAa,MACnBoB,EAAkBxB,CAChC,MACGkB,IAAoBA,EAAkBlB,CAAE,IAAI,OAClD,CAACwB,GAAmBN,CAAiB,CAAC,GAEnCS,IAA2BlB,QACzBmB,EAAiB;EACrB;EACA;EACA,mBAAmBF;EACnB,WAAW;GAAE,KAAK;GAAO,OAAO;GAAO,MAAM;GAAO,MAAM;EAAM;EAMhE,YAAY,MAAO;GACjB,IAAI,CAACnB,EAAS,kBAAkB,OAAO;GACvC,IAAMD,IAAOO,EAAgBb,CAAE;GAE/B,OADIM,KAAQ,QACLC,EAAS,iBAAiBD,CAAI;EACvC;CACF,CAAC,GACD;EAACS;EAAWD;EAAaY;EAAmBnB;EAAUM;CAAe,CACvE;CAsCA,OAAO;EACL,SAAA;GApCA,mBAAmB,MACNM,EAAgBnB,CACvB,KACGa,EAAgBb,CAAE;GAE3B,oBAAoB0B;GACpB,wBAAuC;IAKrC,IAAMG,IAAMC,EAAoBV,CAAK,GAC/BW,IAAWC,GAAe,IAAI;IACpC,IAAID,GAAU,KAAK,IAAM/B,KAAM+B,GAAU,EAAI,IAAI/B,CAAE;IAEnD,IAAMiC,IAA2B,CAAC;IAClC,KAAK,IAAMjC,KAAM6B,GAAK,EAAM,KAAKL,EAAkBxB,CAAE,CAAC;IAGtD,IAAMkC,IAAcF,GAAe,OAAO;IAC1C,IAAIE,GAAa,KAAK,IAAMvB,KAAKuB,GAAa,EAAM,KAAKvB,CAAC;IAC1D,OAAOwB,EAAUF,CAAK;GACxB;GACA,oBAAoB,MAClBD,GAAe,UAAUI,CAAE,KAAKxC;GAClC,yBAAiCoC,GAAe,WAAW,KAAK;GAChE,sBAAsBL;GACtB,yBAA0D,CACxD,GAAGU,EAAmBjB,CAAK,GAC3B,GAAIY,GAAe,eAAe,KAAK,CAAC,CAC1C;GACA,0BAAqDA,GAAe,SAAS,KAAK,CAAC;GACnF,oBAA+CM,IAAe,KAAKzC;EAInE;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF"}
+{"version":3,"file":"useViewHelpers.js","names":["noOpUnsubscribe","alwaysVisible","worldPoseOf","adapter","id","useViewHelpers","opts","boxOf","useCallback","boundsOfPose","pose","framedBounds","geometry","baseBoundsOf","useMemo","boundsOf","committedPoseOf","multiActive","selection","previewPoseExtraRef","useLatest","previewPoseExtra","effectiveBoundsOf","previewPoseOf","previewBoundsOf","p","boundsWithPreview","chromeState","buildChromeState","parts","gestureSource","extraBounds","b","unionAABB","fn","getIsVisible"],"sources":["../../src/canvas/useViewHelpers.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { useLatest } from '@weasel-js/react';\nimport type { GestureSource, GesturePreviewSource } from './gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { buildChromeState, type ChromeState } from 'core/selection/chromeState';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { NodeId } from 'core/scene/types';\nimport type { DebugSink } from '../debug/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nconst noOpUnsubscribe = (): void => {};\n\nconst alwaysVisible = (): boolean => true;\n\n/**\n * The half of {@link CanvasHelpers} that belongs to one view — everything\n * answered by a camera's own tools, gestures and selection. A canvas hosting\n * several viewports needs one of these per view; the surface half is shared.\n */\nexport interface CanvasViewHelpers<TPose> {\n  /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,\n   *  otherwise the committed pose from the adapter. Returns `null` if the id\n   *  isn't known. */\n  getEffectivePose(id: string): TPose | null;\n  /** Overlay-aware bounds for `id`. */\n  getEffectiveBounds(id: string): Bounds | null;\n  /**\n   * World-space AABB of everything the in-flight gesture proposes — the\n   * displaced poses of nodes being moved / resized / rotated / cloned, plus\n   * any nascent insert that has no scene node yet. `null` when no gesture is\n   * in flight.\n   *\n   * This reports the *gesture*, not the document: committed content the\n   * gesture isn't touching is excluded. Select-only gestures are excluded\n   * too: a marquee or lasso has geometry but proposes no content.\n   *\n   * The result is a plain AABB — never rotated. Rotated parts are folded in\n   * by their rotated extent.\n   */\n  getGestureBounds(): Bounds | null;\n  /**\n   * Subscribe to the gesture layer's change signal, for everything on this\n   * object that moves during a drag (`getEffectivePose`, `getEffectiveBounds`,\n   * `getGestureBounds`). Returns an unsubscribe.\n   *\n   * Fires once per dispatcher pump: gesture start, every pointermove that\n   * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing\n   * actions. It fires on the pump, not on a diff: a pump that changed nothing\n   * observable still notifies, so don't hang expensive work directly off the\n   * callback.\n   *\n   * It does **not** cover committed scene edits (subscribe to the scene for\n   * those) or previews a consumer's own tool publishes from React state.\n   * Without a gesture source wired — a bare `<Canvas>` — it never fires.\n   */\n  subscribeGestures(fn: () => void): () => void;\n  /**\n   * Monotonic counter bumped on exactly the events `subscribeGestures` fires\n   * on. Pair the two for `useSyncExternalStore`:\n   *\n   * ```ts\n   * const gestureVersion = useSyncExternalStore(\n   *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),\n   *   () => helpersRef.current?.getGestureVersion() ?? 0,\n   * );\n   * ```\n   *\n   * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with\n   * no gesture source reports, forever.\n   */\n  getGestureVersion(): number;\n  /** The live ChromeState built once per render: overlay-aware selection\n   *  state for affordances and custom layers. */\n  getChromeState(): ChromeState;\n  /**\n   * Everything publishing an in-flight preview for this view: the handles in\n   * flight on its dispatcher, in dispatch order. Readers take the first\n   * non-null answer per id.\n   *\n   * A ghost layer must read this off its draw envelope rather than close over\n   * a dispatcher: one layer array paints every view, so a closure ghosts view\n   * zero's drag into every panel.\n   */\n  getPreviewSources(): readonly GesturePreviewSource[];\n  /** Overlay shapes this view's in-flight handles publish — marquee, lasso,\n   *  insert preview, raw commands. Same envelope rule as\n   *  {@link CanvasViewHelpers.getPreviewSources}. */\n  getGestureOverlays(): readonly OngoingOverlay[];\n  /**\n   * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and\n   * affordances call it per element to decide whether to draw / hit-test.\n   * Unwired, it is the universal `() => true`.\n   */\n  getIsVisible(): (id: string) => boolean;\n}\n\n/**\n * The half of {@link CanvasHelpers} that belongs to the surface — one GL\n * context, one debug sink, however many views are drawn on it.\n */\nexport interface CanvasSurfaceHelpers {\n  /** Active debug sink, when `<Canvas debug=...>` is enabled, for layers to\n   *  call from their `draw` callback. `null` when debug is off. */\n  getDebug(): DebugSink | null;\n}\n\n/** Live overlay-aware lookups exposed to custom layers via `helpersRef`, and\n *  what a layer receives as its `data` argument. */\nexport interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {\n  /**\n   * The view this draw is for: a `<CanvasView>` id, or `null` for the\n   * surface's own camera. One layer array paints every view, so a layer that\n   * belongs in some views and not others — a minimap's indicator — declines\n   * the rest by this id.\n   */\n  readonly viewId: string | null;\n}\n\n/** What a view's pose and bounds lookups read of an adapter. */\nexport interface ViewPoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. An adapter\n   *  without it stores absolute poses, where the two agree. */\n  getWorldPose?(id: string): TPose;\n}\n\nexport interface UseViewHelpersOpts<TPose> {\n  adapter: ViewPoseAdapter<TPose> | undefined;\n  geometry: PoseDescriptor<TPose>;\n  /** Consumer-supplied bounds resolver. Falls back to the adapter's pose. */\n  boundsOf: ((id: string) => Bounds | null) | undefined;\n  /** Bounds of `id` drawn at an in-flight `pose`. Falls back to the\n   *  geometry's box of that pose, which is wrong wherever the surface draws a\n   *  node somewhere its pose does not say — a parallax plane. */\n  boundsOfPose?: ((id: string, pose: TPose) => Bounds | null) | undefined;\n  selection: readonly NodeId[];\n  gestureSource: GestureSource | undefined;\n  /** The dispatcher's preview pose for an id, read through a ref so a change\n   *  mid-gesture doesn't rebuild the memos that depend on it. */\n  previewPoseExtra: ((id: string) => unknown) | undefined;\n  /** Chrome-caps predicate for this view. Absent means everything is visible. */\n  getIsVisible?: (() => (id: string) => boolean) | undefined;\n}\n\nexport interface ViewHelpersBundle<TPose> {\n  helpers: CanvasViewHelpers<TPose>;\n  chromeState: ChromeState;\n}\n\nfunction worldPoseOf<TPose>(adapter: ViewPoseAdapter<TPose>, id: string): TPose {\n  return typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id);\n}\n\n/**\n * Build one view's overlay-aware state: its chrome and the lookups its layers\n * draw and hit-test against. A canvas with N views mounts N components each\n * calling this once.\n */\nexport function useViewHelpers<TPose>(\n  opts: UseViewHelpersOpts<TPose>,\n): ViewHelpersBundle<TPose> {\n  const {\n    adapter, geometry, boundsOf, boundsOfPose, selection, gestureSource,\n    previewPoseExtra, getIsVisible,\n  } = opts;\n  const boxOf = useCallback(\n    (id: string, pose: TPose): Bounds | null =>\n      (boundsOfPose ? boundsOfPose(id, pose) : framedBounds(pose, geometry)),\n    [boundsOfPose, geometry],\n  );\n\n  const baseBoundsOf = useMemo(() => {\n    if (boundsOf) return boundsOf;\n    if (!adapter) return undefined;\n    return (id: string): Bounds | null => {\n      try {\n        // World: chrome is drawn over the picture, so it has to agree with\n        // where the renderer put the node, not with where its pose is stored.\n        return framedBounds(worldPoseOf(adapter, id), geometry);\n      } catch {\n        return null;\n      }\n    };\n  }, [boundsOf, adapter, geometry]);\n\n  const committedPoseOf = useCallback((id: string): TPose | null => {\n    if (!adapter) return null;\n    try {\n      return worldPoseOf(adapter, id);\n    } catch {\n      return null;\n    }\n  }, [adapter]);\n\n  const multiActive = selection.length > 1;\n\n  const previewPoseExtraRef = useLatest(previewPoseExtra);\n\n  const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);\n\n  const previewPoseOf = useCallback((id: string): TPose | null => {\n    const p = previewPoseExtraRef.current?.(id);\n    return p != null ? (p as TPose) : null;\n  }, [previewPoseExtraRef]);\n  const previewBoundsOf = useCallback((id: string): Bounds | null => {\n    const p = previewPoseOf(id);\n    return p != null ? boxOf(id, p) : null;\n  }, [previewPoseOf, boxOf]);\n\n  /**\n   * Bounds for `id` with any in-flight gesture folded in — what the user can\n   * see, not what is committed. Both the chrome state and the layer helpers\n   * answer bounds questions with this, so resize handles cannot end up a frame\n   * away from the shape they belong to.\n   */\n  const boundsWithPreview = useCallback((id: string): Bounds | null => {\n    const previewed = previewBoundsOf(id);\n    if (previewed) return previewed;\n    return effectiveBoundsOf ? effectiveBoundsOf(id) : null;\n  }, [previewBoundsOf, effectiveBoundsOf]);\n\n  const chromeState: ChromeState = useMemo(\n    () => buildChromeState({\n      selection,\n      multiActive,\n      effectiveBoundsOf: boundsWithPreview,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      // Absent adapter / unknown ids fall back to `true` so the affordance\n      // stays visible for consumers that wire bounds without an adapter.\n      canRotate: (id) => {\n        if (!geometry.supportsRotation) return true;\n        const pose = committedPoseOf(id);\n        if (pose == null) return true;\n        return geometry.supportsRotation(pose);\n      },\n    }),\n    [selection, multiActive, boundsWithPreview, geometry, committedPoseOf],\n  );\n\n  const helpers: CanvasViewHelpers<TPose> = {\n    getEffectivePose: (id: string): TPose | null => {\n      return previewPoseOf(id) ?? committedPoseOf(id);\n    },\n    getEffectiveBounds: boundsWithPreview,\n    getGestureBounds: (): Bounds | null => {\n      // The same id sets the ghost layer walks, so this cannot disagree with\n      // what the user sees ghosted.\n      const parts: (Bounds | null)[] = [];\n      for (const id of new Set(gestureSource?.ids() ?? [])) parts.push(previewBoundsOf(id));\n      const extraBounds = gestureSource?.bounds();\n      if (extraBounds) for (const b of extraBounds) parts.push(b);\n      return unionAABB(parts);\n    },\n    subscribeGestures: (fn: () => void): (() => void) =>\n      gestureSource?.subscribe(fn) ?? noOpUnsubscribe,\n    getGestureVersion: (): number => gestureSource?.getVersion() ?? 0,\n    getChromeState: () => chromeState,\n    getPreviewSources: (): readonly GesturePreviewSource[] => gestureSource?.previewSources() ?? [],\n    getGestureOverlays: (): readonly OngoingOverlay[] => gestureSource?.overlays() ?? [],\n    getIsVisible: (): ((id: string) => boolean) => getIsVisible?.() ?? alwaysVisible,\n  };\n\n  return { helpers, chromeState };\n}\n"],"mappings":";;;;;;AAYA,IAAMA,UAA8B,CAAC,GAE/BC,UAA+B;AAyIrC,SAASC,EAAmB,GAAiC,GAAmB;CAC9E,OAAO,OAAOC,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaC,CAAE,IAAID,EAAQ,QAAQC,CAAE;AACnG;AAOA,SAAgBC,EACd,GAC0B;CAC1B,IAAM,EACJ,YAAS,aAAU,aAAU,iBAAc,cAAW,kBACtD,qBAAkB,oBAChBC,GACEC,IAAQC,GACX,GAAY,MACVC,IAAeA,EAAaL,GAAIM,CAAI,IAAIC,EAAaD,GAAME,CAAQ,GACtE,CAACH,GAAcG,CAAQ,CACzB,GAEMC,IAAeC,QAAc;EACjC,IAAIC,GAAU,OAAOA;EACrB,IAAKZ,GACL,QAAQ,MAA8B;GACpC,IAAI;IAGF,OAAOQ,EAAaT,EAAYC,GAASC,CAAE,GAAGQ,CAAQ;GACxD,QAAQ;IACN,OAAO;GACT;EACF;CACF,GAAG;EAACG;EAAUZ;EAASS;CAAQ,CAAC,GAE1BI,IAAkBR,GAAa,MAA6B;EAChE,IAAI,CAACL,GAAS,OAAO;EACrB,IAAI;GACF,OAAOD,EAAYC,GAASC,CAAE;EAChC,QAAQ;GACN,OAAO;EACT;CACF,GAAG,CAACD,CAAO,CAAC,GAENc,IAAcC,EAAU,SAAS,GAEjCC,IAAsBC,EAAUC,CAAgB,GAEhDC,IAAoBR,QAAcC,KAAYF,GAAc,CAACE,GAAUF,CAAY,CAAC,GAEpFU,IAAgBf,GAAa,MACvBW,EAAoB,UAAUf,CAAE,KACR,MACjC,CAACe,CAAmB,CAAC,GAClBK,IAAkBhB,GAAa,MAA8B;EACjE,IAAMiB,IAAIF,EAAcnB,CAAE;EAC1B,OAAOqB,KAAK,OAAsB,OAAflB,EAAMH,GAAIqB,CAAC;CAChC,GAAG,CAACF,GAAehB,CAAK,CAAC,GAQnBmB,IAAoBlB,GAAa,MACnBgB,EAAgBpB,CAC9B,MACGkB,IAAoBA,EAAkBlB,CAAE,IAAI,OAClD,CAACoB,GAAiBF,CAAiB,CAAC,GAEjCK,IAA2Bb,QACzBc,EAAiB;EACrB;EACA;EACA,mBAAmBF;EACnB,WAAW;GAAE,KAAK;GAAO,OAAO;GAAO,MAAM;GAAO,MAAM;EAAM;EAGhE,YAAY,MAAO;GACjB,IAAI,CAACd,EAAS,kBAAkB,OAAO;GACvC,IAAMF,IAAOM,EAAgBZ,CAAE;GAE/B,OADIM,KAAQ,QACLE,EAAS,iBAAiBF,CAAI;EACvC;CACF,CAAC,GACD;EAACQ;EAAWD;EAAaS;EAAmBd;EAAUI;CAAe,CACvE;CAyBA,OAAO;EAAE,SAAA;GAtBP,mBAAmB,MACVO,EAAcnB,CAAE,KAAKY,EAAgBZ,CAAE;GAEhD,oBAAoBsB;GACpB,wBAAuC;IAGrC,IAAMG,IAA2B,CAAC;IAClC,KAAK,IAAMzB,KAAM,IAAI,IAAI0B,GAAe,IAAI,KAAK,CAAC,CAAC,GAAG,EAAM,KAAKN,EAAgBpB,CAAE,CAAC;IACpF,IAAM2B,IAAcD,GAAe,OAAO;IAC1C,IAAIC,GAAa,KAAK,IAAMC,KAAKD,GAAa,EAAM,KAAKC,CAAC;IAC1D,OAAOC,EAAUJ,CAAK;GACxB;GACA,oBAAoB,MAClBC,GAAe,UAAUI,CAAE,KAAKlC;GAClC,yBAAiC8B,GAAe,WAAW,KAAK;GAChE,sBAAsBH;GACtB,yBAA0DG,GAAe,eAAe,KAAK,CAAC;GAC9F,0BAAqDA,GAAe,SAAS,KAAK,CAAC;GACnF,oBAA+CK,IAAe,KAAKlC;EAG5D;EAAS;CAAY;AAChC"}

package/dist/canvas/viewInputs.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewInputs.js","names":["ViewInputsContext","createContext","ViewInputsProvider","useOptionalViewInputs","useContext"],"sources":["../../src/canvas/viewInputs.tsx"],"sourcesContent":["/**\n * What {@link useViewHelpers} needs that belongs to the surface rather than to\n * one view: the adapter, the geometry, the bounds resolver and the tools.\n *\n * These are read during a view's render, so they travel as context rather than\n * on the `SurfaceHandle`, which is not attached until an effect runs.\n */\nimport { createContext, useContext, type ReactNode } from 'react';\nimport type { UseViewHelpersOpts } from './useViewHelpers';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { NodeId } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type { PickView } from './SceneCanvas/useSceneSelectTool';\n\n/**\n * The part of a chrome-caps rule context that belongs to one view. Everything\n * else a `RuleCtx` carries — mode, capabilities, device, focus — is the\n * surface's and the same for every view drawn on it.\n */\nexport interface ViewRuleInputs {\n  selection: readonly NodeId[];\n  view: View;\n  /** What that view's dispatcher currently has in flight. */\n  action: { kind: string | null; id: string | null };\n}\n\n/**\n * @internal Provided by the surface, consumed by `<CanvasView>`.\n *\n * The scene-shaped half only. What a gesture is doing right now is read from\n * the asking view's own dispatcher, not from here.\n */\nexport interface SurfaceViewInputs\n  extends Pick<UseViewHelpersOpts<unknown>, 'adapter' | 'geometry' | 'tools'> {\n  /** A node's box for chrome, drawn under `view` — the camera of the view\n   *  asking, since a node on a parallax plane lands somewhere else in each. */\n  boundsOf: ((id: string, view?: View | null) => Bounds | null) | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through,\n   *  or null when its layer moves with the camera. */\n  planeOfNode?: ((id: string, view?: View | null) => PlaneMap | null) | undefined;\n  /** `boundsOf` for `id` drawn at an in-flight `pose`, under `view`. */\n  boundsOfPose?: ((id: string, pose: unknown, view?: View | null) => Bounds | null) | undefined;\n  /** Every id under a world point, bottom-first. `view` is the view the\n   *  point was produced under — a screen-pixel tolerance cannot be converted\n   *  without its scale, nor a layer judged without its paint, and the world\n   *  point carries neither. */\n  pickEvery?: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** The one id a click resolves to, collapsing parent/child the way the\n   *  select tool does. Falls back to `pickEvery`'s last when absent. */\n  pickBest?: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** A hit node's routing-trait kind, so `target: 'kind:text'` bindings match. */\n  kindOfNode?: (id: string) => string | undefined;\n  /**\n   * The surface's chrome-caps rule table, evaluated against a view's own\n   * context. The rules are surface-wide on purpose — one consumer table, one\n   * set of kit defaults — but a rule keyed on selection, camera or the\n   * in-flight action answers differently per view, so the caller supplies the\n   * context and both the paint gate and the dispatcher's eligibility filter\n   * read the same one.\n   */\n  chromeCaps?: {\n    /** `undefined` when the surface gates nothing — no mode registry wired,\n     *  which is what `<SceneCanvas>` reports for its own view too. */\n    ruleCtx(inputs: ViewRuleInputs): RuleCtx | undefined;\n    isVisible(inputs: ViewRuleInputs): (id: string) => boolean;\n  };\n  /** The surface's selection, which a view shares unless it was given one of\n   *  its own. */\n  selectionApi: SelectionApi;\n  /** The rotate badge the surface's selection overlay paints, which every\n   *  view drawing that overlay has to make grabbable where it is drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n}\n\nconst ViewInputsContext = createContext<SurfaceViewInputs | null>(null);\n\n/** @internal */\nexport function ViewInputsProvider(\n  { value, children }: { value: SurfaceViewInputs; children: ReactNode },\n) {\n  return <ViewInputsContext.Provider value={value}>{children}</ViewInputsContext.Provider>;\n}\n\n/** The hosting surface's view-helper inputs, or `null` outside one. */\nexport function useOptionalViewInputs(): SurfaceViewInputs | null {\n  return useContext(ViewInputsContext);\n}\n"],"mappings":";;;AA6EA,IAAMA,IAAoBC,EAAwC,IAAI;AAGtE,SAAgBC,EACd,EAAE,UAAO,eACT;CACA,OAAO,kBAACF,EAAkB,UAAnB;EAAmC;EAAQ;CAAqC,CAAA;AACzF;AAGA,SAAgBG,IAAkD;CAChE,OAAOC,EAAWJ,CAAiB;AACrC"}
+{"version":3,"file":"viewInputs.js","names":["ViewInputsContext","createContext","ViewInputsProvider","useOptionalViewInputs","useContext"],"sources":["../../src/canvas/viewInputs.tsx"],"sourcesContent":["/**\n * What {@link useViewHelpers} needs that belongs to the surface rather than to\n * one view: the adapter, the geometry and the bounds resolver.\n *\n * These are read during a view's render, so they travel as context rather than\n * on the `SurfaceHandle`, which is not attached until an effect runs.\n */\nimport { createContext, useContext, type ReactNode } from 'react';\nimport type { UseViewHelpersOpts } from './useViewHelpers';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { ChromeCaps } from 'features/chrome-caps/useChromeCaps';\nimport type { PickView } from './SceneCanvas/useSceneSelectTool';\n\nexport type { ViewRuleInputs } from 'features/chrome-caps/useChromeCaps';\n\n/**\n * @internal Provided by the surface, consumed by `<CanvasView>`.\n *\n * The scene-shaped half only. What a gesture is doing right now is read from\n * the asking view's own dispatcher, not from here.\n */\nexport interface SurfaceViewInputs\n  extends Pick<UseViewHelpersOpts<unknown>, 'adapter' | 'geometry'> {\n  /** A node's box for chrome, drawn under `view` — the camera of the view\n   *  asking, since a node on a parallax plane lands somewhere else in each. */\n  boundsOf: ((id: string, view?: View | null) => Bounds | null) | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through,\n   *  or null when its layer moves with the camera. */\n  planeOfNode?: ((id: string, view?: View | null) => PlaneMap | null) | undefined;\n  /** `boundsOf` for `id` drawn at an in-flight `pose`, under `view`. */\n  boundsOfPose?: ((id: string, pose: unknown, view?: View | null) => Bounds | null) | undefined;\n  /** Every id under a world point, bottom-first. `view` is the view the\n   *  point was produced under — a screen-pixel tolerance cannot be converted\n   *  without its scale, nor a layer judged without its paint, and the world\n   *  point carries neither. */\n  pickEvery?: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** The one id a click resolves to, collapsing parent/child the way the\n   *  select tool does. Falls back to `pickEvery`'s last when absent. */\n  pickBest?: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** A hit node's routing-trait kind, so `target: 'kind:text'` bindings match. */\n  kindOfNode?: (id: string) => string | undefined;\n  /** The surface's chrome-caps rule table, evaluated against a view's own\n   *  context. */\n  chromeCaps?: ChromeCaps;\n  /** The surface's selection, which a view shares unless it was given one of\n   *  its own. */\n  selectionApi: SelectionApi;\n  /** The rotate badge the surface's selection overlay paints, which every\n   *  view drawing that overlay has to make grabbable where it is drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n}\n\nconst ViewInputsContext = createContext<SurfaceViewInputs | null>(null);\n\n/** @internal */\nexport function ViewInputsProvider(\n  { value, children }: { value: SurfaceViewInputs; children: ReactNode },\n) {\n  return <ViewInputsContext.Provider value={value}>{children}</ViewInputsContext.Provider>;\n}\n\n/** The hosting surface's view-helper inputs, or `null` outside one. */\nexport function useOptionalViewInputs(): SurfaceViewInputs | null {\n  return useContext(ViewInputsContext);\n}\n"],"mappings":";;;AAuDA,IAAMA,IAAoBC,EAAwC,IAAI;AAGtE,SAAgBC,EACd,EAAE,UAAO,eACT;CACA,OAAO,kBAACF,EAAkB,UAAnB;EAAmC;EAAQ;CAAqC,CAAA;AACzF;AAGA,SAAgBG,IAAkD;CAChE,OAAOC,EAAWJ,CAAiB;AACrC"}