@weasel-js/core 1.10.0 → 1.10.1

package/dist/canvas/SceneCanvas.js

@@ -37,56 +37,55 @@ import { useChromeRules as Pe, useSceneHover as Fe, useSurfaceChromeCaps as Ie }
 import { useSceneRedrawSources as Le } from "./SceneCanvas/useSceneRedrawSources.js";
 import { useSceneSelectTool as Re } from "./SceneCanvas/useSceneSelectTool.js";
 import { useViewLayerGate as ze } from "./SceneCanvas/useViewLayerGate.js";
-import { useSceneAdapter as Be } from "./sceneAdapter.js";
+import { useSceneAdapter as Be } from "./useSceneAdapter.js";
 import { useHitObserver as o } from "./useHitObserver.js";
 import { forwardRef as s, useEffect as Ve, useMemo as c, useRef as l, useState as He } from "react";
-import { useLatest as Ue } from "@weasel-js/react";
-import { InputScope as u } from "@weasel-js/routing/react";
-import { jsx as d, jsxs as We } from "react/jsx-runtime";
-import { getActiveModeFor as Ge } from "@weasel-js/modes";
+import { useLatest as u } from "@weasel-js/react";
+import { InputScope as Ue, useActionsRegistry as We } from "@weasel-js/routing/react";
+import { jsx as d, jsxs as Ge } from "react/jsx-runtime";
+import { getActiveModeFor as Ke } from "@weasel-js/modes";
 //#region src/canvas/SceneCanvas.tsx
