@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas.js

@@ -1,328 +1,290 @@
-import { DeviceProfileProvider as e, useDeviceProfile as t } from "../core/device/useDeviceProfile.js";
-import { dlog as n } from "../debug/flag.js";
-import { AUTO_POSE_DESCRIPTOR as ee } from "../core/geometry/autoPoseDescriptor.js";
-import { ViewInputsProvider as te } from "./viewInputs.js";
-import { ViewRegistryProvider as ne } from "./viewRegistry.js";
-import { CanvasView as r } from "./CanvasView.js";
-import { rotateAroundAABBCenter as i } from "./poseRotation.js";
-import "./defaultDrawOne.js";
-import { PointerProviderIfRoot as re, PointerPublisher as ie } from "./SceneCanvas/PointerProviderIfRoot.js";
-import { isSerializedScene as ae } from "../core/scene/serialization.js";
-import { sceneFromJSON as oe } from "../core/scene/scene.js";
-import { useCanvasCamera as se } from "./SceneCanvas/useCanvasCamera.js";
-import { useHeldModifiers as ce } from "./SceneCanvas/useHeldModifiers.js";
-import { useCanvasIngestion as le } from "../features/ingestion/useCanvasIngestion.js";
-import { isSelectedNode as ue } from "../features/paths/pathEditState.js";
-import { usePathEditState as de } from "../features/paths/usePathEdit.js";
-import { useTestHook as fe } from "../test-hook/useTestHook.js";
-import { Canvas as pe } from "./Canvas.js";
-import { DevHuds as me } from "./SceneCanvas/DevHuds.js";
-import { GestureDispatcherMounter as he } from "./SceneCanvas/GestureDispatcherMounter.js";
-import { actionsMuting as ge } from "./SceneCanvas/useActionsPropResolver.js";
-import { viewportZoomOption as _e } from "./SceneCanvas/useViewportActions.js";
-import { StandardActionsRegistrar as ve } from "./SceneCanvas/StandardActionsRegistrar.js";
-import { contributionEntries as ye } from "./SceneCanvas/useContributionRoles.js";
-import { ToolKeybindingsMounter as be } from "./SceneCanvas/ToolKeybindingsMounter.js";
-import { useCanvasDispatcher as xe } from "./SceneCanvas/useCanvasDispatcher.js";
-import { useCanvasSelection as Se } from "./SceneCanvas/useCanvasSelection.js";
-import { SCENE_CANVAS_FEATURES as Ce } from "./SceneCanvas/features.js";
-import { BUILTIN_TOOL_IDS as we, DEFAULT_HANDLE_SIZE as a } from "./SceneCanvas/props.js";
-import { useCanvasTools as Te, useEnabledFeatures as Ee, useFeatureBindings as De } from "./SceneCanvas/useCanvasTools.js";
-import { useNodeAtPoint as Oe } from "./SceneCanvas/useNodeAtPoint.js";
-import { useNodeKinds as ke } from "./SceneCanvas/useNodeKinds.js";
-import { useAddedViews as Ae, useSceneCanvasHandle as je } from "./SceneCanvas/useSceneCanvasHandle.js";
-import { composeAlphaFor as Me } from "./sceneSlotWiring.js";
-import { useSceneCanvasLayers as Ne } from "./SceneCanvas/useSceneCanvasLayers.js";
-import { useChromeRules as Pe, useSceneHover as Fe, useSurfaceChromeCaps as Ie } from "./SceneCanvas/useSceneChrome.js";
-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 "./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 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";
+import { DeviceProfileProvider, useDeviceProfile } from "../core/device/useDeviceProfile.js";
+import { AUTO_POSE_DESCRIPTOR } from "../core/geometry/autoPoseDescriptor.js";
+import { ViewRegistryProvider } from "./viewRegistry.js";
+import { CanvasView } from "./CanvasView.js";
+import { rotateAroundAABBCenter } from "./poseRotation.js";
+import { defaultDrawOne } from "./defaultDrawOne.js";
+import { CORE_PRESET_SOURCE } from "./SceneCanvas/namedPresets.js";
+import { useCanvasCamera } from "./SceneCanvas/useCanvasCamera.js";
+import { useHeldModifiers } from "./SceneCanvas/useHeldModifiers.js";
+import { useCanvasIngestion } from "../features/ingestion/useCanvasIngestion.js";
+import { Canvas } from "./Canvas.js";
+import { DevHuds, canvasDebug } from "./SceneCanvas/DevHuds.js";
+import { CanvasKitProviders } from "./SceneCanvas/CanvasKitProviders.js";
+import { canvasPassThrough } from "./SceneCanvas/canvasPassThrough.js";
+import { contributionEntries } from "./SceneCanvas/useContributionRoles.js";
+import { SceneCanvasInput } from "./SceneCanvas/SceneCanvasInput.js";
+import { useBakedScene } from "./SceneCanvas/useBakedScene.js";
+import { useCanvasDispatcher } from "./SceneCanvas/useCanvasDispatcher.js";
+import { useCanvasSelection } from "./SceneCanvas/useCanvasSelection.js";
+import { SCENE_CANVAS_FEATURES } from "./SceneCanvas/features.js";
+import { BUILTIN_TOOL_IDS, DEFAULT_HANDLE_SIZE } from "./SceneCanvas/props.js";
+import { useEnabledFeatures } from "./SceneCanvas/useCanvasTools.js";
+import { useAddedViews, useSceneCanvasHandle } from "./SceneCanvas/useSceneCanvasHandle.js";
+import { mergeLayersWithDefaults } from "./SceneCanvas/mergeLayers.js";
+import { useSceneCanvasLayers } from "./SceneCanvas/useSceneCanvasLayers.js";
+import { useSceneCanvasPathEdit } from "./SceneCanvas/useSceneCanvasPathEdit.js";
+import { useSceneCanvasTools } from "./SceneCanvas/useSceneCanvasTools.js";
+import { useSceneCanvasChrome } from "./SceneCanvas/useSceneChrome.js";
+import { useSceneRedrawSources } from "./SceneCanvas/useSceneRedrawSources.js";
+import { useScenePicking } from "./SceneCanvas/useScenePicking.js";
+import { useSurfaceViewInputs } from "./SceneCanvas/useSurfaceViewInputs.js";
+import { forwardRef, useMemo, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+import { InputScope, useActionsRegistry } from "@weasel-js/routing/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { getActiveModeFor } from "@weasel-js/modes";
+
 //#region src/canvas/SceneCanvas.tsx
-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: 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: 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: jt } = se({
-		view: Ct,
-		defaultView: Tt,
-		onViewChange: wt,
-		viewBounds: Et,
-		width: T.width,
-		height: T.height,
+/**
+* `<SceneCanvas>` — `<Canvas>` wired to a `Scene` primitive. Bare, it only renders: behavior
+* comes from the `features` presets (`canvas/SceneCanvas/features.ts`), each of which turns on
+* its own actions, tools, ambient bindings, and chrome.
+*
+* A consumer needing custom tools can pass `tools={useTools(...)}` and SceneCanvas forwards it
+* as-is — the internal tool registry is ignored in that case.
+*/
+function SceneCanvasInner(props, ref) {
+	const { selectTool: selectToolOpts, selectable = true, viewport, modes, debug } = props;
+	const descriptor = props.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+	const deviceProfile = useDeviceProfile();
+	const scene = useBakedScene(props.scene);
+	const getActiveMode = useMemo(() => modes ? getActiveModeFor(modes) : void 0, [modes]);
+	const heldModifiers = useHeldModifiers();
+	const internalCanvasRef = useRef(null);
+	const canvasApiRef = useRef(null);
+	const declaredSize = useLatest({
+		width: props.width ?? 0,
+		height: props.height ?? 0
+	});
+	const { viewState, viewAnimation, camera } = useCanvasCamera({
+		view: props.view,
+		defaultView: props.defaultView,
+		onViewChange: props.onViewChange,
+		viewBounds: props.viewBounds,
+		dims: () => canvasApiRef.current?.getSurfaceRect() ?? declaredSize.current,
 		requestRedraw: () => {
-			j.current?.requestRedraw();
+			canvasApiRef.current?.requestRedraw();
 		}
-	}), { 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: ut
-	}), R = de({
-		host: vt,
-		isAllowed: k ? () => k().allowedCapabilities.has("edits-anchors") : void 0,
-		isSelectedNode: (e) => ue(O, L, e)
-	}), Nt = c(() => ({
-		extendClickLocked: () => R.getEditingId() !== "",
-		...a
-	}), [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
-	}), { selectTool: It, pickEvery: U, pickBest: W, boundsOf: G, boundsOfPose: K, planeOfNode: q, moveOptions: Lt } = Re({
-		scene: O,
-		adapter: H,
-		poseDescriptor: E,
-		geometry: Ce,
-		getView: () => P.current,
-		...x ? { alphaOf: B } : {},
-		...V ? { layerIsPainted: V } : {},
-		selectTool: Nt
-	}), Rt = Oe({
-		pickBest: W,
-		nodes: H,
-		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,
-		toolOptions: rt,
-		inertia: v?.inertia,
-		ambient: at,
-		pressFeedback: st?.feedback,
-		initialActiveTool: it,
-		modes: w,
-		onToolsCreated: tt
-	}), { contributions: Vt, standardActionsExclude: Ht } = De({
-		enabled: J,
-		tools: Y,
-		move: Lt,
-		rotate: a?.rotate || void 0
-	}), 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: dt?.colorOverrides,
-		boundsOf: G,
-		planeOfNode: q,
-		previewIds: Jt,
-		dispatcher: Q,
-		pathEditState: R,
-		slops: b !== void 0 && b !== !1 && b.slops === !0
-	}), { getHover: Qt, canvasRef: $t } = Fe({
-		canvasApiRef: j,
-		viewRef: P,
-		nodeAtPointRef: X,
-		enabled: C !== void 0
-	}), en = Pe({
-		enabled: J,
-		selectable: g,
-		rotateOff: Z,
-		chromeVisibility: C
-	}), { chromeCaps: tn, getIsVisible: nn, getRuleCtx: rn } = Ie({
+	});
+	const { viewRef } = viewState;
+	const selection = useCanvasSelection({
+		scene,
+		supplied: props.selection,
+		options: props.selectionOptions,
+		selectable,
+		describeKind: props.describeKind
+	});
+	const enabled = useEnabledFeatures(props.features, props.presetSource.named, viewport !== void 0);
+	const { pathEditState, selectToolWithDefaults } = useSceneCanvasPathEdit({
+		host: props.pathEdit,
+		opening: props.defaultPathEdit,
+		getActiveMode,
+		scene,
+		selection,
+		extensions: enabled.pathEdit,
+		selectTool: selectToolOpts
+	});
+	const picking = useScenePicking({
+		scene,
+		selection,
+		descriptor,
+		props,
+		viewRef,
+		selectTool: selectToolWithDefaults
+	});
+	const { adapter, boundsOf, planeOfNode } = picking;
+	const getNodeAtPointRef = useLatest(picking.getNodeAtPoint);
+	const tools = useSceneCanvasTools({
+		props,
+		select: picking.selectTool,
+		move: picking.moveOptions,
+		scene,
+		selection,
+		enabled,
+		presetSource: props.presetSource
+	});
+	const rotateOff = selectToolOpts?.rotate === false;
+	const actionsRegistry = useActionsRegistry();
+	const { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra } = useCanvasDispatcher(actionsRegistry);
+	const layered = useSceneCanvasLayers({
+		layers: props.layers,
+		targetScale: deviceProfile.targetScale,
+		scene,
+		adapter,
+		poseDescriptor: descriptor,
+		alphaFor: props.alphaFor,
+		colorOverrides: props.animator?.colorOverrides,
+		boundsOf,
+		planeOfNode,
+		poseTransition: props.poseTransition,
+		previewIds: previewIdsExtra,
+		dispatcher,
+		snapReadout: props.snap?.readout !== false,
+		snapReadoutStyle: props.snap?.readoutStyle,
+		pathEditState,
+		slops: debug !== void 0 && debug !== false && debug.slops === true,
+		boundsIncludeStroke: props.geometry?.boundsIncludeStroke ?? true,
+		selectTool: selectToolOpts
+	});
+	const redrawOn = useSceneRedrawSources({
+		props,
+		scene,
+		heldModifiers,
+		departures: layered.departures
+	});
+	const chrome = useSceneCanvasChrome({
 		source: {
-			rules: en,
-			getMode: k,
-			getFocused: yt,
-			getHover: Qt,
-			getModifiers: kt.get,
-			resizable: a?.resize?.resizable,
-			editingAnchors: () => R.getEditingId() !== "",
-			device: D
+			getMode: getActiveMode,
+			getFocused: props.getFocused,
+			getModifiers: heldModifiers.get,
+			resizable: selectToolOpts?.resize?.resizable,
+			editingAnchors: () => pathEditState.getEditingId() !== "",
+			device: deviceProfile
 		},
-		selection: L.current,
-		viewRef: P,
-		dispatcher: Q
-	}), { 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: $t,
-		ingest: an,
-		viewAnimation: N,
-		camera: jt,
-		addView: cn
-	}), dn = c(() => ({
-		adapter: H,
-		geometry: E,
-		boundsOf: G,
-		boundsOfPose: K,
-		planeOfNode: q,
-		pickEvery: U,
-		pickBest: W,
-		kindOfNode: z,
-		chromeCaps: tn,
-		selectionApi: L,
-		rotationBadge: $
-	}), [
-		H,
-		E,
-		G,
-		K,
-		q,
-		U,
-		W,
-		z,
-		tn,
-		L,
-		$
-	]);
-	return fe({
-		getScene: () => O,
-		getSelectionIds: () => L.current ?? [],
-		getView: () => P.current,
-		getActiveToolId: () => Y.active ?? null
-	}), /* @__PURE__ */ d(te, {
-		value: dn,
-		children: /* @__PURE__ */ Ge(re, { children: [
-			/* @__PURE__ */ d(pe, {
-				ref: ln,
-				adapter: H,
-				selection: L,
-				poseDescriptor: E,
-				tools: Y,
-				layers: Xt,
-				boundsOf: G,
-				boundsOfPose: K,
-				getIsVisible: nn,
-				gestureSource: qt,
-				previewPoseExtra: Yt,
-				...b === void 0 ? {} : { debug: qe(b) },
-				contentVersion: O.getVersion,
-				layerVisibility: S,
-				layerOrder: mt,
-				viewState: M,
-				redrawOn: At,
-				...T
-			}),
-			/* @__PURE__ */ d(me, {
-				cursorCoords: bt,
-				pick: xt,
-				modality: St,
-				canvasRef: A,
-				canvasApiRef: j,
-				detachedInput: T.paintInto ? T.inputElement ?? null : void 0,
-				viewRef: P,
-				pickEvery: U,
-				pickBest: W
-			}),
-			/* @__PURE__ */ d(ie, {
-				canvasRef: A,
-				canvasApiRef: j
-			}),
-			/* @__PURE__ */ d(ve, {
-				selection: L,
-				scene: O,
-				adapter: H,
-				actions: Gt,
-				tune: lt,
-				excludeActions: Ht,
-				currentViewRef: P,
-				onViewChange: M.setViewFromInput,
-				resizeOptions: a?.resize,
-				poseDescriptor: E,
-				geometryProjection: h,
-				dispatcher: Q,
-				pickEvery: U,
-				layerIsPainted: V,
-				alphaOf: x ? B : void 0,
-				viewportPanEnabled: J.has("view") ? v?.pan ?? !0 : !1,
-				viewportZoom: J.has("view") ? Mt : !1,
-				viewportPinchZoom: J.has("view") ? v?.pinchZoom ?? !0 : !1,
-				viewportRecenter: v?.recenter,
-				viewAnimation: N,
-				editAnchorsExternalState: R,
-				layoutDropTarget: p,
-				reflowTransition: m,
-				insertNodeFactories: s,
-				insertPaint: Ue,
-				snapPoint: rt?.snapPoint,
-				canvasRef: A,
-				canvasApiRef: j,
-				ingestionResolveSrc: f?.resolveSrc,
-				ingestionSvg: f?.svg,
-				ingestionClipboard: on
+		rules: {
+			enabled,
+			selectable,
+			rotateOff,
+			chromeVisibility: props.chromeVisibility
+		},
+		hover: {
+			canvasApiRef,
+			nodeAtPointRef: getNodeAtPointRef
+		},
+		selection: selection.current,
+		viewRef,
+		dispatcher
+	});
+	const { ingest, clipboard: ingestionClipboard } = useCanvasIngestion(adapter, () => actionsRegistry, props.ingestion);
+	const { views: addedViews, addView, viewAt } = useAddedViews();
+	const { handleRef, ready: canvasReady } = useSceneCanvasHandle({
+		ref,
+		elementRef: internalCanvasRef,
+		apiRef: canvasApiRef,
+		onElement: chrome.trackHoverOn,
+		ingest,
+		viewAnimation,
+		camera,
+		addView,
+		viewAt
+	});
+	const viewInputs = useSurfaceViewInputs({
+		picking,
+		selection,
+		resizeHandles: layered.resizeHandles,
+		descriptor,
+		chromeCaps: chrome.chromeCaps,
+		rotationBadge: layered.rotationBadge
+	});
+	return /* @__PURE__ */ jsxs(CanvasKitProviders, {
+		viewInputs,
+		children: [
+			/* @__PURE__ */ jsx(Canvas, {
+				ref: handleRef,
+				adapter,
+				selection,
+				poseDescriptor: descriptor,
+				tools: tools.tools,
+				layers: layered.layers,
+				boundsOf,
+				boundsOfPose: picking.boundsOfPose,
+				getIsVisible: chrome.getIsVisible,
+				gestureSource,
+				previewPoseExtra,
+				...debug !== void 0 ? { debug: canvasDebug(debug) } : {},
+				contentVersion: scene.getVersion,
+				layerVisibility: props.layerVisibility,
+				layerOrder: props.layerOrder,
+				viewState,
+				redrawOn,
+				...canvasPassThrough(props)
 			}),
-			/* @__PURE__ */ d(he, {
-				canvasRef: A,
-				canvasApiRef: j,
-				tools: Y,
-				contributions: Vt,
-				enabled: et,
-				keyboard: _,
-				claimKeys: $e,
-				selectionRef: Pt,
-				boundsOf: G,
-				planeOfNode: q,
-				pickEvery: U,
-				pickBest: W,
-				kindOfNode: z,
-				viewRef: P,
-				dispatcher: Q,
-				getIsVisibleForCanvas: nn,
-				getRuleCtx: rn,
-				targetScale: D.targetScale,
-				handleHitRadius: a?.handleHitRadius,
-				rotationBadge: $,
-				chromeAffordancesRef: Zt,
-				onDoubleClick: Ut,
-				onClick: Wt,
-				longPress: st
+			/* @__PURE__ */ jsx(DevHuds, {
+				cursorCoords: props.cursorCoordsHud,
+				pick: props.pickHud,
+				modality: props.modalityHud,
+				canvasRef: internalCanvasRef,
+				canvasApiRef,
+				detachedInput: props.paintInto ? props.inputElement ?? null : void 0,
+				viewRef,
+				pickEvery: picking.pickEvery,
+				pickBest: picking.pickBest
 			}),
-			/* @__PURE__ */ d(be, {
-				internalTools: zt,
-				toolsTakeover: Bt ?? void 0,
-				enableKeybindings: _,
-				modes: w,
-				canvasApi: un ? j.current : null,
-				versionCheck: ot
+			/* @__PURE__ */ jsx(SceneCanvasInput, {
+				props,
+				scene,
+				selection,
+				descriptor,
+				picking: {
+					...picking,
+					adapter
+				},
+				nodeAtPointRef: getNodeAtPointRef,
+				tools,
+				rotateOff,
+				viewOn: enabled.has("view"),
+				camera: {
+					viewState,
+					viewAnimation
+				},
+				dispatcher,
+				pathEdit: { state: pathEditState },
+				chrome,
+				overlay: layered,
+				ingestionClipboard,
+				canvas: {
+					elementRef: internalCanvasRef,
+					apiRef: canvasApiRef,
+					ready: canvasReady
+				},
+				snapSources: enabled.snapSources,
+				snapStore: layered.snapStore
 			}),
-			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}`)),
-			pt
-		] })
+			props.views?.map((v, i) => /* @__PURE__ */ jsx(CanvasView, {
+				...v,
+				order: v.order ?? i
+			}, v.id)),
+			contributionEntries(tools.tools).flatMap((e) => e.views ?? []).map((v) => /* @__PURE__ */ jsx(CanvasView, { ...v }, `contribution:${v.id}`)),
+			addedViews.map((v) => /* @__PURE__ */ jsx(CanvasView, { ...v }, `added:${v.id}`)),
+			props.children
+		]
 	});
 }
-var p = s(f);
-function m({ device: t, ...n }, ee) {
-	return /* @__PURE__ */ d(Ue, {
-		yoke: n.yoke,
-		children: /* @__PURE__ */ d(e, {
-			value: t,
-			children: /* @__PURE__ */ d(ne, { children: /* @__PURE__ */ d(p, {
-				...n,
-				ref: ee
+var SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);
+/** A scene canvas resolving its `features` through `source`. */
+function renderSceneCanvas(source, { device, ...props }, ref) {
+	return /* @__PURE__ */ jsx(InputScope, {
+		yoke: props.yoke,
+		children: /* @__PURE__ */ jsx(DeviceProfileProvider, {
+			value: device,
+			children: /* @__PURE__ */ jsx(ViewRegistryProvider, { children: /* @__PURE__ */ jsx(SceneCanvasInnerForwardRef, {
+				...props,
+				presetSource: source,
+				ref
 			}) })
 		})
 	});
 }
-var h = s(m);
-//#endregion
-export { we as BUILTIN_TOOL_IDS, a as DEFAULT_HANDLE_SIZE, Ce as SCENE_CANVAS_FEATURES, h as SceneCanvas, i as rotateAroundAABBCenter };
+function SceneCanvasWrapper(props, ref) {
+	return renderSceneCanvas(CORE_PRESET_SOURCE, props, ref);
+}
+/**
+* The canvas component: renders a `Scene` and wires the interaction stack
+* around it.
+*
+* Mounted bare it renders the scene, keeps a selection no input sets, and
+* runs a gesture dispatcher for whatever bindings the consumer adds. The
+* `features` presets turn the kit's behavior on — `features={['draw']}` is the
+* whole editor: tools, standard actions and their keys, selection chrome,
+* undo. This is the intended entry point; the lower-level primitives it
+* composes are not part of the public surface.
+*
+* Its ref exposes a `SceneCanvasApi` for the imperative operations that do not
+* fit a prop (view control, hit queries, redraw requests).
+*/
+var SceneCanvas = /* @__PURE__ */ forwardRef(SceneCanvasWrapper);
 
+//#endregion
+export { BUILTIN_TOOL_IDS, DEFAULT_HANDLE_SIZE, SCENE_CANVAS_FEATURES, SceneCanvas, renderSceneCanvas, rotateAroundAABBCenter };
 //# sourceMappingURL=SceneCanvas.js.map