@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/Canvas.js

@@ -1,318 +1,201 @@
-import { drawLayers as e, isLayerPainted as t } from "../core/layers/render.js";
-import { createBackgroundFillLayer as n } from "../core/layers/backgroundFill.js";
-import { clientToWorld as r } from "../core/viewport/clientToWorld.js";
-import { AUTO_POSE_DESCRIPTOR as i } from "../core/geometry/autoPoseDescriptor.js";
-import { useViewHelpers as a } from "./useViewHelpers.js";
-import { useOptionalViewRegistry as o } from "./viewRegistry.js";
-import { shaderKeyOf as s } from "./canvasRenderer.js";
-import { useCanvasSurface as c } from "./useCanvasSurface.js";
-import { SurfaceCanvas as ee } from "./SurfaceCanvas.js";
-import { isCustomEntry as l } from "./layerSlots.js";
-import { composeOrderedLayers as u, placeToolOverlays as d } from "./layerOrder.js";
-import { registerMountedCanvas as f } from "./mountedCanvases.js";
-import { useSurfaceInput as te } from "./useSurfaceInput.js";
-import { beginDebugFrame as ne, useDebugSink as re } from "../debug/useDebugSink.js";
-import { useToolCursor as ie } from "./useToolCursor.js";
-import { createPaintedCursorLayer as p } from "./paintedCursorLayer.js";
-import { viewToMat3 as ae } from "@weasel-js/renderer";
-import { forwardRef as m, useCallback as h, useEffect as g, useImperativeHandle as oe, useInsertionEffect as _, useLayoutEffect as v, useMemo as y, useRef as b, useState as se, useSyncExternalStore as ce } from "react";
-import { useLatest as x } from "@weasel-js/react";
-import { jsx as le } from "react/jsx-runtime";
-import { createCursorSink as ue, createPaintedCursorState as de } from "@weasel-js/cursor";
+import { AUTO_POSE_DESCRIPTOR } from "../core/geometry/autoPoseDescriptor.js";
+import { useViewHelpers } from "./useViewHelpers.js";
+import { useOptionalViewRegistry } from "./viewRegistry.js";
+import { useCanvasSurface } from "./useCanvasSurface.js";
+import { SurfaceCanvas } from "./SurfaceCanvas.js";
+import { useSurfaceSize } from "./useSurfaceSize.js";
+import { registerMountedCanvas } from "./mountedCanvases.js";
+import { useViewLayerGate } from "./useViewLayerGate.js";
+import { useSurfaceInput } from "./useSurfaceInput.js";
+import { useDebugSink } from "../debug/useDebugSink.js";
+import { useToolCursor } from "./useToolCursor.js";
+import { useCanvasElements } from "./useCanvasElements.js";
+import { alwaysVisible, useExtraLayers } from "./useExtraLayers.js";
+import { usePaintedCursor } from "./usePaintedCursor.js";
+import { useCanvasHandle } from "./useCanvasHandle.js";
+import { useComposedLayers, useSlotLayers } from "./useLayerStack.js";
+import { useViewRegistrySurface } from "./useViewRegistrySurface.js";
+import { useCanvasPaint, usePaintedVersion } from "./useCanvasPaint.js";
+import { layerHover } from "./layerHover.js";
+import { useClientToWorld } from "./useClientToWorld.js";
+import { forwardRef, useCallback, useEffect, useInsertionEffect, useLayoutEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+import { jsx } from "react/jsx-runtime";
+
 //#region src/canvas/Canvas.tsx
-var fe = (e) => !0, pe = [], me = {};
-function he(m, he) {
-	let { width: S, height: C, dpr: w, flattenTolerance: ge, contentVersion: _e, syncPaint: ve = !1, redrawOn: ye, adapter: be, layers: T, selection: xe, boundsOf: Se, boundsOfPose: Ce, clientToWorld: we, paintInto: E, inputElement: D, poseDescriptor: Te = i, className: Ee, style: De, tabIndex: Oe = 0, onFocus: ke, onBlur: Ae, autoFocusOnPointerDown: je = !0, helpersRef: Me, tools: O, viewState: Ne, debug: Pe, debugSinkRef: Fe, shaders: k, previewPoseExtra: Ie, gestureSource: Le, backgroundFill: A, decorationLayer: j, getIsVisible: Re, layerVisibility: M, layerOrder: N, layerGroups: ze } = m, { sink: P, overlay: F, frameStats: Be, getDebug: Ve } = re(Pe), I = b(null), L = b(null), He = h((e) => {
-		L.current = e, I.current = e;
-	}, []), R = !!E;
-	_(() => {
-		R && (I.current = D ?? null);
+/**
+* Low-level WebGL surface + viewport primitive. Composes layers into a single GL render pass,
+* applies a view transform, and delivers hover to the layers that ask for it. It routes no
+* gesture: `<SceneCanvas>` mounts the gesture dispatcher on this same element. Canvas owns NO
+* scene-shaped state — selection, picking, kind registry, scene-aware overlays all live in
+* `<SceneCanvas>`, which wraps it.
+*
+* The `layers` prop is a map keyed by slot name, every slot already a layer. Standard slots
+* render at a canonical position; custom entries (any other key, value carrying `.layer`) insert
+* at `after`/`before` an existing slot, defaulting to the top.
+*
+* @internal
+* @deprecated Bare `<Canvas>` is not a supported consumer surface.
+*   Use `<SceneCanvas>` instead.
+*/
+var NO_SELECTION = [];
+function CanvasInner(props, ref) {
+	const { paintInto, inputElement, tools, viewState, style, getIsVisible, layerVisibility, layerOrder, helpersRef, debugSinkRef, poseDescriptor: geometry = AUTO_POSE_DESCRIPTOR } = props;
+	const { sink: debugSink, overlay: debugOverlay, frameStats, getDebug } = useDebugSink(props.debug);
+	const elements = useCanvasElements(paintInto, inputElement);
+	const { canvasRef, ownCanvasRef, detached } = elements;
+	const { width, height } = useSurfaceSize(props, ownCanvasRef);
+	const helpersForLayersRef = useRef(null);
+	const dimsRef = useLatest({
+		width,
+		height
+	});
+	const gateRef = useLatest({
+		getIsVisible,
+		layerVisibility,
+		layerOrder
+	});
+	const paintRef = useRef(() => false);
+	const { lease, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume } = useCanvasSurface(useCallback(() => paintRef.current(), []), {
+		syncPaint: props.syncPaint ?? false,
+		target: canvasRef,
+		dpr: props.dpr,
+		redrawOn: props.redrawOn,
+		shaders: props.shaders,
+		onCommit: "redraw"
 	});
-	let Ue = R ? E.canvas ?? null : null, We = x(Ue), Ge = R ? {
-		x: E.x,
-		y: E.y
-	} : null, z = x(Ge), B = b(null), V = x({
-		width: S,
-		height: C
-	}), H = x({
-		getIsVisible: Re,
-		layerVisibility: M,
-		layerOrder: N
-	}), Ke = b(() => !1), { lease: qe, requestRedraw: U, subscribeFrame: Je, subscribeBeforePaint: Ye, subscribeResume: Xe } = c(h(() => Ke.current(), []), {
-		syncPaint: ve,
-		target: I,
-		dpr: w,
-		redrawOn: ye,
-		shaders: k
-	}), Ze = x(_e), Qe = b(0), $e = h(() => Qe.current, []), [et, tt] = se(0), W = b(/* @__PURE__ */ new Set()), nt = h((e) => (W.current.add(e), tt((e) => e + 1), () => {
-		W.current.delete(e), tt((e) => e + 1);
-	}), []), G = h((e, n, r, i, a, o) => {
-		let s = [...W.current].reverse(), c = H.current, ee = c.getIsVisible?.() ?? fe, l = c.layerVisibility ?? me, u = c.layerOrder;
-		for (let c of s) {
-			if (!c.hitTest || o && !o.includes(c) || !t(c, l, u)) continue;
-			let s = c.hitTest(e, n, a, r, i, ee);
-			if (s) return {
-				layerId: c.id,
-				hit: s
-			};
-		}
-		return null;
-	}, [H]), { viewRef: K, controlled: q, setView: rt, getView: J, subscribeView: it, adoptControlled: at, announceControlled: ot, clearSubscribers: st } = Ne, ct = h((e, t, n) => G(e, t, n?.view ?? K.current, n?.dims ?? V.current, B.current), [
-		G,
-		V,
-		K
-	]), lt = x(we), Y = h((e, t) => {
-		let n = I.current;
-		if (!n) return [e, t];
-		let i = lt.current;
-		return i ? i(n, e, t) : r(e, t, n.getBoundingClientRect(), K.current);
-	}, [lt, K]);
-	v(() => {
-		let e = I.current;
-		if (e) return f({
-			element: e,
-			getView: J
+	const { getPaintedVersion, markPainted } = usePaintedVersion(props.contentVersion);
+	const { extrasRef, extrasVersion, registerLayer, hitTestExtrasIn } = useExtraLayers(gateRef);
+	const { viewRef, setView, getView, subscribeView, adoptControlled, announceControlled, clearSubscribers } = viewState;
+	const toWorld = useClientToWorld(canvasRef, props.clientToWorld, viewRef);
+	useLayoutEffect(() => {
+		const element = canvasRef.current;
+		if (!element) return;
+		return registerMountedCanvas({
+			element,
+			getView
 		});
 	}, [
-		R,
-		D,
-		J
+		canvasRef,
+		detached,
+		inputElement,
+		getView
 	]);
-	let X = y(() => de(), []), ut = y(() => p(X), [X]);
-	g(() => X.subscribe(() => {
-		U();
-	}), [X, U]);
-	let dt = y(() => ue({
-		element: () => I.current,
-		painted: () => X
-	}), [X]), ft = h(() => {
-		let e = z.current, { width: t, height: n } = V.current;
-		return {
-			x: e?.x ?? 0,
-			y: e?.y ?? 0,
-			width: t,
-			height: n
-		};
-	}, [V, z]);
-	oe(he, () => ({
-		element: R ? D ?? null : I.current,
-		surface: R ? E?.canvas ?? null : L.current,
-		getSurfaceRect: ft,
-		clientToWorld: Y,
-		requestRedraw: U,
-		subscribeFrame: Je,
-		subscribeBeforePaint: Ye,
-		subscribeResume: Xe,
-		registerLayer: nt,
-		hitTestExtras: ct,
-		getView: J,
-		setView: rt,
-		subscribeView: it,
-		getPaintedVersion: $e,
-		paintedCursor: X,
-		cursorSink: dt,
-		getDebug: Ve
-	}), [
-		I,
-		L,
-		R,
-		D,
-		E?.canvas,
-		ft,
-		Y,
-		U,
-		Je,
-		Ye,
-		Xe,
-		nt,
-		ct,
-		J,
-		rt,
-		it,
-		$e,
-		X,
-		dt,
-		Ve
-	]);
-	let pt = b(/* @__PURE__ */ new Map()), Z = o(), mt = xe?.current ?? pe, { helpers: ht, chromeState: gt } = a({
-		adapter: be,
-		geometry: Te,
-		boundsOf: Se,
-		boundsOfPose: Ce,
-		selection: mt,
-		gestureSource: Le,
-		previewPoseExtra: Ie,
-		getIsVisible: () => H.current.getIsVisible?.() ?? fe
-	}), _t = { getDebug: () => P }, vt = {
-		...ht,
-		..._t,
+	const { paintedCursor, paintedCursorLayer, cursorSink } = usePaintedCursor(canvasRef, requestRedraw);
+	const frame = {
+		viewRef,
+		dimsRef,
+		helpersRef: helpersForLayersRef
+	};
+	useCanvasHandle(ref, {
+		...elements,
+		inputElement,
+		paintCanvas: paintInto?.canvas
+	}, frame, {
+		hitTestExtrasIn,
+		clientToWorld: toWorld,
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume,
+		registerLayer,
+		getView,
+		setView,
+		subscribeView,
+		getPaintedVersion,
+		paintedCursor,
+		cursorSink,
+		getDebug
+	});
+	const viewRegistry = useOptionalViewRegistry();
+	const layers = useSlotLayers(props.layers, tools, props.backgroundFill, props.decorationLayer);
+	const { helpers: viewHelpers } = useViewHelpers({
+		adapter: props.adapter,
+		geometry,
+		boundsOf: props.boundsOf,
+		boundsOfPose: props.boundsOfPose,
+		nodes: props.nodes,
+		gestureSource: props.gestureSource,
+		previewPoseExtra: props.previewPoseExtra,
+		getScale: () => viewRef.current.scale,
+		selection: props.selection?.current ?? NO_SELECTION,
+		getIsVisible: () => gateRef.current.getIsVisible?.() ?? alwaysVisible,
+		layerIsPainted: useViewLayerGate(layerVisibility, layerOrder, () => layers)
+	});
+	const helpersForLayers = {
+		...viewHelpers,
+		getDebug: () => debugSink,
 		viewId: null
-	}, yt = y(() => A ? n(A) : void 0, [A]), Q = y(() => {
-		let e = {};
-		for (let t of [
-			"grid",
-			"cellHighlight",
-			"selectionOverlay"
-		]) {
-			let n = T[t];
-			l(n) && (e[t] = n.layer);
-		}
-		let t = u(j ? {
-			...T,
-			decorationLayer: { layer: j }
-		} : T, e, T.scene?.layers, yt);
-		return O && d(t, e.selectionOverlay, O.getActiveOverlays), t;
-	}, [
-		T,
-		O,
-		yt,
-		j
-	]), bt = ce(h((e) => Z?.subscribe(e) ?? (() => {}), [Z]), () => Z?.getVersion() ?? 0, () => 0), xt = x(Q);
-	g(() => Z?.attachSurface({
-		view: () => K.current,
-		dims: () => V.current,
-		layers: () => xt.current,
-		requestRedraw: U,
-		chromeState: () => B.current.getChromeState(),
-		hitTestExtras: G,
-		clientToWorld: Y,
-		claimsAbove: (e, t) => {
-			let n = K.current, r = e / n.scale.x + n.x, i = t / n.scale.y + n.y;
-			return G(r, i, n, V.current, B.current) !== null;
-		}
-	}), [
-		Z,
-		I,
-		U,
-		G,
-		V,
-		xt,
-		K,
-		Y
-	]);
-	let $ = y(() => {
-		let e = Z ? [...Q, ...Z.list().filter((e) => e.paint).map((e) => e.layer)] : Q;
-		return [
-			...F ? [...e, F] : e,
-			...W.current,
-			ut
-		];
-	}, [
-		Q,
-		F,
-		et,
-		Z,
-		bt,
-		ut
-	]);
-	g(() => {
-		let e = () => {
-			U();
-		}, t = [];
-		for (let n of $) n.subscribe && t.push(n.subscribe(e));
-		return () => {
-			for (let e of t) e();
-		};
-	}, [$, U]);
-	let St = s(k), Ct = x({
-		layers: $,
-		width: S,
-		height: C,
-		debugSink: P,
-		frameStats: Be,
-		dpr: w,
-		layerGroups: ze,
-		shaders: k,
-		flattenTolerance: ge
+	};
+	useViewRegistrySurface(viewRegistry, layers, frame, {
+		requestRedraw,
+		hitTestExtrasIn,
+		clientToWorld: toWorld
 	});
-	_(() => {
-		at(), B.current = vt, Me && (Me.current = vt), Fe && (Fe.current = P);
-	}), v(() => {
-		ot();
+	const layersWithDebug = useComposedLayers(layers, {
+		viewRegistry,
+		debugOverlay,
+		extrasRef,
+		extrasVersion,
+		cursorLayer: paintedCursorLayer
+	}, requestRedraw);
+	const paintInputsRef = useLatest({
+		layers: layersWithDebug,
+		width,
+		height,
+		debugSink,
+		frameStats,
+		dpr: props.dpr,
+		layerGroups: props.layerGroups,
+		shaders: props.shaders,
+		flattenTolerance: props.flattenTolerance,
+		retain: props.retain
 	});
-	let wt = h(() => {
-		let t = We.current ?? L.current;
-		if (!t) return !1;
-		let n = z.current, { layers: r, width: i, height: a, debugSink: o, frameStats: s, dpr: c, flattenTolerance: ee, layerGroups: l, shaders: u } = Ct.current, d = ne(o, s, r), f = qe.bind(t, {
-			width: i,
-			height: a,
-			dpr: c
-		}, {
-			tile: n,
-			flattenTolerance: ee,
-			shaders: u
-		});
-		if (!f) return !1;
-		let te = K.current, { layerVisibility: re, layerOrder: ie } = H.current, p = d?.time(), m = e(r, B.current, re ?? me, ie, te, {
-			width: i,
-			height: a
-		}, pt.current, void 0, l, p);
-		return f.render(m, ae(te), p ? { spans: p } : void 0), d?.end(f.lastFrameStats()), Qe.current = Ze.current?.() ?? 0, !0;
-	}, [
-		Ze,
-		H,
-		qe,
-		Ct,
-		z,
-		We,
-		K
-	]);
-	return _(() => {
-		Ke.current = wt;
-	}), v(() => {
-		U();
-	}, [
-		$,
-		S,
-		C,
-		P,
-		w,
-		ge,
-		q?.x,
-		q?.y,
-		q?.scale.x,
-		q?.scale.y,
-		M,
-		N,
-		ze,
-		St,
-		ve,
-		gt,
-		Re,
-		Ue,
-		Ge?.x,
-		Ge?.y,
-		U
-	]), g(() => {
-		let e = pt.current;
-		return () => {
-			e.clear(), st();
-		};
-	}, [st]), ie(dt, O, R ? D : null, De?.cursor), te(I, {
-		focusOnPress: je,
-		onFocus: ke,
-		onBlur: Ae,
-		onHover: (e, n) => {
-			let r = K.current, [i, a] = Y(n.clientX, n.clientY), o = M ?? me;
-			for (let e of $) e.onUncapturedMove && t(e, o, N) && e.onUncapturedMove(i, a, n, r, {
-				width: S,
-				height: C
-			});
-		},
-		onLeave: () => {
-			for (let e of $) e.onUncapturedLeave?.();
-		}
-	}), R ? null : /* @__PURE__ */ le(ee, {
-		ref: He,
-		width: S,
-		height: C,
-		tabIndex: Oe,
-		className: Ee,
-		style: De
+	useInsertionEffect(() => {
+		adoptControlled();
+		helpersForLayersRef.current = helpersForLayers;
+		if (helpersRef) helpersRef.current = helpersForLayers;
+		if (debugSinkRef) debugSinkRef.current = debugSink;
+	});
+	useLayoutEffect(() => {
+		announceControlled();
+	});
+	useCanvasPaint(paintRef, lease, elements, {
+		...frame,
+		inputsRef: paintInputsRef,
+		gateRef
+	}, markPainted);
+	useEffect(() => clearSubscribers, [clearSubscribers]);
+	useToolCursor(cursorSink, tools, detached ? inputElement : null, style?.cursor);
+	useSurfaceInput(canvasRef, {
+		focusOnPress: props.autoFocusOnPointerDown ?? true,
+		onFocus: props.onFocus,
+		onBlur: props.onBlur,
+		...layerHover(layersWithDebug, {
+			viewRef,
+			toWorld,
+			layerVisibility,
+			layerOrder,
+			dims: {
+				width,
+				height
+			}
+		})
+	});
+	if (detached) return null;
+	return /* @__PURE__ */ jsx(SurfaceCanvas, {
+		ref: elements.setOwnCanvas,
+		width: props.width,
+		height: props.height,
+		tabIndex: props.tabIndex ?? 0,
+		className: props.className,
+		style
 	});
 }
-var S = m(he);
-//#endregion
-export { S as Canvas };
+/** Forward-ref'd `<canvas>` wrapper. Generic over the pose type, inferred from the
+*  `adapter` prop. */
+var Canvas = forwardRef(CanvasInner);
 
+//#endregion
+export { Canvas };
 //# sourceMappingURL=Canvas.js.map

package/dist/canvas/Canvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"Canvas.js","names":["clientToWorld","clientToWorldHelper","alwaysVisible","NO_SELECTION","NO_LAYER_VISIBILITY","CanvasInner","dprProp","layersMap","clientToWorld$1","geometry","AUTO_POSE_DESCRIPTOR","debugProp","props","debugSink","debugOverlay","useDebugSink","canvasRef","useRef","ownCanvasRef","setOwnCanvas","useCallback","el","detached","paintInto","inputElement","paintTarget","paintTargetRef","useLatest","paintRect","paintRectRef","helpersForLayersRef","dimsRef","gateRef","paintRef","useCanvasSurface","contentVersionRef","contentVersion","paintedVersionRef","getPaintedVersion","extrasVersion","setExtrasVersion","useState","extrasRef","registerLayer","layer","n","hitTestExtrasIn","layers","gate","isVisible","visibility","order","only","isLayerPainted","hit","worldX","worldY","data","view","dims","controlledView","viewState","hitTestExtras","frame","viewRef","clientToWorldRef","toWorld","clientX","clientY","override","clientToWorld","element","registerMountedCanvas","getView","paintedCursor","useMemo","createPaintedCursorState","paintedCursorLayer","createPaintedCursorLayer","requestRedraw","cursorSink","createCursorSink","getSurfaceRect","origin","w","h","ref","subscribeFrame","subscribeBeforePaint","subscribeResume","setView","subscribeView","getDebug","layerCacheRef","viewRegistry","useOptionalViewRegistry","selectedIdsForWiring","selection","viewHelpers","viewChromeState","useViewHelpers","surfaceHelpers","helpersForLayers","backgroundLayer","backgroundFill","createBackgroundFillLayer","standardLayers","slot","entry","isCustomEntry","out","composeOrderedLayers","decorationLayer","tools","placeToolOverlays","viewRegistryVersion","useSyncExternalStore","cb","surfaceLayersRef","x","y","layersWithDebug","withViews","r","redraw","offs","off","shaderIdKey","shaderKeyOf","shaders","paintInputsRef","useInsertionEffect","adoptControlled","helpersRef","debugSinkRef","useLayoutEffect","paint","c","rect","paintLayers","sink","timed","dprIn","paintFlattenTolerance","groups","paintShaders","debugFrame","beginDebugFrame","renderer","lease","vis","spans","commands","drawLayers","viewToMat3","width","height","flattenTolerance","layerVisibility","layerOrder","layerGroups","syncPaint","getIsVisible","useEffect","layerCache","clearSubscribers","useToolCursor","style","useSurfaceInput","autoFocusOnPointerDown","e","SurfaceCanvas","Canvas","forwardRef"],"sources":["../../src/canvas/Canvas.tsx"],"sourcesContent":["/**\n * Low-level WebGL surface + viewport primitive. Composes layers into a single GL render pass,\n * applies a view transform, and delivers hover to the layers that ask for it. It routes no\n * gesture: `<SceneCanvas>` mounts the gesture dispatcher on this same element. Canvas owns NO\n * scene-shaped state — selection, picking, kind registry, scene-aware overlays all live in\n * `<SceneCanvas>`, which wraps it.\n *\n * The `layers` prop is a map keyed by slot name, every slot already a layer. Standard slots\n * render at a canonical position; custom entries (any other key, value carrying `.layer`) insert\n * at `after`/`before` an existing slot, defaulting to the top.\n *\n * @internal\n * @deprecated Bare `<Canvas>` is not a supported consumer surface.\n *   Use `<SceneCanvas>` instead.\n */\n\nimport { forwardRef, useCallback, useEffect, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';\nimport type React from 'react';\nimport type { Paint } from '@weasel-js/paint';\nimport { composeOrderedLayers, placeToolOverlays } from './layerOrder';\nimport { STANDARD_SLOTS, isCustomEntry, type CanvasLayers } from './layerSlots';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport { registerMountedCanvas } from './mountedCanvases';\nimport type { GestureSource } from './gestureBounds';\nimport { useViewHelpers } from './useViewHelpers';\nimport { useSurfaceInput } from './useSurfaceInput';\nimport type { CanvasViewState } from './useCanvasView';\nimport { useOptionalViewRegistry } from './viewRegistry';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasHelpers, CanvasSurfaceHelpers, ViewPoseAdapter } from './useViewHelpers';\n\nimport { useLatest } from '@weasel-js/react';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld as clientToWorldHelper } from 'core/viewport/clientToWorld';\nimport {\n  drawLayers, isLayerPainted,\n  type Dims, type LayerCommandCache, type LayerGroup, type RedrawSource, type RenderLayer,\n} from 'core/layers/render';\nimport { viewToMat3, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { createBackgroundFillLayer } from 'core/layers/backgroundFill';\nimport { shaderKeyOf } from './canvasRenderer';\nimport { SurfaceCanvas } from './SurfaceCanvas';\nimport {\n  type SelectionApi,\n} from 'core/selection/useSelection';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { CanvasDebugSink, DebugConfig } from '../debug/types';\nimport { beginDebugFrame, useDebugSink } from '../debug/useDebugSink';\n\nconst alwaysVisible = (_id: string): boolean => true;\nimport { createCursorSink, createPaintedCursorState } from '@weasel-js/cursor';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\nimport { useToolCursor } from './useToolCursor';\nimport { createPaintedCursorLayer } from './paintedCursorLayer';\n\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/**\n * Props for `<Canvas>`. Canvas is scene-agnostic: it owns the GL surface, view state, hover\n * delivery, and slot composition, and not gesture dispatch, selection state, picking logic,\n * kind registries, or scene-aware overlays.\n */\nexport interface CanvasProps<TPose = unknown> {\n  /** CSS-pixel width. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n\n  /** Drawing-buffer density (device pixels per CSS pixel). When omitted the\n   *  canvas reads `window.devicePixelRatio` per paint. */\n  dpr?: number;\n\n  /** Flatness tolerance for curve tessellation, in world units. Forwarded to\n   *  `WeaselRendererOptions.flattenTolerance`. Leave unset for the cached\n   *  default (`DEFAULT_FLATTEN_TOLERANCE`, 0.5); a scene whose world unit is\n   *  not a pixel — feet, inches, millimetres — needs a value scaled to its\n   *  unit or sub-unit curves flatten to a handful of vertices. */\n  flattenTolerance?: number;\n\n  /** The version of whatever content this canvas draws, sampled at paint time\n   *  and reported by {@link CanvasExtensionApi.getPaintedVersion}.\n   *  `<SceneCanvas>` wires this to `scene.getVersion`. Chrome that must not\n   *  show DOM ahead of pixels compares the two and defers a frame. */\n  contentVersion?: () => number;\n\n  /** Paint inside the React commit rather than on the next animation frame.\n   *  Costs a synchronous paint per commit and per redraw request; buys\n   *  single-commit consistency between React-rendered DOM and canvas pixels.\n   *  For consumers with DOM chrome pinned to canvas content that cannot\n   *  tolerate a frame of skew. Live: toggling it switches modes from the next\n   *  redraw on. A redraw requested from inside a layer's `draw`, or from a\n   *  `subscribeFrame` callback, still waits for a frame — painting it in place\n   *  would recurse. */\n  syncPaint?: boolean;\n\n  /** External state the paint reads that no layer declares — typically what\n   *  an `alphaFor` consults. Each source is subscribed while mounted and\n   *  repaints the canvas when it notifies. A layer that reads outside state\n   *  declares it on `RenderLayer.subscribe` instead. */\n  redrawOn?: readonly RedrawSource[];\n\n  /** Adapter the pose and bounds lookups on `helpersRef` read. */\n  adapter?: ViewPoseAdapter<TPose>;\n\n  /** Layer map. See module docstring for slot semantics. */\n  layers: CanvasLayers;\n\n  /**\n   * Current selection state; Canvas owns none of its own and never writes it. When absent,\n   * Canvas behaves as if nothing is selected: no selection chrome.\n   */\n  selection?: SelectionApi;\n\n\n  /**\n   * How to read and rewrite a pose. Drives the default `boundsOf` fallback and the\n   * selection-overlay bounds. Defaults to the rect identity (`AUTO_POSE_DESCRIPTOR`); supply\n   * one for a non-rect pose type.\n   */\n  poseDescriptor?: PoseDescriptor<TPose>;\n\n  /**\n   * Override for committed bounds lookup, taking precedence over the `poseDescriptor`-derived\n   * fallback. Used by the selection overlay, the multi-select union AABB, and\n   * `helpersRef.getEffectiveBounds`.\n   */\n  boundsOf?: (id: string) => Bounds | null;\n  /** Bounds of `id` drawn at an in-flight pose — how chrome boxes a preview.\n   *  Defaults to the `poseDescriptor`'s box of that pose. */\n  boundsOfPose?: (id: string, pose: TPose) => Bounds | null;\n  /**\n   * Custom pointer-to-world coordinate transform, overriding the default canvas-rect\n   * calculation. Useful for consumers that apply an additional CSS transform to the canvas\n   * element.\n   */\n  clientToWorld?: (canvas: HTMLElement, cx: number, cy: number) => [number, number];\n\n  /**\n   * Paint into a caller-owned canvas at a rect on it, instead of an element\n   * this component creates. `x`/`y` are the rect's top-left in that canvas's\n   * CSS pixels; the rect's size is the existing `width`/`height` props.\n   *\n   * Requires `inputElement`: with no element of its own there is nowhere for\n   * pointer input, focus or the cursor to live, and nothing renders.\n   *\n   * N canvases can then share one GL context and one buffer.\n   */\n  paintInto?: { canvas: HTMLCanvasElement | null; x: number; y: number };\n  /**\n   * The element pointer input, focus and the cursor come from, and the element\n   * every client→world conversion measures. Only read alongside `paintInto`;\n   * an attached canvas uses the one it renders.\n   */\n  inputElement?: HTMLElement | null;\n\n  /** Class for the `<canvas>` this component renders. Under `paintInto` it\n   *  renders none, and the input element is the caller's to style. */\n  className?: string;\n  /** Inline style for the `<canvas>` this component renders; a tool's cursor\n   *  is merged over it. Not applied under `paintInto`, where only that cursor\n   *  is written, onto the input element. */\n  style?: React.CSSProperties;\n  /** Tab order of the `<canvas>` this component renders. Default 0, so the\n   *  canvas is focusable. Not applied under `paintInto`: whether the input\n   *  element can take focus is the caller's to decide. */\n  tabIndex?: number;\n  /** Fired when the element input comes from gains focus: the canvas, or\n   *  under `paintInto` the `inputElement`. Called with the DOM event. */\n  onFocus?: (event: FocusEvent) => void;\n  /** Fired when that element loses focus. */\n  onBlur?: (event: FocusEvent) => void;\n  /**\n   * When `true` (default), the canvas element receives focus on `pointerdown` so keyboard\n   * events are captured without a separate click-to-focus step. Set to `false` where\n   * auto-focus would steal focus from sibling inputs.\n   */\n  autoFocusOnPointerDown?: boolean;\n\n  /** The tool set. Canvas reads the active tool's cursor and its overlays;\n   *  it dispatches nothing to a tool. */\n  tools?: import('../tools/overlayBinding').ToolsApi;\n\n  /** The camera this surface looks through, from `useCanvasView`. Whoever\n   *  made it holds the view props; the surface adopts and announces a\n   *  controlled view among its own effects, and repaints when one moves. */\n  viewState: CanvasViewState;\n  /**\n   * Mutable ref Canvas writes overlay-aware pose/bounds lookups to on every render. Custom\n   * layers can read it from inside their `draw` closure to reflect in-flight gestures\n   * (move/resize/rotate) instead of the committed scene; an id outside the active overlay\n   * falls back to the adapter.\n   */\n  helpersRef?: React.MutableRefObject<CanvasHelpers<TPose> | null>;\n\n  /**\n   * Debug overlay configuration.\n   *  - `undefined` (default): read `?debug=…` from the URL.\n   *  - `false`: force off, ignore URL.\n   *  - `DebugConfig` object: force on with that config, ignore URL.\n   *\n   * When enabled, the Canvas appends a screen-space `debug-overlay` layer and builds the\n   * sink it paints: each paint records into it, and the layer helpers and the ref handle's\n   * `getDebug` hand it to whatever else records.\n   */\n  debug?: DebugConfig | false;\n\n  /** Test-only escape hatch: writes the live debug sink to this ref so tests\n   *  can call `snapshot()` after a render. No effect when debug is off. */\n  debugSinkRef?: React.MutableRefObject<CanvasDebugSink | null>;\n\n  /**\n   * Shader programs to compile before the frame that first draws them; one\n   * not named here compiles on that frame. Each handle comes from a\n   * module-level `registerProgram()`. The array is read at each paint and\n   * registered again when its ids change, so a handle added after mount is\n   * picked up. Re-registering one of these ids with new source repaints the\n   * canvas, and the renderer recompiles it for that frame.\n   */\n  shaders?: ShaderProgramHandle[];\n\n  /**\n   * Preview-pose lookup, so selection chrome tracks the ghost during dispatcher-driven\n   * drags. Returns `null` / `undefined` when no preview is in flight.\n   */\n  previewPoseExtra?: (id: string) => unknown;\n\n  /**\n   * In-flight gesture state `<Canvas>` can't see for itself. Backs the `getGestureBounds` /\n   * `subscribeGestures` / `getGestureVersion` trio on `helpersRef`. Unwired, those three\n   * report \"no gesture in flight\" and never fire.\n   */\n  gestureSource?: GestureSource;\n\n  /**\n   * Fill for the full canvas surface, drawn as a screen-space layer beneath every other\n   * layer, the grid and anything anchored before it included — independent of pan / zoom.\n   */\n  backgroundFill?: Paint;\n\n  /**\n   * Mode-owned decoration layer (e.g. path-edit anchor dots). Composed as a `decorationLayer`\n   * entry in `layers` with no anchor, which this prop replaces: it paints above every slot\n   * and every other custom layer, and beneath a tool's `'top'` overlays. A tool's\n   * selection-anchored overlays sit beneath it too while there is selection chrome to anchor\n   * them; with that slot empty they fall to the tail and paint above it.\n   */\n  decorationLayer?: RenderLayer<unknown>;\n\n  /**\n   * Chrome-caps visibility resolver. Exposed on `helpersForLayers.getIsVisible` so custom\n   * layers (notably `composeAffordanceLayer`) can gate paint by chrome id, and threaded into\n   * hit-testing so the same gate applies there. Called fresh per draw / per hitTest. Omit to\n   * leave every chrome element visible.\n   */\n  getIsVisible?: () => (id: string) => boolean;\n\n  /**\n   * Show or hide whole render layers by id. An id absent from the map falls\n   * back to the layer's own `defaultVisible`, and a layer marked `alwaysOn`\n   * ignores the map entirely.\n   *\n   * Hiding a layer also stops it claiming pointer events through\n   * `hitTestExtras` — a layer nobody can see must not swallow a click.\n   *\n   * This is `getIsVisible`'s coarser sibling: that one gates individual\n   * chrome elements *within* a layer, this one gates the layer.\n   */\n  layerVisibility?: Record<string, boolean>;\n\n  /**\n   * Draw order, by layer id, bottom first. Omit for the order the layers\n   * arrive in.\n   *\n   * **A listed order is the whole list:** any layer whose id is missing from\n   * it is not drawn. Reordering two layers means naming all of them.\n   */\n  layerOrder?: string[];\n\n  /**\n   * Runs of consecutive layers that composite as one — the surface for blurring the world\n   * while the chrome above it stays sharp. Members are named by layer id. See\n   * {@link LayerGroup}.\n   */\n  layerGroups?: readonly LayerGroup[];\n}\n\n\nconst NO_SELECTION: SelectionApi['current'] = [];\n\nconst NO_LAYER_VISIBILITY: Record<string, boolean> = {};\n\nfunction CanvasInner<TPose>(\n  props: CanvasProps<TPose>,\n  ref: React.ForwardedRef<CanvasExtensionApi>,\n) {\n  const {\n    width,\n    height,\n    dpr: dprProp,\n    flattenTolerance,\n    contentVersion,\n    syncPaint = false,\n    redrawOn,\n    adapter,\n    layers: layersMap,\n    selection,\n    boundsOf,\n    boundsOfPose,\n    clientToWorld,\n    paintInto,\n    inputElement,\n    poseDescriptor: geometry = AUTO_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>,\n    className,\n    style,\n    tabIndex = 0,\n    onFocus,\n    onBlur,\n    autoFocusOnPointerDown = true,\n    helpersRef,\n    tools,\n    viewState,\n    debug: debugProp,\n    debugSinkRef,\n    shaders,\n    previewPoseExtra,\n    gestureSource,\n    backgroundFill,\n    decorationLayer,\n    getIsVisible,\n    layerVisibility,\n    layerOrder,\n    layerGroups,\n  } = props;\n\n  const { sink: debugSink, overlay: debugOverlay, frameStats, getDebug } = useDebugSink(debugProp);\n\n  // The element input comes from and every client→world conversion measures: the `<canvas>`\n  // this component renders, or under `paintInto` the caller's `inputElement`.\n  const canvasRef = useRef<HTMLElement | null>(null);\n  // The `<canvas>` this component rendered, if it rendered one. `paint` is the\n  // only thing that needs a real canvas, for `getContext`.\n  const ownCanvasRef = useRef<HTMLCanvasElement | null>(null);\n  // Stable, so a commit does not detach the element: an inline ref is nulled\n  // until the layout phase reaches it, and a sync paint asked for before that\n  // finds no canvas.\n  const setOwnCanvas = useCallback((el: HTMLCanvasElement | null) => {\n    ownCanvasRef.current = el;\n    canvasRef.current = el;\n  }, []);\n  const detached = !!paintInto;\n  // The detached input element reaches `canvasRef` at commit; the own canvas\n  // arrives through `setOwnCanvas`, React's ref callback.\n  useInsertionEffect(() => {\n    if (detached) canvasRef.current = inputElement ?? null;\n  });\n  // Where pixels go. Split from `canvasRef` only when detached.\n  const paintTarget = detached ? (paintInto.canvas ?? null) : null;\n  const paintTargetRef = useLatest(paintTarget);\n  const paintRect = detached ? { x: paintInto.x, y: paintInto.y } : null;\n  const paintRectRef = useLatest(paintRect);\n\n  // Read by `hitTestExtras`, which is built once and must see live values.\n  const helpersForLayersRef = useRef<CanvasHelpers<TPose> | null>(null);\n  const dimsRef = useLatest({ width, height });\n  // Which layers reach the screen, and which chrome within them: asked by the\n  // paint and by every hit-test.\n  const gateRef = useLatest({ getIsVisible, layerVisibility, layerOrder });\n\n  // React does not drive the paint; the frame loop does. The thunk defers to\n  // `paint` below, which needs inputs this render has not computed yet.\n  const paintRef = useRef<() => boolean>(() => false);\n  const { lease, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume } = useCanvasSurface(\n    useCallback(() => paintRef.current(), []),\n    { syncPaint, target: canvasRef, dpr: dprProp, redrawOn, shaders },\n  );\n\n  const contentVersionRef = useLatest(contentVersion);\n  const paintedVersionRef = useRef(0);\n  const getPaintedVersion = useCallback(() => paintedVersionRef.current, []);\n\n  // The `layersWithDebug` memo reads `extrasRef.current`, so registration has\n  // to bump state to re-run it. Rare (a HUD attaching, a loupe mounting).\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  // Hit-test registered layers topmost-first: registration order is draw order, so the\n  // last-registered layer gets first refusal. `<SceneCanvas>` folds this into its\n  // `affordanceAt` thunk; Canvas has the layers but not the dispatcher.\n  const hitTestExtrasIn = useCallback((\n    worldX: number,\n    worldY: number,\n    view: View,\n    dims: Dims,\n    data: unknown,\n    only?: readonly RenderLayer<unknown>[],\n  ) => {\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  const {\n    viewRef, controlled: controlledView, setView, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  } = viewState;\n\n  const hitTestExtras = useCallback((\n    worldX: number,\n    worldY: number,\n    frame?: { view: View; dims: Dims },\n  ) => hitTestExtrasIn(\n    worldX,\n    worldY,\n    frame?.view ?? viewRef.current,\n    frame?.dims ?? dimsRef.current,\n    helpersForLayersRef.current,\n  ), [hitTestExtrasIn, dimsRef, viewRef]);\n\n  // The one client→world conversion: hover, the view registry and both\n  // handles answer with it, so a `clientToWorld` override reaches all of them\n  // or none.\n  const clientToWorldRef = useLatest(clientToWorld);\n  const toWorld = useCallback((clientX: number, clientY: number): [number, number] => {\n    const el = canvasRef.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  }, [clientToWorldRef, viewRef]);\n\n  useLayoutEffect(() => {\n    const element = canvasRef.current;\n    if (!element) return;\n    return registerMountedCanvas({ element, getView });\n  }, [detached, inputElement, getView]);\n\n  // The painted tier's channel. `<Canvas>` owns it because it owns both ends:\n  // the tool cursor that feeds it and the frame loop that has to repaint when\n  // it changes. The hover pump reaches it through the ref handle below.\n  const paintedCursor = useMemo<PaintedCursorState>(() => createPaintedCursorState(), []);\n  const paintedCursorLayer = useMemo(\n    () => createPaintedCursorLayer(paintedCursor),\n    [paintedCursor],\n  );\n  // An idle pointermove repaints nothing on its own, so a cursor the compositor\n  // is not drawing needs its own pump. The store stays quiet unless something\n  // painted is actually on screen.\n  useEffect(() => paintedCursor.subscribe(() => { requestRedraw(); }), [paintedCursor, requestRedraw]);\n  // The one writer of the input element's `cursor` style: the tool's cursor\n  // from here, a hover cursor from the pump, which reaches it through the handle.\n  const cursorSink = useMemo(\n    () => createCursorSink({ element: () => canvasRef.current, painted: () => paintedCursor }),\n    [paintedCursor],\n  );\n\n  const getSurfaceRect = useCallback(() => {\n    const origin = paintRectRef.current;\n    const { width: w, height: h } = dimsRef.current;\n    return { x: origin?.x ?? 0, y: origin?.y ?? 0, width: w, height: h };\n  }, [dimsRef, paintRectRef]);\n\n  useImperativeHandle(ref, () => ({\n    // Named rather than read off `canvasRef` so the handle rebuilds when a\n    // detached surface's input element arrives, which is a render later.\n    element: detached ? inputElement ?? null : canvasRef.current,\n    surface: detached ? paintInto?.canvas ?? null : ownCanvasRef.current,\n    getSurfaceRect,\n    clientToWorld: toWorld,\n    requestRedraw,\n    subscribeFrame,\n    subscribeBeforePaint,\n    subscribeResume,\n    registerLayer,\n    hitTestExtras,\n    getView,\n    setView,\n    subscribeView,\n    getPaintedVersion,\n    paintedCursor,\n    cursorSink,\n    getDebug,\n  }), [canvasRef, ownCanvasRef, detached, inputElement, paintInto?.canvas,\n       getSurfaceRect, toWorld, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume,\n       registerLayer,\n       hitTestExtras, getView, setView, subscribeView, getPaintedVersion,\n       paintedCursor, cursorSink, getDebug]);\n\n  const layerCacheRef = useRef<LayerCommandCache>(new Map());\n\n  // Views registered on this surface — declared as `views` descriptors or\n  // mounted as `<CanvasView>` children. Null outside a surface that mounts a\n  // registry, which is the single-view case.\n  const viewRegistry = useOptionalViewRegistry();\n\n  const selectedIdsForWiring = selection?.current ?? NO_SELECTION;\n\n  // One view's overlay-aware state. A hook, so N views are N components each\n  // calling it once — not a loop in this body.\n  const { helpers: viewHelpers, chromeState: viewChromeState } = useViewHelpers<TPose>({\n    adapter,\n    geometry,\n    boundsOf,\n    boundsOfPose,\n    selection: selectedIdsForWiring,\n    gestureSource,\n    previewPoseExtra,\n    getIsVisible: () => gateRef.current.getIsVisible?.() ?? alwaysVisible,\n  });\n\n  const surfaceHelpers: CanvasSurfaceHelpers = {\n    getDebug: () => debugSink,\n  };\n  const helpersForLayers: CanvasHelpers<TPose> = { ...viewHelpers, ...surfaceHelpers, viewId: null };\n\n  const backgroundLayer = useMemo(\n    () => (backgroundFill ? createBackgroundFillLayer(backgroundFill) : undefined),\n    [backgroundFill],\n  );\n\n  const layers = useMemo<RenderLayer<unknown>[]>(() => {\n    const standardLayers: Partial<\n      Record<(typeof STANDARD_SLOTS)[number], RenderLayer<unknown>>\n    > = {};\n    for (const slot of ['grid', 'cellHighlight', 'selectionOverlay'] as const) {\n      const entry = layersMap[slot];\n      if (isCustomEntry(entry)) standardLayers[slot] = entry.layer;\n    }\n    const out: RenderLayer<unknown>[] = composeOrderedLayers(\n      decorationLayer ? { ...layersMap, decorationLayer: { layer: decorationLayer } } : layersMap,\n      standardLayers, layersMap.scene?.layers, backgroundLayer,\n    );\n    if (tools) {\n      placeToolOverlays(out, standardLayers.selectionOverlay, tools.getActiveOverlays);\n    }\n    return out;\n  }, [layersMap, tools, backgroundLayer, decorationLayer]);\n\n  const viewRegistryVersion = useSyncExternalStore(\n    useCallback((cb: () => void) => viewRegistry?.subscribe(cb) ?? (() => {}), [viewRegistry]),\n    () => viewRegistry?.getVersion() ?? 0,\n    () => 0,\n  );\n\n  // The stack a view paints through its own camera is this canvas's, before\n  // the views themselves are folded in — otherwise a view would contain\n  // itself. Published by reference and read at draw time.\n  const surfaceLayersRef = useLatest<readonly RenderLayer<unknown>[]>(layers);\n  useEffect(() => {\n    return viewRegistry?.attachSurface({\n      view: () => viewRef.current,\n      dims: () => dimsRef.current,\n      layers: () => surfaceLayersRef.current,\n      requestRedraw,\n      chromeState: () => helpersForLayersRef.current!.getChromeState(),\n      hitTestExtras: hitTestExtrasIn,\n      clientToWorld: toWorld,\n      claimsAbove: (x, y) => {\n        const view = viewRef.current;\n        const worldX = x / view.scale.x + view.x;\n        const worldY = y / view.scale.y + view.y;\n        return hitTestExtrasIn(worldX, worldY, view, dimsRef.current, helpersForLayersRef.current) !== null;\n      },\n    });\n  }, [viewRegistry, canvasRef, requestRedraw, hitTestExtrasIn, dimsRef, surfaceLayersRef, viewRef, toWorld]);\n\n  const layersWithDebug = useMemo(() => {\n    // Views paint through the surface's own stack, so they sit above it and\n    // below both the debug overlay and externally-registered layers.\n    const withViews = viewRegistry\n      ? [...layers, ...viewRegistry.list().filter((r) => r.paint).map((r) => r.layer as RenderLayer<unknown>)]\n      : layers;\n    const base = debugOverlay ? [...withViews, debugOverlay] : withViews;\n    // The cursor goes last: it is the one thing that is always in front of\n    // everything, including a consumer's own registered layers.\n    return [...base, ...extrasRef.current, paintedCursorLayer];\n    // extrasVersion drives re-reads of extrasRef when layers are registered/detached;\n    // viewRegistryVersion does the same for registered views.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [layers, debugOverlay, extrasVersion, viewRegistry, viewRegistryVersion,\n      paintedCursorLayer]);\n\n  useEffect(() => {\n    const redraw = (): void => { requestRedraw(); };\n    const offs: (() => void)[] = [];\n    for (const layer of layersWithDebug) if (layer.subscribe) offs.push(layer.subscribe(redraw));\n    return () => { for (const off of offs) off(); };\n  }, [layersWithDebug, requestRedraw]);\n\n  const shaderIdKey = shaderKeyOf(shaders);\n\n  // Everything the paint, hit-testing and the view registry read that a React\n  // render owns. `useLatest` and the insertion effect below publish committed\n  // renders only, ahead of every layout effect in the commit, any of which may\n  // ask for a sync paint.\n  const paintInputs = {\n    layers: layersWithDebug, width, height, debugSink, frameStats,\n    dpr: dprProp, layerGroups, shaders,\n    flattenTolerance,\n  };\n  const paintInputsRef = useLatest(paintInputs);\n  useInsertionEffect(() => {\n    adoptControlled();\n    helpersForLayersRef.current = helpersForLayers;\n    if (helpersRef) helpersRef.current = helpersForLayers;\n    if (debugSinkRef) debugSinkRef.current = debugSink;\n  });\n  useLayoutEffect(() => {\n    announceControlled();\n  });\n\n  const paint = useCallback((): boolean => {\n    const c = paintTargetRef.current ?? ownCanvasRef.current;\n    if (!c) return false;\n    const rect = paintRectRef.current;\n    const {\n      layers: paintLayers, width: w, height: h, debugSink: sink, frameStats: timed,\n      dpr: dprIn,\n      flattenTolerance: paintFlattenTolerance,\n      layerGroups: groups, shaders: paintShaders,\n    } = paintInputsRef.current;\n\n    const debugFrame = beginDebugFrame(sink, timed, paintLayers);\n\n    const renderer = lease.bind(c, { width: w, height: h, dpr: dprIn }, {\n      tile: rect,\n      flattenTolerance: paintFlattenTolerance,\n      shaders: paintShaders,\n    });\n    // No WebGL2 (jsdom), or a context that is lost for now: nothing to paint.\n    if (!renderer) return false;\n\n    const view = viewRef.current;\n    const { layerVisibility: vis, layerOrder: order } = gateRef.current;\n    const spans = debugFrame?.time();\n    const commands = drawLayers(\n      paintLayers,\n      helpersForLayersRef.current,\n      vis ?? NO_LAYER_VISIBILITY,\n      order,\n      view,\n      { width: w, height: h },\n      layerCacheRef.current,\n      undefined,\n      groups,\n      spans,\n    );\n    renderer.render(commands, viewToMat3(view), spans ? { spans } : undefined);\n    debugFrame?.end(renderer.lastFrameStats());\n    paintedVersionRef.current = contentVersionRef.current?.() ?? 0;\n    return true;\n  }, [contentVersionRef, gateRef, lease, paintInputsRef, paintRectRef, paintTargetRef, viewRef]);\n  useInsertionEffect(() => {\n    paintRef.current = paint;\n  });\n\n  // A tripwire, not a list of values this effect uses: every paint input that\n  // arrives on a render must appear here, or changing it paints stale.\n  // `viewChromeState` stands in for the whole overlay-aware set the layer\n  // helpers expose — it re-memoizes on exactly the selection, bounds and\n  // preview inputs they read. What moves between renders instead (a scene\n  // write, a gesture pump, a late image decode) pushes its own redraw.\n  // Layout, not passive, so a `syncPaint` surface lands its pixels in the same\n  // commit as the DOM.\n  useLayoutEffect(() => {\n    requestRedraw();\n  }, [layersWithDebug, width, height, debugSink, dprProp, flattenTolerance,\n      controlledView?.x, controlledView?.y, controlledView?.scale.x, controlledView?.scale.y,\n      layerVisibility, layerOrder, layerGroups, shaderIdKey, syncPaint,\n      viewChromeState, getIsVisible, paintTarget, paintRect?.x, paintRect?.y, requestRedraw]);\n\n  useEffect(() => {\n    const layerCache = layerCacheRef.current;\n    return () => {\n      layerCache.clear();\n      clearSubscribers();\n    };\n  }, [clearSubscribers]);\n\n  useToolCursor(cursorSink, tools, detached ? inputElement : null, style?.cursor);\n\n  useSurfaceInput(canvasRef, {\n    focusOnPress: autoFocusOnPointerDown,\n    onFocus,\n    onBlur,\n    onHover: (_el, e) => {\n      const view = viewRef.current;\n      const [worldX, worldY] = toWorld(e.clientX, e.clientY);\n      const visibility = layerVisibility ?? NO_LAYER_VISIBILITY;\n      // Same gate as `hitTestExtrasIn`: a layer nobody can see takes no input.\n      for (const layer of layersWithDebug) {\n        if (!layer.onUncapturedMove || !isLayerPainted(layer, visibility, layerOrder)) continue;\n        layer.onUncapturedMove(worldX, worldY, e, view, { width, height });\n      }\n    },\n    onLeave: () => {\n      for (const layer of layersWithDebug) layer.onUncapturedLeave?.();\n    },\n  });\n\n  if (detached) return null;\n\n  return (\n    <SurfaceCanvas\n      ref={setOwnCanvas}\n      width={width}\n      height={height}\n      tabIndex={tabIndex}\n      className={className} style={style}\n    />\n  );\n}\n\n/** Forward-ref'd `<canvas>` wrapper. Generic over the pose type, inferred from the\n *  `adapter` prop. */\nexport const Canvas = forwardRef(CanvasInner) as <TPose = unknown>(\n  props: CanvasProps<TPose> & { ref?: React.ForwardedRef<CanvasExtensionApi> },\n) => ReturnType<typeof CanvasInner>;\n\n"],"mappings":"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"}
+{"version":3,"file":"Canvas.js","names":[],"sources":["../../src/canvas/Canvas.tsx"],"sourcesContent":["/**\n * Low-level WebGL surface + viewport primitive. Composes layers into a single GL render pass,\n * applies a view transform, and delivers hover to the layers that ask for it. It routes no\n * gesture: `<SceneCanvas>` mounts the gesture dispatcher on this same element. Canvas owns NO\n * scene-shaped state — selection, picking, kind registry, scene-aware overlays all live in\n * `<SceneCanvas>`, which wraps it.\n *\n * The `layers` prop is a map keyed by slot name, every slot already a layer. Standard slots\n * render at a canonical position; custom entries (any other key, value carrying `.layer`) insert\n * at `after`/`before` an existing slot, defaulting to the top.\n *\n * @internal\n * @deprecated Bare `<Canvas>` is not a supported consumer surface.\n *   Use `<SceneCanvas>` instead.\n */\n\nimport { forwardRef, useCallback, useEffect, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport type React from 'react';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport { registerMountedCanvas } from './mountedCanvases';\nimport { useViewHelpers } from './useViewHelpers';\nimport { useViewLayerGate } from './useViewLayerGate';\nimport { useSurfaceInput } from './useSurfaceInput';\nimport { useOptionalViewRegistry } from './viewRegistry';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasHelpers } from './useViewHelpers';\nimport type { CanvasProps } from './canvasProps';\nimport { useLatest } from '@weasel-js/react';\nimport { SurfaceCanvas } from './SurfaceCanvas';\nimport { useSurfaceSize } from './useSurfaceSize';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { useDebugSink } from '../debug/useDebugSink';\nimport { useToolCursor } from './useToolCursor';\nimport { useCanvasElements } from './useCanvasElements';\nimport { alwaysVisible, useExtraLayers } from './useExtraLayers';\nimport { usePaintedCursor } from './usePaintedCursor';\nimport { useCanvasHandle } from './useCanvasHandle';\nimport { useComposedLayers, useSlotLayers } from './useLayerStack';\nimport { useViewRegistrySurface } from './useViewRegistrySurface';\nimport { useCanvasPaint, usePaintedVersion } from './useCanvasPaint';\nimport { layerHover } from './layerHover';\nimport { useClientToWorld } from './useClientToWorld';\n\nexport type { CanvasProps, CanvasRetainOptions } from './canvasProps';\n\nconst NO_SELECTION: SelectionApi['current'] = [];\n\nfunction CanvasInner<TPose>(\n  props: CanvasProps<TPose>,\n  ref: React.ForwardedRef<CanvasExtensionApi>,\n) {\n  const {\n    paintInto, inputElement, tools, viewState, style, getIsVisible, layerVisibility, layerOrder,\n    helpersRef, debugSinkRef,\n    poseDescriptor: geometry = AUTO_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>,\n  } = props;\n\n  const { sink: debugSink, overlay: debugOverlay, frameStats, getDebug } = useDebugSink(props.debug);\n  const elements = useCanvasElements(paintInto, inputElement);\n  const { canvasRef, ownCanvasRef, detached } = elements;\n  const { width, height } = useSurfaceSize(props, ownCanvasRef);\n\n  // Read by `hitTestExtras`, which is built once and must see live values.\n  const helpersForLayersRef = useRef<CanvasHelpers<TPose> | null>(null);\n  const dimsRef = useLatest({ width, height });\n  // Which layers reach the screen, and which chrome within them: asked by the\n  // paint and by every hit-test.\n  const gateRef = useLatest({ getIsVisible, layerVisibility, layerOrder });\n\n  // The frame loop paints; a committed render only marks the surface dirty, so\n  // no prop can reach the paint without repainting it. The thunk defers to\n  // `useCanvasPaint` below, which needs inputs this render has not computed yet.\n  const paintRef = useRef<() => boolean>(() => false);\n  const { lease, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume } = useCanvasSurface(\n    useCallback(() => paintRef.current(), []),\n    { syncPaint: props.syncPaint ?? false, target: canvasRef, dpr: props.dpr, redrawOn: props.redrawOn, shaders: props.shaders, onCommit: 'redraw' },\n  );\n  const { getPaintedVersion, markPainted } = usePaintedVersion(props.contentVersion);\n  const { extrasRef, extrasVersion, registerLayer, hitTestExtrasIn } = useExtraLayers(gateRef);\n\n  const {\n    viewRef, setView, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  } = viewState;\n\n  const toWorld = useClientToWorld(canvasRef, props.clientToWorld, viewRef);\n\n  useLayoutEffect(() => {\n    const element = canvasRef.current;\n    if (!element) return;\n    return registerMountedCanvas({ element, getView });\n  }, [canvasRef, detached, inputElement, getView]);\n\n  const { paintedCursor, paintedCursorLayer, cursorSink } = usePaintedCursor(canvasRef, requestRedraw);\n\n  const frame = { viewRef, dimsRef, helpersRef: helpersForLayersRef };\n  useCanvasHandle(ref, { ...elements, inputElement, paintCanvas: paintInto?.canvas }, frame, {\n    hitTestExtrasIn, clientToWorld: toWorld, requestRedraw, subscribeFrame, subscribeBeforePaint,\n    subscribeResume, registerLayer, getView, setView, subscribeView,\n    getPaintedVersion, paintedCursor, cursorSink, getDebug,\n  });\n\n  const viewRegistry = useOptionalViewRegistry();\n\n  // One view's overlay-aware state. A hook, so N views are N components each\n  // calling it once — not a loop in this body.\n  const layers = useSlotLayers(props.layers, tools, props.backgroundFill, props.decorationLayer);\n  const { helpers: viewHelpers } = useViewHelpers<TPose>({\n    adapter: props.adapter, geometry, boundsOf: props.boundsOf, boundsOfPose: props.boundsOfPose,\n    nodes: props.nodes, gestureSource: props.gestureSource, previewPoseExtra: props.previewPoseExtra,\n    getScale: () => viewRef.current.scale,\n    selection: props.selection?.current ?? NO_SELECTION,\n    getIsVisible: () => gateRef.current.getIsVisible?.() ?? alwaysVisible,\n    layerIsPainted: useViewLayerGate(layerVisibility, layerOrder, () => layers),\n  });\n  const helpersForLayers: CanvasHelpers<TPose> = { ...viewHelpers, getDebug: () => debugSink, viewId: null };\n\n  useViewRegistrySurface(viewRegistry, layers, frame, { requestRedraw, hitTestExtrasIn, clientToWorld: toWorld });\n  const layersWithDebug = useComposedLayers(layers, {\n    viewRegistry, debugOverlay, extrasRef, extrasVersion, cursorLayer: paintedCursorLayer,\n  }, requestRedraw);\n\n  // Everything the paint, hit-testing and the view registry read that a React\n  // render owns. `useLatest` and the insertion effect below publish committed\n  // renders only, ahead of every layout effect in the commit, any of which may\n  // ask for a sync paint.\n  const paintInputsRef = useLatest({\n    layers: layersWithDebug, width, height, debugSink, frameStats,\n    dpr: props.dpr, layerGroups: props.layerGroups, shaders: props.shaders,\n    flattenTolerance: props.flattenTolerance, retain: props.retain,\n  });\n  useInsertionEffect(() => {\n    adoptControlled();\n    helpersForLayersRef.current = helpersForLayers;\n    if (helpersRef) helpersRef.current = helpersForLayers;\n    if (debugSinkRef) debugSinkRef.current = debugSink;\n  });\n  useLayoutEffect(() => {\n    announceControlled();\n  });\n\n  useCanvasPaint(paintRef, lease, elements, { ...frame, inputsRef: paintInputsRef, gateRef }, markPainted);\n  useEffect(() => clearSubscribers, [clearSubscribers]);\n\n  useToolCursor(cursorSink, tools, detached ? inputElement : null, style?.cursor);\n\n  useSurfaceInput(canvasRef, {\n    focusOnPress: props.autoFocusOnPointerDown ?? true,\n    onFocus: props.onFocus,\n    onBlur: props.onBlur,\n    ...layerHover(layersWithDebug, {\n      viewRef, toWorld, layerVisibility, layerOrder, dims: { width, height },\n    }),\n  });\n\n  if (detached) return null;\n\n  return (\n    <SurfaceCanvas\n      ref={elements.setOwnCanvas}\n      width={props.width}\n      height={props.height}\n      tabIndex={props.tabIndex ?? 0}\n      className={props.className} style={style}\n    />\n  );\n}\n\n/** Forward-ref'd `<canvas>` wrapper. Generic over the pose type, inferred from the\n *  `adapter` prop. */\nexport const Canvas = forwardRef(CanvasInner) as <TPose = unknown>(\n  props: CanvasProps<TPose> & { ref?: React.ForwardedRef<CanvasExtensionApi> },\n) => ReturnType<typeof CanvasInner>;\n\n"],"mappings":"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"}