-function Ke(e) {
+function qe(e) {
 	if (e === !1) return !1;
 	let { slops: t, ...n } = e;
 	return n;
 }
 function f(e, ne) {
-	let { scene: i, geometry: Ce, poseDescriptor: we, selectTool: a, insertNodeFactories: s, insertPaint: u, ingestion: f, layouts: p, layoutDropTarget: m, reflowTransition: h, geometryProjection: qe, routing: Je, selection: Ye, selectionOptions: Xe, selectable: g = !0, tools: Ze, features: Qe, enableKeybindings: _ = !0, claimKeys: $e = !1, enableGestureDispatcher: et = !0, onToolsCreated: tt, defaultTools: nt, toolOptions: rt, initialActiveTool: it, ambient: at, versionCheck: ot, longPress: st, viewport: v, layers: ct, actions: y, describeKind: lt, animator: ut, views: dt, children: ft, debug: b, alphaFor: x, layerVisibility: S, layerOrder: pt, isPointerInteractive: mt, onDoubleClick: ht, onClick: gt, chromeVisibility: C, modes: w, pathEdit: _t, getFocused: vt, cursorCoordsHud: yt, pickHud: bt, modalityHud: xt, view: St, onViewChange: Ct, defaultView: wt, viewBounds: Tt, redrawOn: Et, ...T } = e, E = we ?? ee, D = t(), [Dt] = He(() => ae(i) ? oe(i, {}) : null), O = Dt ?? i, k = c(() => w ? Ge(w) : void 0, [w]), Ot = ce(), kt = Le({
-		supplied: Et,
+	let { scene: i, geometry: Ce, poseDescriptor: we, selectTool: a, insertNodeFactories: s, insertPaint: Ue, ingestion: f, layoutDropTarget: p, reflowTransition: m, geometryProjection: h, routing: Je, selection: Ye, selectionOptions: Xe, selectable: g = !0, tools: Ze, features: Qe, enableKeybindings: _ = !0, claimKeys: $e = !1, enableGestureDispatcher: et = !0, onToolsCreated: tt, defaultTools: nt, toolOptions: rt, initialActiveTool: it, ambient: at, versionCheck: ot, longPress: st, viewport: v, layers: ct, actions: y, tune: lt, describeKind: ut, animator: dt, views: ft, children: pt, debug: b, alphaFor: x, layerVisibility: S, layerOrder: mt, isPointerInteractive: ht, onDoubleClick: gt, onClick: _t, chromeVisibility: C, modes: w, pathEdit: vt, getFocused: yt, cursorCoordsHud: bt, pickHud: xt, modalityHud: St, view: Ct, onViewChange: wt, defaultView: Tt, viewBounds: Et, redrawOn: Dt, ...T } = e, E = we ?? ee, D = t(), [Ot] = He(() => ae(i) ? oe(i, {}) : null), O = Ot ?? i, k = c(() => w ? Ke(w) : void 0, [w]), kt = ce(), At = Le({
+		supplied: Dt,
 		scene: O,
-		heldModifiers: Ot,
-		animator: ut,
+		heldModifiers: kt,
+		animator: dt,
 		modes: w
 	}), A = l(null), j = l(null);
 	Ve(() => (n("scene-canvas", "mount"), () => n("scene-canvas", "unmount")), []);
-	let { viewState: M, viewAnimation: N, camera: At } = se({
-		view: St,
-		defaultView: wt,
-		onViewChange: Ct,
-		viewBounds: Tt,
+	let { viewState: M, viewAnimation: N, camera: jt } = se({
+		view: Ct,
+		defaultView: Tt,
+		onViewChange: wt,
+		viewBounds: Et,
 		width: T.width,
 		height: T.height,
 		requestRedraw: () => {
 			j.current?.requestRedraw();
 		}
-	}), { viewRef: P } = M, F = v?.zoom, I = v?.animatedZoom, jt = c(() => _e(F, I), [F, I]), L = Se({
+	}), { viewRef: P } = M, F = v?.zoom, I = v?.animatedZoom, Mt = c(() => _e(F, I), [F, I]), L = Se({
 		scene: O,
 		supplied: Ye,
 		options: Xe,
 		selectable: g,
-		describeKind: lt
+		describeKind: ut
 	}), R = de({
-		host: _t,
+		host: vt,
 		isAllowed: k ? () => k().allowedCapabilities.has("edits-anchors") : void 0,
 		isSelectedNode: (e) => ue(O, L, e)
-	}), Mt = c(() => ({
+	}), Nt = c(() => ({
 		extendClickLocked: () => R.getEditingId() !== "",
 		...a
-	}), [a, R]), Nt = Ue(L), { kindOfData: Pt, kindOfNode: z } = ke(O, Je), B = c(() => Me(O, x), [O, x]), V = ze(S, pt), H = Be(O, {
+	}), [a, R]), Pt = u(L), { kindOfData: Ft, kindOfNode: z } = ke(O, Je), B = c(() => Me(O, x), [O, x]), V = ze(S, mt), H = Be(O, {
 		selection: L.adapterMethods,
-		poseDescriptor: E,
-		layouts: p
-	}), { selectTool: Ft, pickEvery: U, pickBest: W, boundsOf: G, boundsOfPose: K, planeOfNode: q, moveOptions: It } = Re({
+		poseDescriptor: E
+	}), { selectTool: It, pickEvery: U, pickBest: W, boundsOf: G, boundsOfPose: K, planeOfNode: q, moveOptions: Lt } = Re({
 		scene: O,
 		adapter: H,
 		poseDescriptor: E,
@@ -94,14 +93,14 @@ function f(e, ne) {
 		getView: () => P.current,
 		...x ? { alphaOf: B } : {},
 		...V ? { layerIsPainted: V } : {},
-		selectTool: Mt
-	}), Lt = Oe({
+		selectTool: Nt
+	}), Rt = Oe({
 		pickBest: W,
 		nodes: H,
-		kindOfData: Pt,
-		isPointerInteractive: mt
-	}), J = Ee(Qe, v !== void 0), { tools: Y, internal: Rt, takeover: zt } = Te({
-		select: Ft,
+		kindOfData: Ft,
+		isPointerInteractive: ht
+	}), J = Ee(Qe, v !== void 0), { tools: Y, internal: zt, takeover: Bt } = Te({
+		select: It,
 		enabled: J,
 		tools: Ze,
 		defaultTools: nt,
@@ -112,42 +111,42 @@ function f(e, ne) {
 		initialActiveTool: it,
 		modes: w,
 		onToolsCreated: tt
-	}), { contributions: Bt, standardActionsExclude: Vt } = De({
+	}), { contributions: Vt, standardActionsExclude: Ht } = De({
 		enabled: J,
 		tools: Y,
-		move: It,
+		move: Lt,
 		rotate: a?.rotate || void 0
-	}), X = Ue(Lt), Ht = o(ht, X), Ut = o(gt, X), Z = a?.rotate === !1, Wt = c(() => Z ? ge(y, "rotate") : y, [y, Z]), { dispatcher: Q, getActionRef: Gt, gestureSource: Kt, previewIdsExtra: qt, previewPoseExtra: Jt } = xe(), { layers: Yt, rotationBadge: $, chromeAffordancesRef: Xt } = Ne({
+	}), X = u(Rt), Ut = o(gt, X), Wt = o(_t, X), Z = a?.rotate === !1, Gt = c(() => Z ? ge(y, "rotate") : y, [y, Z]), Kt = We(), { dispatcher: Q, gestureSource: qt, previewIdsExtra: Jt, previewPoseExtra: Yt } = xe(Kt), { layers: Xt, rotationBadge: $, chromeAffordancesRef: Zt } = Ne({
 		layers: ct,
 		targetScale: D.targetScale,
 		scene: O,
 		adapter: H,
 		poseDescriptor: E,
 		alphaFor: x,
-		colorOverrides: ut?.colorOverrides,
+		colorOverrides: dt?.colorOverrides,
 		boundsOf: G,
 		planeOfNode: q,
-		previewIds: qt,
+		previewIds: Jt,
 		dispatcher: Q,
 		pathEditState: R,
 		slops: b !== void 0 && b !== !1 && b.slops === !0
-	}), { getHover: Zt, canvasRef: Qt } = Fe({
+	}), { getHover: Qt, canvasRef: $t } = Fe({
 		canvasApiRef: j,
 		viewRef: P,
 		nodeAtPointRef: X,
 		enabled: C !== void 0
-	}), $t = Pe({
+	}), en = Pe({
 		enabled: J,
 		selectable: g,
 		rotateOff: Z,
 		chromeVisibility: C
-	}), { chromeCaps: en, getIsVisible: tn, getRuleCtx: nn } = Ie({
+	}), { chromeCaps: tn, getIsVisible: nn, getRuleCtx: rn } = Ie({
 		source: {
-			rules: $t,
+			rules: en,
 			getMode: k,
-			getFocused: vt,
-			getHover: Zt,
-			getModifiers: Ot.get,
+			getFocused: yt,
+			getHover: Qt,
+			getModifiers: kt.get,
 			resizable: a?.resize?.resizable,
 			editingAnchors: () => R.getEditingId() !== "",
 			device: D
@@ -155,14 +154,14 @@ function f(e, ne) {
 		selection: L.current,
 		viewRef: P,
 		dispatcher: Q
-	}), rn = l(null), { ingest: an, clipboard: on } = le(H, () => rn.current, f), { views: sn, addView: cn } = Ae(), { handleRef: ln, ready: un } = je({
+	}), { ingest: an, clipboard: on } = le(H, () => Kt, f), { views: sn, addView: cn } = Ae(), { handleRef: ln, ready: un } = je({
 		ref: ne,
 		elementRef: A,
 		apiRef: j,
-		onElement: Qt,
+		onElement: $t,
 		ingest: an,
 		viewAnimation: N,
-		camera: At,
+		camera: jt,
 		addView: cn
 	}), dn = c(() => ({
 		adapter: H,
@@ -173,7 +172,7 @@ function f(e, ne) {
 		pickEvery: U,
 		pickBest: W,
 		kindOfNode: z,
-		chromeCaps: en,
+		chromeCaps: tn,
 		selectionApi: L,
 		rotationBadge: $
 	}), [
@@ -185,7 +184,7 @@ function f(e, ne) {
 		U,
 		W,
 		z,
-		en,
+		tn,
 		L,
 		$
 	]);
@@ -196,31 +195,31 @@ function f(e, ne) {
 		getActiveToolId: () => Y.active ?? null
 	}), /* @__PURE__ */ d(te, {
 		value: dn,
-		children: /* @__PURE__ */ We(re, { children: [
+		children: /* @__PURE__ */ Ge(re, { children: [
 			/* @__PURE__ */ d(pe, {
 				ref: ln,
 				adapter: H,
 				selection: L,
 				poseDescriptor: E,
 				tools: Y,
-				layers: Yt,
+				layers: Xt,
 				boundsOf: G,
 				boundsOfPose: K,
-				getIsVisible: tn,
-				gestureSource: Kt,
-				previewPoseExtra: Jt,
-				...b === void 0 ? {} : { debug: Ke(b) },
+				getIsVisible: nn,
+				gestureSource: qt,
+				previewPoseExtra: Yt,
+				...b === void 0 ? {} : { debug: qe(b) },
 				contentVersion: O.getVersion,
 				layerVisibility: S,
-				layerOrder: pt,
+				layerOrder: mt,
 				viewState: M,
-				redrawOn: kt,
+				redrawOn: At,
 				...T
 			}),
 			/* @__PURE__ */ d(me, {
-				cursorCoords: yt,
-				pick: bt,
-				modality: xt,
+				cursorCoords: bt,
+				pick: xt,
+				modality: St,
 				canvasRef: A,
 				canvasApiRef: j,
 				detachedInput: T.paintInto ? T.inputElement ?? null : void 0,
@@ -236,46 +235,44 @@ function f(e, ne) {
 				selection: L,
 				scene: O,
 				adapter: H,
-				actions: Wt,
-				excludeActions: Vt,
+				actions: Gt,
+				tune: lt,
+				excludeActions: Ht,
 				currentViewRef: P,
 				onViewChange: M.setViewFromInput,
 				resizeOptions: a?.resize,
 				poseDescriptor: E,
-				geometryProjection: qe,
+				geometryProjection: h,
 				dispatcher: Q,
-				getActionRef: Gt,
 				pickEvery: U,
 				layerIsPainted: V,
 				alphaOf: x ? B : void 0,
 				viewportPanEnabled: J.has("view") ? v?.pan ?? !0 : !1,
-				viewportZoom: J.has("view") ? jt : !1,
+				viewportZoom: J.has("view") ? Mt : !1,
 				viewportPinchZoom: J.has("view") ? v?.pinchZoom ?? !0 : !1,
 				viewportRecenter: v?.recenter,
 				viewAnimation: N,
 				editAnchorsExternalState: R,
-				layouts: p,
-				layoutDropTarget: m,
-				reflowTransition: h,
+				layoutDropTarget: p,
+				reflowTransition: m,
 				insertNodeFactories: s,
-				insertPaint: u,
+				insertPaint: Ue,
 				snapPoint: rt?.snapPoint,
 				canvasRef: A,
 				canvasApiRef: j,
 				ingestionResolveSrc: f?.resolveSrc,
 				ingestionSvg: f?.svg,
-				ingestionClipboard: on,
-				actionsRegistryRef: rn
+				ingestionClipboard: on
 			}),
 			/* @__PURE__ */ d(he, {
 				canvasRef: A,
 				canvasApiRef: j,
 				tools: Y,
-				contributions: Bt,
+				contributions: Vt,
 				enabled: et,
 				keyboard: _,
 				claimKeys: $e,
-				selectionRef: Nt,
+				selectionRef: Pt,
 				boundsOf: G,
 				planeOfNode: q,
 				pickEvery: U,
@@ -283,37 +280,37 @@ function f(e, ne) {
 				kindOfNode: z,
 				viewRef: P,
 				dispatcher: Q,
-				getIsVisibleForCanvas: tn,
-				getRuleCtx: nn,
+				getIsVisibleForCanvas: nn,
+				getRuleCtx: rn,
 				targetScale: D.targetScale,
 				handleHitRadius: a?.handleHitRadius,
 				rotationBadge: $,
-				chromeAffordancesRef: Xt,
-				onDoubleClick: Ht,
-				onClick: Ut,
+				chromeAffordancesRef: Zt,
+				onDoubleClick: Ut,
+				onClick: Wt,
 				longPress: st
 			}),
 			/* @__PURE__ */ d(be, {
-				internalTools: Rt,
-				toolsTakeover: zt ?? void 0,
+				internalTools: zt,
+				toolsTakeover: Bt ?? void 0,
 				enableKeybindings: _,
 				modes: w,
 				canvasApi: un ? j.current : null,
 				versionCheck: ot
 			}),
-			dt?.map((e, t) => /* @__PURE__ */ d(r, {
+			ft?.map((e, t) => /* @__PURE__ */ d(r, {
 				...e,
 				order: e.order ?? t
 			}, e.id)),
 			ye(Y).flatMap((e) => e.views ?? []).map((e) => /* @__PURE__ */ d(r, { ...e }, `contribution:${e.id}`)),
 			sn.map((e) => /* @__PURE__ */ d(r, { ...e }, `added:${e.id}`)),
-			ft
+			pt
 		] })
 	});
 }
 var p = s(f);
 function m({ device: t, ...n }, ee) {
-	return /* @__PURE__ */ d(u, {
+	return /* @__PURE__ */ d(Ue, {
 		yoke: n.yoke,
 		children: /* @__PURE__ */ d(e, {
 			value: t,

package/dist/canvas/SceneCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SceneCanvas.js","names":["canvasDebug","debug","_slops","rest","SceneCanvasInner","sceneInput","selectToolOpts","selectionProp","toolsProp","viewDescriptors","getFocusedProp","redrawOnProp","restProps","props","descriptor","poseDescriptor","AUTO_POSE_DESCRIPTOR","deviceProfile","useDeviceProfile","bakedScene","useState","isSerializedScene","sceneFromJSON","scene","getActiveMode","useMemo","modes","getActiveModeFor","heldModifiers","useHeldModifiers","redrawOn","useSceneRedrawSources","internalCanvasRef","useRef","canvasApiRef","dlog","useCanvasCamera","viewState","viewportZoomProp","viewport","animatedZoom","resolvedViewportZoom","viewportZoomOption","selection","useCanvasSelection","selectionOptions","pathEditState","usePathEditState","pathEdit","isSelectedNode","id","selectToolWithDefaults","selectionRef","useLatest","useNodeKinds","routing","composedAlphaFor","composeAlphaFor","alphaFor","viewLayerGate","useViewLayerGate","layerVisibility","layerOrder","adapter","useSceneAdapter","internalSelect","internalPickEvery","internalPickBest","internalBoundsOf","internalBoundsOfPose","internalPlaneOfNode","internalMoveOptions","useSceneSelectTool","viewRef","getNodeAtPoint","useNodeAtPoint","enabled","useEnabledFeatures","features","internalTools","toolsTakeover","useCanvasTools","longPress","featureContributions","useFeatureBindings","getNodeAtPointRef","onDoubleClickObserver","useHitObserver","onDoubleClick","onClickObserver","onClick","rotateOff","resolvedActions","actionsMuting","actions","useCanvasDispatcher","wiredLayers","useSceneCanvasLayers","animator","previewIdsExtra","trackHoverOn","useSceneHover","chromeVisibility","chromeRules","useChromeRules","getIsVisibleForCanvas","getRuleCtxForCanvas","useSurfaceChromeCaps","actionsRegistryRef","ingestionClipboard","useCanvasIngestion","ingestion","addedViews","useAddedViews","canvasReady","useSceneCanvasHandle","viewInputs","kindOfNode","chromeCaps","rotationBadge","useTestHook","tools","ViewInputsProvider","PointerProviderIfRoot","Canvas","handleRef","DevHuds","cursorCoordsHud","pickHud","modalityHud","PointerPublisher","StandardActionsRegistrar","standardActionsExclude","toolOptions","GestureDispatcherMounter","enableGestureDispatcher","enableKeybindings","ToolKeybindingsMounter","CanvasView","v","i","contributionEntries","children","SceneCanvasInnerForwardRef","forwardRef","SceneCanvasWrapper","InputScope","DeviceProfileProvider","device","ViewRegistryProvider","SceneCanvas","BUILTIN_TOOL_IDS","DEFAULT_HANDLE_SIZE","SCENE_CANVAS_FEATURES","rotateAroundAABBCenter"],"sources":["../../src/canvas/SceneCanvas.tsx"],"sourcesContent":["/**\n * `<SceneCanvas>` — `<Canvas>` wired to a `Scene` primitive. Bare, it only renders: behavior\n * comes from the `features` presets (`canvas/SceneCanvas/features.ts`), each of which turns on\n * its own actions, tools, ambient bindings, and chrome.\n *\n * A consumer needing custom tools can pass `tools={useTools(...)}` and SceneCanvas forwards it\n * as-is — the internal tool registry is ignored in that case.\n */\nimport { getActiveModeFor } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport type { ActionsProp, ActionsRegistry } from '@weasel-js/routing';\nimport { InputScope } from '@weasel-js/routing/react';\nimport { sceneFromJSON } from 'core/scene/scene';\nimport { isSerializedScene } from 'core/scene/serialization';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { useCanvasCamera } from './SceneCanvas/useCanvasCamera';\nimport { useHeldModifiers } from './SceneCanvas/useHeldModifiers';\nimport { useCanvasIngestion } from 'features/ingestion/useCanvasIngestion';\nimport { isSelectedNode } from 'features/paths/pathEditState';\nimport { usePathEditState } from 'features/paths/usePathEdit';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type React from 'react';\nimport { forwardRef, useEffect, useMemo, useRef, useState } from 'react';\nimport { DeviceProfileProvider, useDeviceProfile } from '../core/device/useDeviceProfile';\nimport { dlog } from '../debug/flag';\nimport type { DebugConfig } from '../debug/types';\nimport type { ReflowTransition } from '../layout/types';\nimport { useTestHook } from '../test-hook/useTestHook';\nimport { Canvas } from './Canvas';\nimport { CanvasView } from './CanvasView';\nimport { DevHuds } from './SceneCanvas/DevHuds';\nimport { GestureDispatcherMounter } from './SceneCanvas/GestureDispatcherMounter';\nimport { PointerProviderIfRoot, PointerPublisher } from './SceneCanvas/PointerProviderIfRoot';\nimport { StandardActionsRegistrar } from './SceneCanvas/StandardActionsRegistrar';\nimport { ToolKeybindingsMounter } from './SceneCanvas/ToolKeybindingsMounter';\nimport type { FeatureBindingOptions } from './SceneCanvas/features';\nimport type { BridgeAdapter, SceneCanvasProps } from './SceneCanvas/props';\nimport { actionsMuting } from './SceneCanvas/useActionsPropResolver';\nimport { useCanvasDispatcher } from './SceneCanvas/useCanvasDispatcher';\nimport { useCanvasSelection } from './SceneCanvas/useCanvasSelection';\nimport { useCanvasTools, useEnabledFeatures, useFeatureBindings } from './SceneCanvas/useCanvasTools';\nimport { contributionEntries } from './SceneCanvas/useContributionRoles';\nimport { useNodeAtPoint } from './SceneCanvas/useNodeAtPoint';\nimport { useNodeKinds } from './SceneCanvas/useNodeKinds';\nimport { useAddedViews, useSceneCanvasHandle } from './SceneCanvas/useSceneCanvasHandle';\nimport { useSceneCanvasLayers } from './SceneCanvas/useSceneCanvasLayers';\nimport { useChromeRules, useSceneHover, useSurfaceChromeCaps } from './SceneCanvas/useSceneChrome';\nimport { useSceneRedrawSources } from './SceneCanvas/useSceneRedrawSources';\nimport { useSceneSelectTool } from './SceneCanvas/useSceneSelectTool';\nimport { useViewLayerGate } from './SceneCanvas/useViewLayerGate';\nimport { viewportZoomOption } from './SceneCanvas/useViewportActions';\nimport type { CanvasExtensionApi, SceneCanvasApi } from './canvasExtension';\nimport { useSceneAdapter } from './sceneAdapter';\nimport { composeAlphaFor } from './sceneSlotWiring';\nimport { useHitObserver } from './useHitObserver';\nimport { ViewInputsProvider, type SurfaceViewInputs } from './viewInputs';\nimport { ViewRegistryProvider } from './viewRegistry';\nexport { SCENE_CANVAS_FEATURES } from './SceneCanvas/features';\nexport type { Feature } from './SceneCanvas/features';\nexport type { BuiltinToolOptions } from './SceneCanvas/useBuiltinShapeTools';\nexport { defaultDrawOne } from './defaultDrawOne';\nexport { rotateAroundAABBCenter } from './poseRotation';\n\n/** `<SceneCanvas debug>` minus the flag only SceneCanvas reads. */\nfunction canvasDebug(debug: (DebugConfig & { slops?: boolean }) | false): DebugConfig | false {\n  if (debug === false) return false;\n  const { slops: _slops, ...rest } = debug;\n  return rest;\n}\n\nfunction SceneCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  const {\n    scene: sceneInput,\n    geometry,\n    poseDescriptor,\n    selectTool: selectToolOpts,\n    insertNodeFactories,\n    insertPaint,\n    ingestion,\n    layouts,\n    layoutDropTarget,\n    reflowTransition,\n    geometryProjection,\n    routing,\n    selection: selectionProp,\n    selectionOptions,\n    selectable = true,\n    tools: toolsProp,\n    features,\n    enableKeybindings = true,\n    claimKeys = false,\n    enableGestureDispatcher = true,\n    onToolsCreated,\n    defaultTools,\n    toolOptions,\n    initialActiveTool,\n    ambient,\n    versionCheck,\n    longPress,\n    viewport,\n    layers,\n    actions,\n    describeKind,\n    animator,\n    views: viewDescriptors,\n    children,\n    debug,\n    alphaFor,\n    layerVisibility,\n    layerOrder,\n    isPointerInteractive,\n    onDoubleClick,\n    onClick,\n    chromeVisibility,\n    modes,\n    pathEdit,\n    getFocused: getFocusedProp,\n    cursorCoordsHud, pickHud, modalityHud,\n    view, onViewChange, defaultView, viewBounds, redrawOn: redrawOnProp,\n    ...restProps\n  } = props;\n\n  const descriptor = (poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const deviceProfile = useDeviceProfile();\n\n  // `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked\n  // once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).\n  const [bakedScene] = useState<Scene<TData, TLayer, TPose> | null>(\n    () => (isSerializedScene<TData, TLayer, TPose>(sceneInput) ? sceneFromJSON(sceneInput, {}) : null),\n  );\n  const scene = bakedScene ?? (sceneInput as Scene<TData, TLayer, TPose>);\n\n  const getActiveMode = useMemo(() => (modes ? getActiveModeFor(modes) : undefined), [modes]);\n  const heldModifiers = useHeldModifiers();\n  const redrawOn = useSceneRedrawSources({ supplied: redrawOnProp, scene, heldModifiers, animator, modes });\n\n  // The canvas element, kept here so the dispatcher can attach its input listeners even when\n  // the consumer passes their own forwarded ref, and the full handle, for `requestRedraw`.\n  const internalCanvasRef = useRef<HTMLElement | null>(null);\n  const canvasApiRef = useRef<CanvasExtensionApi | null>(null);\n\n  useEffect(() => {\n    dlog('scene-canvas', 'mount');\n    return () => dlog('scene-canvas', 'unmount');\n  }, []);\n\n  const { viewState, viewAnimation, camera } = useCanvasCamera({\n    view, defaultView, onViewChange, viewBounds,\n    width: restProps.width,\n    height: restProps.height,\n    requestRedraw: () => { canvasApiRef.current?.requestRedraw(); },\n  });\n  const { viewRef } = viewState;\n\n  const viewportZoomProp = viewport?.zoom;\n  const animatedZoom = viewport?.animatedZoom;\n  const resolvedViewportZoom = useMemo(\n    () => viewportZoomOption(viewportZoomProp, animatedZoom),\n    [viewportZoomProp, animatedZoom],\n  );\n\n  const selection = useCanvasSelection({\n    scene, supplied: selectionProp, options: selectionOptions, selectable, describeKind,\n  });\n\n  // `isAllowed` is absent, not a predicate, when no mode registry is wired:\n  // see `PathEditSource.isAllowed`.\n  const pathEditState = usePathEditState({\n    host: pathEdit,\n    isAllowed: getActiveMode\n      ? () => getActiveMode().allowedCapabilities.has('edits-anchors')\n      : undefined,\n    isSelectedNode: (id) => isSelectedNode(scene, selection, id),\n  });\n\n  const selectToolWithDefaults = useMemo(() => ({\n    // Shift-click belongs to the anchor selection while a path is being\n    // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.\n    extendClickLocked: () => pathEditState.getEditingId() !== '',\n    ...selectToolOpts,\n  }), [selectToolOpts, pathEditState]);\n\n  const selectionRef = useLatest(selection);\n  const { kindOfData, kindOfNode } = useNodeKinds(scene, routing);\n\n  // The painted alpha of a node in this view: the caller's `alphaFor` times any per-node\n  // override alpha. The pick path reads the same number the painter does, or a node faded\n  // to nothing stays clickable.\n  const composedAlphaFor = useMemo(\n    () => composeAlphaFor(scene, alphaFor),\n    [scene, alphaFor],\n  );\n  const viewLayerGate = useViewLayerGate(layerVisibility, layerOrder);\n\n  const adapter = useSceneAdapter(scene, {\n    // `adapterMethods` is memoized; `selection` itself is a fresh object each render.\n    selection: selection.adapterMethods,\n    poseDescriptor: descriptor,\n    layouts,\n  });\n\n  const {\n    selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest,\n    boundsOf: internalBoundsOf, boundsOfPose: internalBoundsOfPose, planeOfNode: internalPlaneOfNode,\n    moveOptions: internalMoveOptions,\n  } = useSceneSelectTool({\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    geometry,\n    // The pick tolerance is declared in screen pixels; this is what converts it.\n    getView: () => viewRef.current,\n    // Only when the consumer actually fades something. Without a prop the\n    // composed function is just the override lookup, and the source resolves\n    // that once per walk instead of once per candidate.\n    ...(alphaFor ? { alphaOf: composedAlphaFor } : {}),\n    ...(viewLayerGate ? { layerIsPainted: viewLayerGate } : {}),\n    selectTool: selectToolWithDefaults,\n  });\n\n  const getNodeAtPoint = useNodeAtPoint({\n    pickBest: internalPickBest, nodes: adapter, kindOfData, isPointerInteractive,\n  });\n\n  const enabled = useEnabledFeatures(features, viewport !== undefined);\n  const { tools, internal: internalTools, takeover: toolsTakeover } = useCanvasTools({\n    select: internalSelect,\n    enabled,\n    tools: toolsProp,\n    defaultTools,\n    toolOptions,\n    inertia: viewport?.inertia,\n    ambient,\n    pressFeedback: longPress?.feedback,\n    initialActiveTool,\n    modes,\n    onToolsCreated,\n  });\n  const { contributions: featureContributions, standardActionsExclude } = useFeatureBindings({\n    enabled,\n    tools,\n    move: internalMoveOptions as FeatureBindingOptions['move'],\n    rotate: (selectToolOpts?.rotate || undefined) as FeatureBindingOptions['rotate'],\n  });\n\n  // Rides the gesture dispatcher as an OBSERVER rather than an Action binding because the\n  // prop is a notification, not a behavior: as a binding it would lose first-match-wins to\n  // `enterPathEdit` on every body hit and silently stop firing.\n  const getNodeAtPointRef = useLatest(getNodeAtPoint);\n  const onDoubleClickObserver = useHitObserver(onDoubleClick, getNodeAtPointRef);\n  const onClickObserver = useHitObserver(onClick, getNodeAtPointRef);\n\n  // `selectTool.rotate === false` disables rotation: its action is muted here and its\n  // handle hidden by `useChromeRules`.\n  const rotateOff = selectToolOpts?.rotate === false;\n  const resolvedActions = useMemo<ActionsProp | undefined>(\n    () => (rotateOff ? actionsMuting(actions, 'rotate') : actions),\n    [actions, rotateOff],\n  );\n\n  const { dispatcher, getActionRef, gestureSource, previewIdsExtra, previewPoseExtra } = useCanvasDispatcher();\n\n  const { layers: wiredLayers, rotationBadge, chromeAffordancesRef } = useSceneCanvasLayers({\n    layers,\n    targetScale: deviceProfile.targetScale,\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    alphaFor,\n    colorOverrides: animator?.colorOverrides,\n    boundsOf: internalBoundsOf,\n    planeOfNode: internalPlaneOfNode,\n    previewIds: previewIdsExtra,\n    dispatcher,\n    pathEditState,\n    slops: debug !== undefined && debug !== false && debug.slops === true,\n  });\n\n  const { getHover, canvasRef: trackHoverOn } = useSceneHover({\n    canvasApiRef, viewRef, nodeAtPointRef: getNodeAtPointRef, enabled: chromeVisibility !== undefined,\n  });\n  const chromeRules = useChromeRules({ enabled, selectable, rotateOff, chromeVisibility });\n  const { chromeCaps, getIsVisible: getIsVisibleForCanvas, getRuleCtx: getRuleCtxForCanvas } = useSurfaceChromeCaps({\n    source: {\n      rules: chromeRules,\n      getMode: getActiveMode,\n      getFocused: getFocusedProp,\n      getHover,\n      getModifiers: heldModifiers.get,\n      resizable: selectToolOpts?.resize?.resizable,\n      editingAnchors: () => pathEditState.getEditingId() !== '',\n      device: deviceProfile,\n    },\n    selection: selection.current as readonly NodeId[],\n    viewRef,\n    dispatcher,\n  });\n\n  // `StandardActionsRegistrar` stashes the registry into this ref.\n  const actionsRegistryRef = useRef<ActionsRegistry | null>(null);\n  const { ingest, clipboard: ingestionClipboard } = useCanvasIngestion(\n    adapter, () => actionsRegistryRef.current, ingestion,\n  );\n\n  const { views: addedViews, addView } = useAddedViews();\n  // The consumer's handle extends the primitive's with `ingest`, which needs the action stack.\n  const { handleRef, ready: canvasReady } = useSceneCanvasHandle({\n    ref, elementRef: internalCanvasRef, apiRef: canvasApiRef, onElement: trackHoverOn,\n    ingest, viewAnimation, camera, addView,\n  });\n\n  // What a view needs to build its own overlay-aware state. `geometry` is the\n  // same descriptor handed to `<Canvas>`, so the two cannot diverge.\n  const viewInputs = useMemo<SurfaceViewInputs>(() => ({\n    adapter: adapter as unknown as { getPose(id: string): unknown },\n    geometry: descriptor as PoseDescriptor<unknown>,\n    boundsOf: internalBoundsOf,\n    boundsOfPose: internalBoundsOfPose as SurfaceViewInputs['boundsOfPose'],\n    planeOfNode: internalPlaneOfNode,\n    pickEvery: internalPickEvery,\n    pickBest: internalPickBest,\n    kindOfNode,\n    chromeCaps,\n    selectionApi: selection,\n    rotationBadge,\n  }), [adapter, descriptor, internalBoundsOf, internalBoundsOfPose, internalPlaneOfNode,\n       internalPickEvery, internalPickBest, kindOfNode, chromeCaps, selection, rotationBadge]);\n\n  useTestHook({\n    getScene: () => scene as never,\n    getSelectionIds: () => (selection.current as readonly string[] | undefined) ?? [],\n    getView: () => viewRef.current,\n    getActiveToolId: () => tools.active ?? null,\n  });\n\n  return (\n    <ViewInputsProvider value={viewInputs}>\n      <PointerProviderIfRoot>\n        <Canvas<TPose>\n          ref={handleRef}\n          adapter={adapter}\n          selection={selection}\n          poseDescriptor={descriptor}\n          tools={tools}\n          layers={wiredLayers}\n          // The chrome's bounds are the picker's: a node on a parallax plane is\n          // boxed where the plane draws it, and a `geometry.boundsOf` reaches both.\n          boundsOf={internalBoundsOf}\n          boundsOfPose={internalBoundsOfPose}\n          getIsVisible={getIsVisibleForCanvas}\n          // The gesture surface behind `helpersRef.getGestureBounds()` /\n          // `subscribeGestures()` — Canvas has no dispatcher of its own.\n          gestureSource={gestureSource}\n          previewPoseExtra={previewPoseExtra}\n          {...(debug !== undefined ? { debug: canvasDebug(debug) } : {})}\n          contentVersion={scene.getVersion}\n          layerVisibility={layerVisibility}\n          layerOrder={layerOrder}\n          viewState={viewState}\n          redrawOn={redrawOn}\n          {...restProps}\n        />\n        <DevHuds\n          cursorCoords={cursorCoordsHud}\n          pick={pickHud}\n          modality={modalityHud}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          detachedInput={restProps.paintInto ? restProps.inputElement ?? null : undefined}\n          viewRef={viewRef}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n        />\n        <PointerPublisher canvasRef={internalCanvasRef} canvasApiRef={canvasApiRef} />\n        <StandardActionsRegistrar\n          selection={selection}\n          scene={scene}\n          adapter={adapter as unknown as BridgeAdapter}\n          actions={resolvedActions}\n          excludeActions={standardActionsExclude}\n          currentViewRef={viewRef}\n          onViewChange={viewState.setViewFromInput}\n          resizeOptions={selectToolOpts?.resize as UseResizeOptions<unknown> | undefined}\n          poseDescriptor={descriptor as PoseDescriptor<unknown>}\n          geometryProjection={geometryProjection}\n          dispatcher={dispatcher}\n          getActionRef={getActionRef}\n          pickEvery={internalPickEvery}\n          layerIsPainted={viewLayerGate}\n          alphaOf={alphaFor ? composedAlphaFor : undefined}\n          viewportPanEnabled={enabled.has('view') ? (viewport?.pan ?? true) : false}\n          viewportZoom={enabled.has('view') ? resolvedViewportZoom : false}\n          viewportPinchZoom={enabled.has('view') ? (viewport?.pinchZoom ?? true) : false}\n          viewportRecenter={viewport?.recenter}\n          viewAnimation={viewAnimation}\n          editAnchorsExternalState={pathEditState}\n          layouts={layouts as SceneCanvasProps<unknown, string, unknown>['layouts']}\n          layoutDropTarget={layoutDropTarget}\n          reflowTransition={reflowTransition as ReflowTransition<unknown> | null | undefined}\n          insertNodeFactories={insertNodeFactories}\n          insertPaint={insertPaint}\n          snapPoint={toolOptions?.snapPoint}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          ingestionResolveSrc={ingestion?.resolveSrc}\n          ingestionSvg={ingestion?.svg}\n          ingestionClipboard={ingestionClipboard}\n          actionsRegistryRef={actionsRegistryRef}\n        />\n        <GestureDispatcherMounter\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          tools={tools}\n          contributions={featureContributions}\n          enabled={enableGestureDispatcher}\n          keyboard={enableKeybindings}\n          claimKeys={claimKeys}\n          selectionRef={selectionRef}\n          boundsOf={internalBoundsOf}\n          planeOfNode={internalPlaneOfNode}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n          kindOfNode={kindOfNode}\n          viewRef={viewRef}\n          dispatcher={dispatcher}\n          getIsVisibleForCanvas={getIsVisibleForCanvas}\n          getRuleCtx={getRuleCtxForCanvas}\n          targetScale={deviceProfile.targetScale}\n          handleHitRadius={selectToolOpts?.handleHitRadius}\n          rotationBadge={rotationBadge}\n          chromeAffordancesRef={chromeAffordancesRef}\n          onDoubleClick={onDoubleClickObserver}\n          onClick={onClickObserver}\n          longPress={longPress}\n        />\n        <ToolKeybindingsMounter\n          internalTools={internalTools}\n          toolsTakeover={toolsTakeover ?? undefined}\n          enableKeybindings={enableKeybindings}\n          modes={modes}\n          canvasApi={canvasReady ? canvasApiRef.current : null}\n          versionCheck={versionCheck}\n        />\n        {viewDescriptors?.map((v, i) => (\n          <CanvasView key={v.id} {...v} order={v.order ?? i} />\n        ))}\n        {contributionEntries(tools).flatMap((e) => e.views ?? []).map((v) => (\n          <CanvasView key={`contribution:${v.id}`} {...v} />\n        ))}\n        {addedViews.map((v) => <CanvasView key={`added:${v.id}`} {...v} />)}\n        {children}\n      </PointerProviderIfRoot>\n    </ViewInputsProvider>\n  );\n}\n\nconst SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);\n\n// The canvas's input scope sits above `SceneCanvasInner`, whose own hooks\n// (`useTools` among them) must already read this canvas's tool and registries.\n// Its device profile too, so the canvas and everything under it share one.\nfunction SceneCanvasWrapper<TData, TLayer extends string, TPose>(\n  { device, ...props }: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  return (\n    <InputScope yoke={props.yoke}>\n      <DeviceProfileProvider value={device}>\n        <ViewRegistryProvider>\n          <SceneCanvasInnerForwardRef {...(props as SceneCanvasProps<unknown, string, unknown>)} ref={ref} />\n        </ViewRegistryProvider>\n      </DeviceProfileProvider>\n    </InputScope>\n  );\n}\n\n/**\n * The canvas component: renders a `Scene` and wires the interaction stack\n * around it.\n *\n * Mounted bare it renders the scene, keeps a selection no input sets, and\n * runs a gesture dispatcher for whatever bindings the consumer adds. The\n * `features` presets turn the kit's behavior on — `features={['draw']}` is the\n * whole editor: tools, standard actions and their keys, selection chrome,\n * undo. This is the intended entry point; the lower-level primitives it\n * composes are not part of the public surface.\n *\n * Its ref exposes a `SceneCanvasApi` for the imperative operations that do not\n * fit a prop (view control, hit queries, redraw requests).\n */\nexport const SceneCanvas = forwardRef(SceneCanvasWrapper) as <\n  TData, TLayer extends string, TPose,\n>(\n  props: SceneCanvasProps<TData, TLayer, TPose> & { ref?: React.Ref<SceneCanvasApi> },\n) => ReturnType<typeof SceneCanvasInner>;\n\nexport { DEFAULT_HANDLE_SIZE, mergeLayersWithDefaults, BUILTIN_TOOL_IDS } from './SceneCanvas/props';\nexport type {\n  SceneCanvasProps,\n  SceneCanvasHit,\n  SceneCanvasLayers,\n  SceneCanvasLongPress,\n  BuiltinToolId,\n} from './SceneCanvas/props';\nexport type { CoordTraceEntry } from './SceneCanvas/coordTrace';\n"],"mappings":"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"}
+{"version":3,"file":"SceneCanvas.js","names":["canvasDebug","debug","_slops","rest","SceneCanvasInner","sceneInput","selectToolOpts","selectionProp","toolsProp","viewDescriptors","getFocusedProp","redrawOnProp","restProps","props","descriptor","poseDescriptor","AUTO_POSE_DESCRIPTOR","deviceProfile","useDeviceProfile","bakedScene","useState","isSerializedScene","sceneFromJSON","scene","getActiveMode","useMemo","modes","getActiveModeFor","heldModifiers","useHeldModifiers","redrawOn","useSceneRedrawSources","internalCanvasRef","useRef","canvasApiRef","dlog","useCanvasCamera","viewState","viewportZoomProp","viewport","animatedZoom","resolvedViewportZoom","viewportZoomOption","selection","useCanvasSelection","selectionOptions","pathEditState","usePathEditState","pathEdit","isSelectedNode","id","selectToolWithDefaults","selectionRef","useLatest","useNodeKinds","routing","composedAlphaFor","composeAlphaFor","alphaFor","viewLayerGate","useViewLayerGate","layerVisibility","layerOrder","adapter","useSceneAdapter","internalSelect","internalPickEvery","internalPickBest","internalBoundsOf","internalBoundsOfPose","internalPlaneOfNode","internalMoveOptions","useSceneSelectTool","viewRef","getNodeAtPoint","useNodeAtPoint","enabled","useEnabledFeatures","features","internalTools","toolsTakeover","useCanvasTools","longPress","featureContributions","useFeatureBindings","getNodeAtPointRef","onDoubleClickObserver","useHitObserver","onDoubleClick","onClickObserver","onClick","rotateOff","resolvedActions","actionsMuting","actions","actionsRegistry","useActionsRegistry","useCanvasDispatcher","wiredLayers","useSceneCanvasLayers","animator","previewIdsExtra","trackHoverOn","useSceneHover","chromeVisibility","chromeRules","useChromeRules","getIsVisibleForCanvas","getRuleCtxForCanvas","useSurfaceChromeCaps","ingestionClipboard","useCanvasIngestion","ingestion","addedViews","useAddedViews","canvasReady","useSceneCanvasHandle","viewInputs","kindOfNode","chromeCaps","rotationBadge","useTestHook","tools","ViewInputsProvider","PointerProviderIfRoot","Canvas","handleRef","DevHuds","cursorCoordsHud","pickHud","modalityHud","PointerPublisher","StandardActionsRegistrar","standardActionsExclude","toolOptions","GestureDispatcherMounter","enableGestureDispatcher","enableKeybindings","ToolKeybindingsMounter","CanvasView","v","i","contributionEntries","children","SceneCanvasInnerForwardRef","forwardRef","SceneCanvasWrapper","InputScope","DeviceProfileProvider","device","ViewRegistryProvider","SceneCanvas","BUILTIN_TOOL_IDS","DEFAULT_HANDLE_SIZE","SCENE_CANVAS_FEATURES","rotateAroundAABBCenter"],"sources":["../../src/canvas/SceneCanvas.tsx"],"sourcesContent":["/**\n * `<SceneCanvas>` — `<Canvas>` wired to a `Scene` primitive. Bare, it only renders: behavior\n * comes from the `features` presets (`canvas/SceneCanvas/features.ts`), each of which turns on\n * its own actions, tools, ambient bindings, and chrome.\n *\n * A consumer needing custom tools can pass `tools={useTools(...)}` and SceneCanvas forwards it\n * as-is — the internal tool registry is ignored in that case.\n */\nimport { getActiveModeFor } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { InputScope, useActionsRegistry } from '@weasel-js/routing/react';\nimport { sceneFromJSON } from 'core/scene/scene';\nimport { isSerializedScene } from 'core/scene/serialization';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { useCanvasCamera } from './SceneCanvas/useCanvasCamera';\nimport { useHeldModifiers } from './SceneCanvas/useHeldModifiers';\nimport { useCanvasIngestion } from 'features/ingestion/useCanvasIngestion';\nimport { isSelectedNode } from 'features/paths/pathEditState';\nimport { usePathEditState } from 'features/paths/usePathEdit';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type React from 'react';\nimport { forwardRef, useEffect, useMemo, useRef, useState } from 'react';\nimport { DeviceProfileProvider, useDeviceProfile } from '../core/device/useDeviceProfile';\nimport { dlog } from '../debug/flag';\nimport type { DebugConfig } from '../debug/types';\nimport type { ReflowTransition } from '../layout/types';\nimport { useTestHook } from '../test-hook/useTestHook';\nimport { Canvas } from './Canvas';\nimport { CanvasView } from './CanvasView';\nimport { DevHuds } from './SceneCanvas/DevHuds';\nimport { GestureDispatcherMounter } from './SceneCanvas/GestureDispatcherMounter';\nimport { PointerProviderIfRoot, PointerPublisher } from './SceneCanvas/PointerProviderIfRoot';\nimport { StandardActionsRegistrar } from './SceneCanvas/StandardActionsRegistrar';\nimport { ToolKeybindingsMounter } from './SceneCanvas/ToolKeybindingsMounter';\nimport type { FeatureBindingOptions } from './SceneCanvas/features';\nimport type { BridgeAdapter, SceneCanvasProps } from './SceneCanvas/props';\nimport { actionsMuting } from './SceneCanvas/useActionsPropResolver';\nimport { useCanvasDispatcher } from './SceneCanvas/useCanvasDispatcher';\nimport { useCanvasSelection } from './SceneCanvas/useCanvasSelection';\nimport { useCanvasTools, useEnabledFeatures, useFeatureBindings } from './SceneCanvas/useCanvasTools';\nimport { contributionEntries } from './SceneCanvas/useContributionRoles';\nimport { useNodeAtPoint } from './SceneCanvas/useNodeAtPoint';\nimport { useNodeKinds } from './SceneCanvas/useNodeKinds';\nimport { useAddedViews, useSceneCanvasHandle } from './SceneCanvas/useSceneCanvasHandle';\nimport { useSceneCanvasLayers } from './SceneCanvas/useSceneCanvasLayers';\nimport { useChromeRules, useSceneHover, useSurfaceChromeCaps } from './SceneCanvas/useSceneChrome';\nimport { useSceneRedrawSources } from './SceneCanvas/useSceneRedrawSources';\nimport { useSceneSelectTool } from './SceneCanvas/useSceneSelectTool';\nimport { useViewLayerGate } from './SceneCanvas/useViewLayerGate';\nimport { viewportZoomOption } from './SceneCanvas/useViewportActions';\nimport type { CanvasExtensionApi, SceneCanvasApi } from './canvasExtension';\nimport { useSceneAdapter } from './useSceneAdapter';\nimport { composeAlphaFor } from './sceneSlotWiring';\nimport { useHitObserver } from './useHitObserver';\nimport { ViewInputsProvider, type SurfaceViewInputs } from './viewInputs';\nimport { ViewRegistryProvider } from './viewRegistry';\nexport { SCENE_CANVAS_FEATURES } from './SceneCanvas/features';\nexport type { Feature } from './SceneCanvas/features';\nexport type { BuiltinToolOptions } from './SceneCanvas/useBuiltinShapeTools';\nexport { defaultDrawOne } from './defaultDrawOne';\nexport { rotateAroundAABBCenter } from './poseRotation';\n\n/** `<SceneCanvas debug>` minus the flag only SceneCanvas reads. */\nfunction canvasDebug(debug: (DebugConfig & { slops?: boolean }) | false): DebugConfig | false {\n  if (debug === false) return false;\n  const { slops: _slops, ...rest } = debug;\n  return rest;\n}\n\nfunction SceneCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  const {\n    scene: sceneInput,\n    geometry,\n    poseDescriptor,\n    selectTool: selectToolOpts,\n    insertNodeFactories,\n    insertPaint,\n    ingestion,\n    layoutDropTarget,\n    reflowTransition,\n    geometryProjection,\n    routing,\n    selection: selectionProp,\n    selectionOptions,\n    selectable = true,\n    tools: toolsProp,\n    features,\n    enableKeybindings = true,\n    claimKeys = false,\n    enableGestureDispatcher = true,\n    onToolsCreated,\n    defaultTools,\n    toolOptions,\n    initialActiveTool,\n    ambient,\n    versionCheck,\n    longPress,\n    viewport,\n    layers,\n    actions, tune,\n    describeKind,\n    animator,\n    views: viewDescriptors,\n    children,\n    debug,\n    alphaFor,\n    layerVisibility,\n    layerOrder,\n    isPointerInteractive,\n    onDoubleClick,\n    onClick,\n    chromeVisibility,\n    modes,\n    pathEdit,\n    getFocused: getFocusedProp,\n    cursorCoordsHud, pickHud, modalityHud,\n    view, onViewChange, defaultView, viewBounds, redrawOn: redrawOnProp,\n    ...restProps\n  } = props;\n\n  const descriptor = (poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const deviceProfile = useDeviceProfile();\n\n  // `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked\n  // once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).\n  const [bakedScene] = useState<Scene<TData, TLayer, TPose> | null>(\n    () => (isSerializedScene<TData, TLayer, TPose>(sceneInput) ? sceneFromJSON(sceneInput, {}) : null),\n  );\n  const scene = bakedScene ?? (sceneInput as Scene<TData, TLayer, TPose>);\n\n  const getActiveMode = useMemo(() => (modes ? getActiveModeFor(modes) : undefined), [modes]);\n  const heldModifiers = useHeldModifiers();\n  const redrawOn = useSceneRedrawSources({ supplied: redrawOnProp, scene, heldModifiers, animator, modes });\n\n  // The canvas element, kept here so the dispatcher can attach its input listeners even when\n  // the consumer passes their own forwarded ref, and the full handle, for `requestRedraw`.\n  const internalCanvasRef = useRef<HTMLElement | null>(null);\n  const canvasApiRef = useRef<CanvasExtensionApi | null>(null);\n\n  useEffect(() => {\n    dlog('scene-canvas', 'mount');\n    return () => dlog('scene-canvas', 'unmount');\n  }, []);\n\n  const { viewState, viewAnimation, camera } = useCanvasCamera({\n    view, defaultView, onViewChange, viewBounds,\n    width: restProps.width,\n    height: restProps.height,\n    requestRedraw: () => { canvasApiRef.current?.requestRedraw(); },\n  });\n  const { viewRef } = viewState;\n\n  const viewportZoomProp = viewport?.zoom;\n  const animatedZoom = viewport?.animatedZoom;\n  const resolvedViewportZoom = useMemo(\n    () => viewportZoomOption(viewportZoomProp, animatedZoom),\n    [viewportZoomProp, animatedZoom],\n  );\n\n  const selection = useCanvasSelection({\n    scene, supplied: selectionProp, options: selectionOptions, selectable, describeKind,\n  });\n\n  // `isAllowed` is absent, not a predicate, when no mode registry is wired:\n  // see `PathEditSource.isAllowed`.\n  const pathEditState = usePathEditState({\n    host: pathEdit,\n    isAllowed: getActiveMode\n      ? () => getActiveMode().allowedCapabilities.has('edits-anchors')\n      : undefined,\n    isSelectedNode: (id) => isSelectedNode(scene, selection, id),\n  });\n\n  const selectToolWithDefaults = useMemo(() => ({\n    // Shift-click belongs to the anchor selection while a path is being\n    // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.\n    extendClickLocked: () => pathEditState.getEditingId() !== '',\n    ...selectToolOpts,\n  }), [selectToolOpts, pathEditState]);\n\n  const selectionRef = useLatest(selection);\n  const { kindOfData, kindOfNode } = useNodeKinds(scene, routing);\n\n  // The painted alpha of a node in this view: the caller's `alphaFor` times any per-node\n  // override alpha. The pick path reads the same number the painter does, or a node faded\n  // to nothing stays clickable.\n  const composedAlphaFor = useMemo(\n    () => composeAlphaFor(scene, alphaFor),\n    [scene, alphaFor],\n  );\n  const viewLayerGate = useViewLayerGate(layerVisibility, layerOrder);\n\n  const adapter = useSceneAdapter(scene, {\n    // `adapterMethods` is memoized; `selection` itself is a fresh object each render.\n    selection: selection.adapterMethods,\n    poseDescriptor: descriptor,\n  });\n\n  const {\n    selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest,\n    boundsOf: internalBoundsOf, boundsOfPose: internalBoundsOfPose, planeOfNode: internalPlaneOfNode,\n    moveOptions: internalMoveOptions,\n  } = useSceneSelectTool({\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    geometry,\n    // The pick tolerance is declared in screen pixels; this is what converts it.\n    getView: () => viewRef.current,\n    // Only when the consumer actually fades something. Without a prop the\n    // composed function is just the override lookup, and the source resolves\n    // that once per walk instead of once per candidate.\n    ...(alphaFor ? { alphaOf: composedAlphaFor } : {}),\n    ...(viewLayerGate ? { layerIsPainted: viewLayerGate } : {}),\n    selectTool: selectToolWithDefaults,\n  });\n\n  const getNodeAtPoint = useNodeAtPoint({\n    pickBest: internalPickBest, nodes: adapter, kindOfData, isPointerInteractive,\n  });\n\n  const enabled = useEnabledFeatures(features, viewport !== undefined);\n  const { tools, internal: internalTools, takeover: toolsTakeover } = useCanvasTools({\n    select: internalSelect,\n    enabled,\n    tools: toolsProp,\n    defaultTools,\n    toolOptions,\n    inertia: viewport?.inertia,\n    ambient,\n    pressFeedback: longPress?.feedback,\n    initialActiveTool,\n    modes,\n    onToolsCreated,\n  });\n  const { contributions: featureContributions, standardActionsExclude } = useFeatureBindings({\n    enabled,\n    tools,\n    move: internalMoveOptions as FeatureBindingOptions['move'],\n    rotate: (selectToolOpts?.rotate || undefined) as FeatureBindingOptions['rotate'],\n  });\n\n  // Rides the gesture dispatcher as an OBSERVER rather than an Action binding because the\n  // prop is a notification, not a behavior: as a binding it would lose first-match-wins to\n  // `enterPathEdit` on every body hit and silently stop firing.\n  const getNodeAtPointRef = useLatest(getNodeAtPoint);\n  const onDoubleClickObserver = useHitObserver(onDoubleClick, getNodeAtPointRef);\n  const onClickObserver = useHitObserver(onClick, getNodeAtPointRef);\n\n  // `selectTool.rotate === false` disables rotation: its action is muted here and its\n  // handle hidden by `useChromeRules`.\n  const rotateOff = selectToolOpts?.rotate === false;\n  const resolvedActions = useMemo<ActionsProp | undefined>(\n    () => (rotateOff ? actionsMuting(actions, 'rotate') : actions),\n    [actions, rotateOff],\n  );\n\n  // The wrapper's `<InputScope>` provides it.\n  const actionsRegistry = useActionsRegistry();\n  const { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra } = useCanvasDispatcher(actionsRegistry);\n\n  const { layers: wiredLayers, rotationBadge, chromeAffordancesRef } = useSceneCanvasLayers({\n    layers,\n    targetScale: deviceProfile.targetScale,\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    alphaFor,\n    colorOverrides: animator?.colorOverrides,\n    boundsOf: internalBoundsOf,\n    planeOfNode: internalPlaneOfNode,\n    previewIds: previewIdsExtra,\n    dispatcher,\n    pathEditState,\n    slops: debug !== undefined && debug !== false && debug.slops === true,\n  });\n\n  const { getHover, canvasRef: trackHoverOn } = useSceneHover({\n    canvasApiRef, viewRef, nodeAtPointRef: getNodeAtPointRef, enabled: chromeVisibility !== undefined,\n  });\n  const chromeRules = useChromeRules({ enabled, selectable, rotateOff, chromeVisibility });\n  const { chromeCaps, getIsVisible: getIsVisibleForCanvas, getRuleCtx: getRuleCtxForCanvas } = useSurfaceChromeCaps({\n    source: {\n      rules: chromeRules,\n      getMode: getActiveMode,\n      getFocused: getFocusedProp,\n      getHover,\n      getModifiers: heldModifiers.get,\n      resizable: selectToolOpts?.resize?.resizable,\n      editingAnchors: () => pathEditState.getEditingId() !== '',\n      device: deviceProfile,\n    },\n    selection: selection.current as readonly NodeId[],\n    viewRef,\n    dispatcher,\n  });\n\n  const { ingest, clipboard: ingestionClipboard } = useCanvasIngestion(\n    adapter, () => actionsRegistry, ingestion,\n  );\n\n  const { views: addedViews, addView } = useAddedViews();\n  // The consumer's handle extends the primitive's with `ingest`, which needs the action stack.\n  const { handleRef, ready: canvasReady } = useSceneCanvasHandle({\n    ref, elementRef: internalCanvasRef, apiRef: canvasApiRef, onElement: trackHoverOn,\n    ingest, viewAnimation, camera, addView,\n  });\n\n  // What a view needs to build its own overlay-aware state. `geometry` is the\n  // same descriptor handed to `<Canvas>`, so the two cannot diverge.\n  const viewInputs = useMemo<SurfaceViewInputs>(() => ({\n    adapter: adapter as unknown as { getPose(id: string): unknown },\n    geometry: descriptor as PoseDescriptor<unknown>,\n    boundsOf: internalBoundsOf,\n    boundsOfPose: internalBoundsOfPose as SurfaceViewInputs['boundsOfPose'],\n    planeOfNode: internalPlaneOfNode,\n    pickEvery: internalPickEvery,\n    pickBest: internalPickBest,\n    kindOfNode,\n    chromeCaps,\n    selectionApi: selection,\n    rotationBadge,\n  }), [adapter, descriptor, internalBoundsOf, internalBoundsOfPose, internalPlaneOfNode,\n       internalPickEvery, internalPickBest, kindOfNode, chromeCaps, selection, rotationBadge]);\n\n  useTestHook({\n    getScene: () => scene as never,\n    getSelectionIds: () => (selection.current as readonly string[] | undefined) ?? [],\n    getView: () => viewRef.current,\n    getActiveToolId: () => tools.active ?? null,\n  });\n\n  return (\n    <ViewInputsProvider value={viewInputs}>\n      <PointerProviderIfRoot>\n        <Canvas<TPose>\n          ref={handleRef}\n          adapter={adapter}\n          selection={selection}\n          poseDescriptor={descriptor}\n          tools={tools}\n          layers={wiredLayers}\n          // The chrome's bounds are the picker's: a node on a parallax plane is\n          // boxed where the plane draws it, and a `geometry.boundsOf` reaches both.\n          boundsOf={internalBoundsOf}\n          boundsOfPose={internalBoundsOfPose}\n          getIsVisible={getIsVisibleForCanvas}\n          // The gesture surface behind `helpersRef.getGestureBounds()` /\n          // `subscribeGestures()` — Canvas has no dispatcher of its own.\n          gestureSource={gestureSource}\n          previewPoseExtra={previewPoseExtra}\n          {...(debug !== undefined ? { debug: canvasDebug(debug) } : {})}\n          contentVersion={scene.getVersion}\n          layerVisibility={layerVisibility}\n          layerOrder={layerOrder}\n          viewState={viewState}\n          redrawOn={redrawOn}\n          {...restProps}\n        />\n        <DevHuds\n          cursorCoords={cursorCoordsHud}\n          pick={pickHud}\n          modality={modalityHud}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          detachedInput={restProps.paintInto ? restProps.inputElement ?? null : undefined}\n          viewRef={viewRef}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n        />\n        <PointerPublisher canvasRef={internalCanvasRef} canvasApiRef={canvasApiRef} />\n        <StandardActionsRegistrar\n          selection={selection}\n          scene={scene}\n          adapter={adapter as unknown as BridgeAdapter}\n          actions={resolvedActions} tune={tune}\n          excludeActions={standardActionsExclude}\n          currentViewRef={viewRef}\n          onViewChange={viewState.setViewFromInput}\n          resizeOptions={selectToolOpts?.resize as UseResizeOptions<unknown> | undefined}\n          poseDescriptor={descriptor as PoseDescriptor<unknown>}\n          geometryProjection={geometryProjection}\n          dispatcher={dispatcher}\n          pickEvery={internalPickEvery}\n          layerIsPainted={viewLayerGate}\n          alphaOf={alphaFor ? composedAlphaFor : undefined}\n          viewportPanEnabled={enabled.has('view') ? (viewport?.pan ?? true) : false}\n          viewportZoom={enabled.has('view') ? resolvedViewportZoom : false}\n          viewportPinchZoom={enabled.has('view') ? (viewport?.pinchZoom ?? true) : false}\n          viewportRecenter={viewport?.recenter}\n          viewAnimation={viewAnimation}\n          editAnchorsExternalState={pathEditState}\n          layoutDropTarget={layoutDropTarget}\n          reflowTransition={reflowTransition as ReflowTransition<unknown> | null | undefined}\n          insertNodeFactories={insertNodeFactories}\n          insertPaint={insertPaint}\n          snapPoint={toolOptions?.snapPoint}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          ingestionResolveSrc={ingestion?.resolveSrc}\n          ingestionSvg={ingestion?.svg}\n          ingestionClipboard={ingestionClipboard}\n        />\n        <GestureDispatcherMounter\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          tools={tools}\n          contributions={featureContributions}\n          enabled={enableGestureDispatcher}\n          keyboard={enableKeybindings}\n          claimKeys={claimKeys}\n          selectionRef={selectionRef}\n          boundsOf={internalBoundsOf}\n          planeOfNode={internalPlaneOfNode}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n          kindOfNode={kindOfNode}\n          viewRef={viewRef}\n          dispatcher={dispatcher}\n          getIsVisibleForCanvas={getIsVisibleForCanvas}\n          getRuleCtx={getRuleCtxForCanvas}\n          targetScale={deviceProfile.targetScale}\n          handleHitRadius={selectToolOpts?.handleHitRadius}\n          rotationBadge={rotationBadge}\n          chromeAffordancesRef={chromeAffordancesRef}\n          onDoubleClick={onDoubleClickObserver}\n          onClick={onClickObserver}\n          longPress={longPress}\n        />\n        <ToolKeybindingsMounter\n          internalTools={internalTools}\n          toolsTakeover={toolsTakeover ?? undefined}\n          enableKeybindings={enableKeybindings}\n          modes={modes}\n          canvasApi={canvasReady ? canvasApiRef.current : null}\n          versionCheck={versionCheck}\n        />\n        {viewDescriptors?.map((v, i) => (\n          <CanvasView key={v.id} {...v} order={v.order ?? i} />\n        ))}\n        {contributionEntries(tools).flatMap((e) => e.views ?? []).map((v) => (\n          <CanvasView key={`contribution:${v.id}`} {...v} />\n        ))}\n        {addedViews.map((v) => <CanvasView key={`added:${v.id}`} {...v} />)}\n        {children}\n      </PointerProviderIfRoot>\n    </ViewInputsProvider>\n  );\n}\n\nconst SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);\n\n// The canvas's input scope sits above `SceneCanvasInner`, whose own hooks\n// (`useTools` among them) must already read this canvas's tool and registries.\n// Its device profile too, so the canvas and everything under it share one.\nfunction SceneCanvasWrapper<TData, TLayer extends string, TPose>(\n  { device, ...props }: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  return (\n    <InputScope yoke={props.yoke}>\n      <DeviceProfileProvider value={device}>\n        <ViewRegistryProvider>\n          <SceneCanvasInnerForwardRef {...(props as SceneCanvasProps<unknown, string, unknown>)} ref={ref} />\n        </ViewRegistryProvider>\n      </DeviceProfileProvider>\n    </InputScope>\n  );\n}\n\n/**\n * The canvas component: renders a `Scene` and wires the interaction stack\n * around it.\n *\n * Mounted bare it renders the scene, keeps a selection no input sets, and\n * runs a gesture dispatcher for whatever bindings the consumer adds. The\n * `features` presets turn the kit's behavior on — `features={['draw']}` is the\n * whole editor: tools, standard actions and their keys, selection chrome,\n * undo. This is the intended entry point; the lower-level primitives it\n * composes are not part of the public surface.\n *\n * Its ref exposes a `SceneCanvasApi` for the imperative operations that do not\n * fit a prop (view control, hit queries, redraw requests).\n */\nexport const SceneCanvas = forwardRef(SceneCanvasWrapper) as <\n  TData, TLayer extends string, TPose,\n>(\n  props: SceneCanvasProps<TData, TLayer, TPose> & { ref?: React.Ref<SceneCanvasApi> },\n) => ReturnType<typeof SceneCanvasInner>;\n\nexport { DEFAULT_HANDLE_SIZE, mergeLayersWithDefaults, BUILTIN_TOOL_IDS } from './SceneCanvas/props';\nexport type {\n  SceneCanvasProps,\n  SceneCanvasHit,\n  SceneCanvasLayers,\n  SceneCanvasLongPress,\n  BuiltinToolId,\n} from './SceneCanvas/props';\nexport type { CoordTraceEntry } from './SceneCanvas/coordTrace';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,SAASA,GAAY,GAAyE;CAC5F,IAAIC,MAAU,IAAO,OAAO;CAC5B,IAAM,EAAE,OAAOC,GAAQ,GAAGC,MAASF;CACnC,OAAOE;AACT;AAEA,SAASC,EACP,GACA,IACA;CACA,IAAM,EACJ,OAAOC,GACP,cACA,oBACA,YAAYC,GACZ,wBACA,iBACA,cACA,qBACA,qBACA,uBACA,aACA,WAAWC,IACX,sBACA,gBAAa,IACb,OAAOC,IACP,cACA,uBAAoB,IACpB,gBAAY,IACZ,8BAA0B,IAC1B,oBACA,kBACA,iBACA,uBACA,aACA,kBACA,eACA,aACA,YACA,YAAS,UACT,kBACA,cACA,OAAOC,IACP,cACA,UACA,aACA,oBACA,gBACA,0BACA,mBACA,aACA,qBACA,UACA,cACA,YAAYC,IACZ,qBAAiB,aAAS,iBAC1B,UAAM,kBAAc,iBAAa,gBAAY,UAAUC,IACvD,GAAGC,MACDC,GAEEC,IAAcC,MAAkBC,IAChCC,IAAgBC,EAAiB,GAIjC,CAACC,MAAcC,SACZC,GAAwChB,CAAU,IAAIiB,GAAcjB,GAAY,CAAC,CAAC,IAAI,IAC/F,GACMkB,IAAQJ,MAAed,GAEvBmB,IAAgBC,QAAeC,IAAQC,GAAiBD,CAAK,IAAI,KAAA,GAAY,CAACA,CAAK,CAAC,GACpFE,KAAgBC,GAAiB,GACjCC,KAAWC,GAAsB;EAAE,UAAUpB;EAAc;EAAO;EAAe;EAAU;CAAM,CAAC,GAIlGqB,IAAoBC,EAA2B,IAAI,GACnDC,IAAeD,EAAkC,IAAI;CAE3D,UACEE,EAAK,gBAAgB,OAAO,SACfA,EAAK,gBAAgB,SAAS,IAC1C,CAAC,CAAC;CAEL,IAAM,EAAE,cAAW,kBAAe,eAAWC,GAAgB;EAC3D;EAAM;EAAa;EAAc;EACjC,OAAOxB,EAAU;EACjB,QAAQA,EAAU;EAClB,qBAAqB;GAAE,EAAa,SAAS,cAAc;EAAG;CAChE,CAAC,GACK,EAAE,eAAYyB,GAEdC,IAAmBC,GAAU,MAC7BC,IAAeD,GAAU,cACzBE,KAAuBhB,QACrBiB,GAAmBJ,GAAkBE,CAAY,GACvD,CAACF,GAAkBE,CAAY,CACjC,GAEMG,IAAYC,GAAmB;EACnC;EAAO,UAAUrC;EAAe,SAASsC;EAAkB;EAAY;CACzE,CAAC,GAIKC,IAAgBC,GAAiB;EACrC,MAAMC;EACN,WAAWxB,UACDA,EAAc,CAAC,CAAC,oBAAoB,IAAI,eAAe,IAC7D,KAAA;EACJ,iBAAiB,MAAOyB,GAAe1B,GAAOoB,GAAWO,CAAE;CAC7D,CAAC,GAEKC,KAAyB1B,SAAe;EAG5C,yBAAyBqB,EAAc,aAAa,MAAM;EAC1D,GAAGxC;CACL,IAAI,CAACA,GAAgBwC,CAAa,CAAC,GAE7BM,KAAeC,EAAUV,CAAS,GAClC,EAAE,gBAAY,kBAAeW,GAAa/B,GAAOgC,EAAO,GAKxDC,IAAmB/B,QACjBgC,GAAgBlC,GAAOmC,CAAQ,GACrC,CAACnC,GAAOmC,CAAQ,CAClB,GACMC,IAAgBC,GAAiBC,GAAiBC,EAAU,GAE5DC,IAAUC,GAAgBzC,GAAO;EAErC,WAAWoB,EAAU;EACrB,gBAAgB7B;CAClB,CAAC,GAEK,EACJ,YAAYmD,IAAgB,WAAWC,GAAmB,UAAUC,GACpE,UAAUC,GAAkB,cAAcC,GAAsB,aAAaC,GAC7E,aAAaC,OACXC,GAAmB;EACrB;EACA;EACA,gBAAgB1D;EAChB;EAEA,eAAe2D,EAAQ;EAIvB,GAAIf,IAAW,EAAE,SAASF,EAAiB,IAAI,CAAC;EAChD,GAAIG,IAAgB,EAAE,gBAAgBA,EAAc,IAAI,CAAC;EACzD,YAAYR;CACd,CAAC,GAEKuB,KAAiBC,GAAe;EACpC,UAAUR;EAAkB,OAAOJ;EAAS;EAAY;CAC1D,CAAC,GAEKa,IAAUC,GAAmBC,IAAUvC,MAAa,KAAA,CAAS,GAC7D,EAAE,UAAO,UAAUwC,IAAe,UAAUC,OAAkBC,GAAe;EACjF,QAAQhB;EACR;EACA,OAAOzD;EACP;EACA;EACA,SAAS+B,GAAU;EACnB;EACA,eAAe2C,IAAW;EAC1B;EACA;EACA;CACF,CAAC,GACK,EAAE,eAAeC,IAAsB,+BAA2BC,GAAmB;EACzF;EACA;EACA,MAAMb;EACN,QAASjE,GAAgB,UAAU,KAAA;CACrC,CAAC,GAKK+E,IAAoBhC,EAAUqB,EAAc,GAC5CY,KAAwBC,EAAeC,IAAeH,CAAiB,GACvEI,KAAkBF,EAAeG,IAASL,CAAiB,GAI3DM,IAAYrF,GAAgB,WAAW,IACvCsF,KAAkBnE,QACfkE,IAAYE,GAAcC,GAAS,QAAQ,IAAIA,GACtD,CAACA,GAASH,CAAS,CACrB,GAGMI,KAAkBC,GAAmB,GACrC,EAAE,eAAY,mBAAe,qBAAiB,yBAAqBC,GAAoBF,EAAe,GAEtG,EAAE,QAAQG,IAAa,kBAAe,6BAAyBC,GAAqB;EACxF;EACA,aAAalF,EAAc;EAC3B;EACA;EACA,gBAAgBH;EAChB;EACA,gBAAgBsF,IAAU;EAC1B,UAAUhC;EACV,aAAaE;EACb,YAAY+B;EACZ;EACA;EACA,OAAOpG,MAAU,KAAA,KAAaA,MAAU,MAASA,EAAM,UAAU;CACnE,CAAC,GAEK,EAAE,cAAU,WAAWqG,OAAiBC,GAAc;EAC1D;EAAc;EAAS,gBAAgBlB;EAAmB,SAASmB,MAAqB,KAAA;CAC1F,CAAC,GACKC,KAAcC,GAAe;EAAE;EAAS;EAAY;EAAW;CAAiB,CAAC,GACjF,EAAE,gBAAY,cAAcC,IAAuB,YAAYC,OAAwBC,GAAqB;EAChH,QAAQ;GACN,OAAOJ;GACP,SAASjF;GACT,YAAYd;GACZ;GACA,cAAckB,GAAc;GAC5B,WAAWtB,GAAgB,QAAQ;GACnC,sBAAsBwC,EAAc,aAAa,MAAM;GACvD,QAAQ7B;EACV;EACA,WAAW0B,EAAU;EACrB;EACA;CACF,CAAC,GAEK,EAAE,YAAQ,WAAWmE,OAAuBC,GAChDhD,SAAegC,IAAiBiB,CAClC,GAEM,EAAE,OAAOC,IAAY,gBAAYC,GAAc,GAE/C,EAAE,eAAW,OAAOC,OAAgBC,GAAqB;EAC7D;EAAK,YAAYpF;EAAmB,QAAQE;EAAc,WAAWoE;EACrE;EAAQ;EAAe;EAAQ;CACjC,CAAC,GAIKe,KAAa5F,SAAkC;EAC1C;EACT,UAAUX;EACV,UAAUsD;EACV,cAAcC;EACd,aAAaC;EACb,WAAWJ;EACX,UAAUC;EACV;EACA;EACA,cAAcxB;EACd;CACF,IAAI;EAACoB;EAASjD;EAAYsD;EAAkBC;EAAsBC;EAC7DJ;EAAmBC;EAAkBmD;EAAYC;EAAY5E;EAAW6E;CAAa,CAAC;CAS3F,OAPAC,GAAY;EACV,gBAAgBlG;EAChB,uBAAwBoB,EAAU,WAA6C,CAAC;EAChF,eAAe8B,EAAQ;EACvB,uBAAuBiD,EAAM,UAAU;CACzC,CAAC,GAGC,kBAACC,IAAD;EAAoB,OAAON;EACzB,UAAA,mBAACO,IAAD,EAAA,UAAA;GACE,kBAACC,IAAD;IACE,KAAKC;IACI;IACE;IACX,gBAAgBhH;IACT;IACP,QAAQoF;IAGR,UAAU9B;IACV,cAAcC;IACd,cAAcsC;IAGC;IACG;IAClB,GAAK1G,MAAU,KAAA,IAA4C,CAAC,IAAjC,EAAE,OAAOD,GAAYC,CAAK,EAAE;IACvD,gBAAgBsB,EAAM;IACL;IACL;IACD;IACD;IACV,GAAIX;GACL,CAAA;GACD,kBAACmH,IAAD;IACE,cAAcC;IACd,MAAMC;IACN,UAAUC;IACV,WAAWlG;IACG;IACd,eAAepB,EAAU,YAAYA,EAAU,gBAAgB,OAAO,KAAA;IAC7D;IACT,WAAWsD;IACX,UAAUC;GACX,CAAA;GACD,kBAACgE,IAAD;IAAkB,WAAWnG;IAAiC;GAAe,CAAA;GAC7E,kBAACoG,IAAD;IACa;IACJ;IACE;IACT,SAASxC;IAAuB;IAChC,gBAAgByC;IAChB,gBAAgB5D;IAChB,cAAcpC,EAAU;IACxB,eAAe/B,GAAgB;IAC/B,gBAAgBQ;IACI;IACR;IACZ,WAAWoD;IACX,gBAAgBP;IAChB,SAASD,IAAWF,IAAmB,KAAA;IACvC,oBAAoBoB,EAAQ,IAAI,MAAM,IAAKrC,GAAU,OAAO,KAAQ;IACpE,cAAcqC,EAAQ,IAAI,MAAM,IAAInC,KAAuB;IAC3D,mBAAmBmC,EAAQ,IAAI,MAAM,IAAKrC,GAAU,aAAa,KAAQ;IACzE,kBAAkBA,GAAU;IACb;IACf,0BAA0BO;IACR;IACA;IACG;IACR;IACb,WAAWwF,IAAa;IACxB,WAAWtG;IACG;IACd,qBAAqBgF,GAAW;IAChC,cAAcA,GAAW;IACL;GACrB,CAAA;GACD,kBAACuB,IAAD;IACE,WAAWvG;IACG;IACP;IACP,eAAemD;IACf,SAASqD;IACT,UAAUC;IACC;IACG;IACd,UAAUrE;IACV,aAAaE;IACb,WAAWJ;IACX,UAAUC;IACE;IACH;IACG;IACW;IACvB,YAAYyC;IACZ,aAAa3F,EAAc;IAC3B,iBAAiBX,GAAgB;IAClB;IACO;IACtB,eAAegF;IACf,SAASG;IACE;GACZ,CAAA;GACD,kBAACiD,IAAD;IACiB;IACf,eAAe1D,MAAiB,KAAA;IACb;IACZ;IACP,WAAWmC,KAAcjF,EAAa,UAAU;IAClC;GACf,CAAA;GACAzB,IAAiB,KAAK,GAAG,MACxB,kBAACkI,GAAD;IAAuB,GAAIC;IAAG,OAAOA,EAAE,SAASC;GAAI,GAAnCD,EAAE,EAAiC,CACrD;GACAE,GAAoBpB,CAAK,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,MAC7D,kBAACiB,GAAD,EAAyC,GAAIC,EAAI,GAAhC,gBAAgBA,EAAE,IAAc,CAClD;GACA3B,GAAW,KAAK,MAAM,kBAAC0B,GAAD,EAAkC,GAAIC,EAAI,GAAzB,SAASA,EAAE,IAAc,CAAC;GACjEG;EACoB,EAAA,CAAA;CACL,CAAA;AAExB;AAEA,IAAMC,IAA6BC,EAAW7I,CAAgB;AAK9D,SAAS8I,EACP,EAAE,WAAQ,GAAGrI,KACb,IACA;CACA,OACE,kBAACsI,IAAD;EAAY,MAAMtI,EAAM;EACtB,UAAA,kBAACuI,GAAD;GAAuB,OAAOC;GAC5B,UAAA,kBAACC,IAAD,EAAA,UACE,kBAACN,GAAD;IAA4B,GAAKnI;IAA2D;GAAM,CAAA,EAC9E,CAAA;EACD,CAAA;CACb,CAAA;AAEhB;AAgBA,IAAa0I,IAAcN,EAAWC,CAAkB"}

package/dist/canvas/SceneViewCanvas.js

@@ -1,6 +1,6 @@
 import { normalizeView as e } from "../core/viewport/view.js";
 import { useCanvasSurface as t } from "./useCanvasSurface.js";
-import { surfaceBox as n } from "./surfaceBox.js";
+import { SurfaceCanvas as n } from "./SurfaceCanvas.js";
 import { sceneViewFrame as r } from "./sceneViewRender.js";
 import { useCallback as i, useEffect as a, useRef as o, useSyncExternalStore as s } from "react";
 import { assignRef as c } from "@weasel-js/react";
@@ -36,11 +36,11 @@ function u(u) {
 		target: T,
 		paintOnCommit: !0
 	});
-	return a(() => d.overrides.subscribe(D), [d, D]), a(() => y?.onTick(D), [y, D]), /* @__PURE__ */ l("canvas", {
+	return a(() => d.overrides.subscribe(D), [d, D]), a(() => y?.onTick(D), [y, D]), /* @__PURE__ */ l(n, {
 		ref: E,
 		width: f,
 		height: p,
-		...n(f, p, b)
+		className: b
 	});
 }
 var d = u;

package/dist/canvas/SceneViewCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SceneViewCanvas.js","names":["SceneViewCanvasInner","props","view","normalizeView","scene","localRef","useRef","setCanvasRef","useCallback","el","assignRef","canvasRef","useCanvasSurface","canvas","commands","sceneViewFrame","animator","lease","useEffect","requestRedraw","surfaceBox","width","height","className","SceneViewCanvas"],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * It paints through `useFrameLoop` rather than from React: a render and an\n * override commit both just mark the surface dirty. The mount paint is\n * synchronous, so the first frame the user sees is the scene, and nothing\n * paints while the canvas is off screen or the tab is hidden.\n */\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport { surfaceBox } from './surfaceBox';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '@weasel-js/animator';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {\n  /** Scene to render. The component subscribes to it and repaints when it\n   *  changes. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer\n   *  size) and the renderer's coordinate space. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform — a world-space annotation over the scene. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for the `<canvas>`. Its size is `width` × `height`\n   *  unless a rule on this class sizes it. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  const paint = (lease: CanvasRendererLease): boolean => {\n    const canvas = localRef.current;\n    if (!canvas) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const { requestRedraw } = useCanvasSurface(paint, { target: localRef, paintOnCommit: true });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n\n  return (\n    <canvas\n      ref={setCanvasRef}\n      width={width}\n      height={height}\n      {...surfaceBox(width, height, className)}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. It attaches no event listeners;\n * consumers attach their own through `canvasRef`, a plain prop because\n * `forwardRef` erases the component's generics. `width` and `height` are CSS\n * pixels and size the drawing buffer; a `className` rule that sizes the\n * element stretches that buffer to fit.\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;AA2EA,SAASA,EACP,GACA;CACA,IAAM,EACJ,UAAO,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eACzE,aAAU,cAAW,cAAW,SAAM,mBACpCC,GACEC,IAAOC,EAAcF,EAAM,IAAI;CAIrC,EAAqBG,EAAM,WAAWA,EAAM,YAAYA,EAAM,UAAU;CAExE,IAAMC,IAAWC,EAAiC,IAAI,GAEhDC,IAAeC,GAAa,MAAuC;EAEvE,AADA,EAAS,UAAUC,GACnBC,EAAUC,GAAWF,CAAE;CACzB,GAAG,CAACE,CAAS,CAAC,GAqBR,EAAE,qBAAkBC,GAnBX,MAAwC;EACrD,IAAMC,IAASR,EAAS;EACxB,IAAI,CAACQ,GAAQ,OAAO;EACpB,IAAMC,IAAWC,EAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgBC,GAAU;GAC1B;GACA;EACF,CAAC;EACD,OAAOC,EAAM,MAAMJ,GAAQC,GAAUZ,GAAM;GAAE;GAAO;EAAO,CAAC;CAC9D,GACkD;EAAE,QAAQG;EAAU,eAAe;CAAK,CAAC;CAO3F,OAHAa,QAAgBd,EAAM,UAAU,UAAUe,CAAa,GAAG,CAACf,GAAOe,CAAa,CAAC,GAChFD,QAAgBF,GAAU,OAAOG,CAAa,GAAG,CAACH,GAAUG,CAAa,CAAC,GAGxE,kBAAC,UAAD;EACE,KAAKZ;EACE;EACC;EACR,GAAIa,EAAWC,GAAOC,GAAQC,CAAS;CACxC,CAAA;AAEL;AASA,IAAaC,IAAkBxB"}
+{"version":3,"file":"SceneViewCanvas.js","names":["SceneViewCanvasInner","props","view","normalizeView","scene","localRef","useRef","setCanvasRef","useCallback","el","assignRef","canvasRef","useCanvasSurface","canvas","commands","sceneViewFrame","animator","lease","useEffect","requestRedraw","SurfaceCanvas","SceneViewCanvas"],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * It paints through `useFrameLoop` rather than from React: a render and an\n * override commit both just mark the surface dirty. The mount paint is\n * synchronous, so the first frame the user sees is the scene, and nothing\n * paints while the canvas is off screen or the tab is hidden.\n */\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport { SurfaceCanvas } from './SurfaceCanvas';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '@weasel-js/animator';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {\n  /** Scene to render. The component subscribes to it and repaints when it\n   *  changes. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer\n   *  size) and the renderer's coordinate space. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform — a world-space annotation over the scene. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for the `<canvas>`. Its size is `width` × `height`\n   *  unless a rule on this class sizes it. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  const paint = (lease: CanvasRendererLease): boolean => {\n    const canvas = localRef.current;\n    if (!canvas) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const { requestRedraw } = useCanvasSurface(paint, { target: localRef, paintOnCommit: true });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n\n  return (\n    <SurfaceCanvas\n      ref={setCanvasRef}\n      width={width}\n      height={height}\n      className={className}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. It attaches no event listeners;\n * consumers attach their own through `canvasRef`, a plain prop because\n * `forwardRef` erases the component's generics. `width` and `height` are CSS\n * pixels and size the drawing buffer; a `className` rule that sizes the\n * element stretches that buffer to fit.\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;AA2EA,SAASA,EACP,GACA;CACA,IAAM,EACJ,UAAO,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eACzE,aAAU,cAAW,cAAW,SAAM,mBACpCC,GACEC,IAAOC,EAAcF,EAAM,IAAI;CAIrC,EAAqBG,EAAM,WAAWA,EAAM,YAAYA,EAAM,UAAU;CAExE,IAAMC,IAAWC,EAAiC,IAAI,GAEhDC,IAAeC,GAAa,MAAuC;EAEvE,AADA,EAAS,UAAUC,GACnBC,EAAUC,GAAWF,CAAE;CACzB,GAAG,CAACE,CAAS,CAAC,GAqBR,EAAE,qBAAkBC,GAnBX,MAAwC;EACrD,IAAMC,IAASR,EAAS;EACxB,IAAI,CAACQ,GAAQ,OAAO;EACpB,IAAMC,IAAWC,EAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgBC,GAAU;GAC1B;GACA;EACF,CAAC;EACD,OAAOC,EAAM,MAAMJ,GAAQC,GAAUZ,GAAM;GAAE;GAAO;EAAO,CAAC;CAC9D,GACkD;EAAE,QAAQG;EAAU,eAAe;CAAK,CAAC;CAO3F,OAHAa,QAAgBd,EAAM,UAAU,UAAUe,CAAa,GAAG,CAACf,GAAOe,CAAa,CAAC,GAChFD,QAAgBF,GAAU,OAAOG,CAAa,GAAG,CAACH,GAAUG,CAAa,CAAC,GAGxE,kBAACC,GAAD;EACE,KAAKb;EACE;EACC;EACG;CACZ,CAAA;AAEL;AASA,IAAac,IAAkBrB"}

package/dist/canvas/SurfaceCanvas.js

@@ -0,0 +1,40 @@
+import { forwardRef as e, useCallback as t } from "react";
+import { assignRef as n } from "@weasel-js/react";
+import { jsx as r } from "react/jsx-runtime";
+//#region src/canvas/SurfaceCanvas.tsx
+var i = ":where([data-wzl-surface]) { width: var(--wzl-surface-width); height: var(--wzl-surface-height); }", a = /* @__PURE__ */ new WeakSet();
+function o(e) {
+	let t = e.ownerDocument, n = e.getRootNode(), r = "host" in n ? n : t;
+	if (a.has(r)) return;
+	a.add(r);
+	let o = t.defaultView?.CSSStyleSheet;
+	if (o && "replaceSync" in o.prototype && Array.isArray(r.adoptedStyleSheets)) {
+		let e = new o();
+		e.replaceSync(i), r.adoptedStyleSheets = [...r.adoptedStyleSheets, e];
+		return;
+	}
+	let s = t.createElement("style");
+	s.textContent = i, ("host" in r ? r : r.head).appendChild(s);
+}
+var s = e(function({ width: e, height: i, className: a, style: s, tabIndex: c }, l) {
+	let u = t((e) => {
+		e && o(e), n(l, e);
+	}, [l]), d = {
+		...s,
+		"--wzl-surface-width": `${e}px`,
+		"--wzl-surface-height": `${i}px`
+	};
+	return /* @__PURE__ */ r("canvas", {
+		ref: u,
+		width: e,
+		height: i,
+		tabIndex: c,
+		className: a,
+		style: d,
+		"data-wzl-surface": ""
+	});
+});
+//#endregion
+export { i as SURFACE_RULE, s as SurfaceCanvas, o as adoptSurfaceRule };
+
+//# sourceMappingURL=SurfaceCanvas.js.map

package/dist/canvas/SurfaceCanvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SurfaceCanvas.js","names":["SURFACE_RULE","adopted","adoptSurfaceRule","doc","el","node","root","Sheet","sheet","style","SurfaceCanvas","forwardRef","setRef","useCallback","assignRef","ref","sized","width","height"],"sources":["../../src/canvas/SurfaceCanvas.tsx"],"sourcesContent":["import { forwardRef, useCallback, type CSSProperties } from 'react';\nimport { assignRef } from '@weasel-js/react';\n\n/** Where an element's styles come from. */\ntype StyleRoot = Document | ShadowRoot;\n\n/** The CSS size of a canvas the kit renders: its `width` and `height` props.\n *  Zero specificity, so a class the consumer passes resizes the element. */\nexport const SURFACE_RULE =\n  ':where([data-wzl-surface]) { width: var(--wzl-surface-width); height: var(--wzl-surface-height); }';\n\nlet adopted = new WeakSet<StyleRoot>();\n\n/**\n * Hold {@link SURFACE_RULE} in the root `el`'s styles come from: its shadow\n * root, else its document. Once per root, and never taken back out.\n */\nexport function adoptSurfaceRule(el: Element): void {\n  const doc = el.ownerDocument;\n  const node = el.getRootNode();\n  const root: StyleRoot = 'host' in node ? (node as ShadowRoot) : doc;\n  if (adopted.has(root)) return;\n  adopted.add(root);\n  const Sheet = doc.defaultView?.CSSStyleSheet;\n  if (Sheet && 'replaceSync' in Sheet.prototype && Array.isArray(root.adoptedStyleSheets)) {\n    // From the root's own window: a constructed sheet cannot be adopted across documents.\n    const sheet = new Sheet();\n    sheet.replaceSync(SURFACE_RULE);\n    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];\n    return;\n  }\n  const style = doc.createElement('style');\n  style.textContent = SURFACE_RULE;\n  ('host' in root ? root : root.head).appendChild(style);\n}\n\n/** Test seam: forgets which roots hold the rule. */\nexport function __resetSurfaceRule(): void {\n  adopted = new WeakSet();\n}\n\nexport interface SurfaceCanvasProps {\n  /** CSS pixels. The renderer sizes only the drawing buffer, so without the\n   *  rule this element holds it is as large as its buffer: `dpr` times too big. */\n  width: number;\n  height: number;\n  className?: string;\n  style?: CSSProperties;\n  tabIndex?: number;\n}\n\n/** The `<canvas>` a kit component paints into, `width` × `height` CSS pixels. */\nexport const SurfaceCanvas = forwardRef<HTMLCanvasElement, SurfaceCanvasProps>(\n  function SurfaceCanvas({ width, height, className, style, tabIndex }, ref) {\n    // Stable while `ref` is, so a commit does not detach the element.\n    const setRef = useCallback((el: HTMLCanvasElement | null) => {\n      if (el) adoptSurfaceRule(el);\n      assignRef(ref, el);\n    }, [ref]);\n    const sized = { ...style, '--wzl-surface-width': `${width}px`, '--wzl-surface-height': `${height}px` };\n    return (\n      <canvas\n        ref={setRef}\n        width={width}\n        height={height}\n        tabIndex={tabIndex}\n        className={className}\n        style={sized as CSSProperties}\n        data-wzl-surface=\"\"\n      />\n    );\n  },\n);\n"],"mappings":";;;;AAQA,IAAaA,IACX,sGAEEC,oBAAU,IAAI,QAAmB;AAMrC,SAAgBC,EAAiB,GAAmB;CAClD,IAAMC,IAAMC,EAAG,eACTC,IAAOD,EAAG,YAAY,GACtBE,IAAkB,UAAUD,IAAQA,IAAsBF;CAChE,IAAIF,EAAQ,IAAIK,CAAI,GAAG;CACvB,EAAQ,IAAIA,CAAI;CAChB,IAAMC,IAAQJ,EAAI,aAAa;CAC/B,IAAII,KAAS,iBAAiBA,EAAM,aAAa,MAAM,QAAQD,EAAK,kBAAkB,GAAG;EAEvF,IAAME,IAAQ,IAAID,EAAM;EAExB,AADAC,EAAM,YAAYR,CAAY,GAC9B,EAAK,qBAAqB,CAAC,GAAGM,EAAK,oBAAoBE,CAAK;EAC5D;CACF;CACA,IAAMC,IAAQN,EAAI,cAAc,OAAO;CAEvC,AADA,EAAM,cAAcH,IACnB,UAAUM,IAAOA,IAAOA,EAAK,KAAA,CAAM,YAAYG,CAAK;AACvD;AAkBA,IAAaC,IAAgBC,EAC3B,SAAuB,EAAE,UAAO,WAAQ,cAAW,UAAO,eAAY,GAAK;CAEzE,IAAMC,IAASC,GAAa,MAAiC;EAE3D,AADIT,KAAIF,EAAiBE,CAAE,GAC3BU,EAAUC,GAAKX,CAAE;CACnB,GAAG,CAACW,CAAG,CAAC,GACFC,IAAQ;EAAE,GAAGP;EAAO,uBAAuB,GAAGQ,EAAM;EAAK,wBAAwB,GAAGC,EAAO;CAAI;CACrG,OACE,kBAAC,UAAD;EACE,KAAKN;EACE;EACC;EACE;EACC;EACX,OAAOI;EACP,oBAAiB;CAClB,CAAA;AAEL,CACF"}