@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/SceneCanvas/poseGeometry.js

@@ -1,47 +1,43 @@
-import { poseFrameInverseOf as e, poseFrameOf as t, poseLinearOf as n } from "../../core/geometry/poseFrame.js";
-import { AUTO_POSE_DESCRIPTOR as r, isPathLike as i } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { hasSlop as a, slopForStrokeHit as o } from "../../core/viewport/screenSlop.js";
-import { applyToPoint as s, pointInPath as c, strokeHitTest as l } from "@weasel-js/geom";
+import { framedBounds as e } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as t, isPathLike as n } from "../../core/geometry/autoPoseDescriptor.js";
+import { hasSlop as r, slopForStrokeHit as i } from "../../core/viewport/screenSlop.js";
+import { applyToPoint as a, pointInPath as o, poseFrameInverseOf as s, poseFrameOf as c, poseLinearOf as l, strokeHitTest as u } from "@weasel-js/geom";
 //#region src/canvas/SceneCanvas/poseGeometry.ts
-function u(e, t = r) {
-	return t.getBounds(e);
+function d(e, n = t) {
+	return n.getBounds(e);
 }
-var d = 4;
-function f(e, t, n, i, a = r) {
-	return m(e, t, n, i, a, 0);
+var f = 4;
+function p(e, n, r, i, a = t) {
+	return g(e, n, r, i, a, null, !1);
 }
-function p(n, i, a, o, c = r) {
-	let l = c === r ? n : h(n, c);
-	if (!t(l)) return m(n, i, a, o, c, 0);
-	let u = e(l);
-	if (!u) return !1;
-	let [d, f] = s(u, i, a);
-	return m(n, d, f, o, c, l.rotation ?? 0);
+function m(n, r, i, o, u = t) {
+	let d = u === t ? n : e(n, u), f = c(d);
+	if (!f) return g(n, r, i, o, u, null, !1);
+	let p = s(d);
+	if (!p) return !1;
+	let [m, h] = a(p, r, i);
+	return g(n, m, h, o, u, f, l(d) !== null);
 }
-function m(e, t, n, r, s, f) {
-	let p = i(e), m = r === void 0 ? p ? d : 0 : typeof r == "number" ? r : r.reach ?? 0, h = typeof r == "object" ? r : void 0, { opts: g } = o(h, f);
-	if (p) return c(e, t, n) ? !0 : l(e, t, n, m, g);
-	let _ = u(e, s), v = {
+var h = {
+	x: 1,
+	y: 1
+};
+function g(e, t, a, s, c, l, p) {
+	let m = n(e), g = typeof s == "object" ? void 0 : s ?? (m ? f : 0), _ = p && g !== void 0 && g > 0, v = _ ? 0 : g ?? s.reach ?? 0, y = _ ? {
+		px: g,
+		scale: h
+	} : typeof s == "object" ? s : void 0, { opts: b } = i(y, l);
+	if (m) return o(e, t, a) ? !0 : u(e, t, a, v, b);
+	let x = d(e, c), S = {
 		kind: "rect",
-		x: _.x - m,
-		y: _.y - m,
-		width: _.width + 2 * m,
-		height: _.height + 2 * m
-	};
-	return c(v, t, n) ? !0 : a(h) && l(v, t, n, 0, g);
-}
-function h(e, t) {
-	let r = t.getBounds(e);
-	return {
-		x: r.x,
-		y: r.y,
-		width: r.width,
-		height: r.height,
-		rotation: t.getRotation?.(e) ?? 0,
-		transform: n(e) ?? void 0
+		x: x.x - v,
+		y: x.y - v,
+		width: x.width + 2 * v,
+		height: x.height + 2 * v
 	};
+	return o(S, t, a) ? !0 : r(y) && u(S, t, a, 0, b);
 }
 //#endregion
-export { u as aabbOfPose, i as isPathLike, f as poseContains, p as poseContainsRotated };
+export { d as aabbOfPose, n as isPathLike, p as poseContains, m as poseContainsRotated };
 
 //# sourceMappingURL=poseGeometry.js.map

package/dist/canvas/SceneCanvas/poseGeometry.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseGeometry.js","names":["aabbOfPose","AUTO_POSE_DESCRIPTOR","descriptor","pose","DEFAULT_PATH_STROKE_SLOP","poseContains","containsInFrame","wx","wy","tolerance","poseContainsRotated","framed","framedBounds","poseFrameOf","back","poseFrameInverseOf","lx","ly","applyToPoint","pathLike","isPathLike","reach","screen","slopForStrokeHit","rotation","pointInPath","x","y","strokeHitTest","opts","b","grown","hasSlop","poseLinearOf"],"sources":["../../../src/canvas/SceneCanvas/poseGeometry.ts"],"sourcesContent":["/**\n * Pose-shape helpers shared by `<SceneCanvas>` internals.\n *\n * Every bounds read goes through a `PoseDescriptor`, defaulting to\n * `AUTO_POSE_DESCRIPTOR` (path descriptor for `{kind:'polygon'|'rect'}` poses,\n * rect descriptor for everything else). Used by hit-test, marquee and bounds\n * extraction, so a consumer-supplied descriptor reaches all three.\n */\nimport type { Bounds } from 'tools/builtin/select';\nimport { applyToPoint, pointInPath, strokeHitTest } from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR, isPathLike } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { poseFrameInverseOf, poseFrameOf, poseLinearOf } from 'core/geometry/poseFrame';\nimport { hasSlop, slopForStrokeHit, type ScreenSlop } from 'core/viewport/screenSlop';\n\nexport { isPathLike };\n\nexport function aabbOfPose<TPose>(\n  pose: TPose,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): Bounds {\n  return descriptor.getBounds(pose);\n}\n\n/** Screen-px slop applied to the stroke-distance hit-test for paths. Catches\n *  fingertip-imprecision around thin lines / curves without depending on the\n *  stroke's actual rendered width (which the hit-test layer doesn't know). */\nconst DEFAULT_PATH_STROKE_SLOP = 4;\n\n/** A containment slop: `reach` world units the caller knows the ink extends\n *  past the pose (a stroke's outward half-width), then `px`/`scale` of screen\n *  slop measured from there. */\nexport interface PoseSlop extends ScreenSlop {\n  reach?: number;\n}\n\n/**\n * @param tolerance - Grab slop. A number is **world** units and grows the\n *   AABB test and the path stroke-distance test alike; a {@link PoseSlop}\n *   is measured on screen, from `reach` world units out. Defaults to\n *   {@link DEFAULT_PATH_STROKE_SLOP} for path-like poses (the historical\n *   fixed slop) and to `0` for rect poses, whose edges were never fuzzy.\n */\nexport function poseContains<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  return containsInFrame(pose, wx, wy, tolerance, descriptor, 0);\n}\n\n/**\n * Containment for `<SceneCanvas>`'s default `pickEvery`. When the pose has a\n * frame (`poseFrameOf`: a rotation, a `transform`, or both), takes the query\n * point back through it and tests in the pose's own box frame, mirroring the\n * renderer's wrap so the click target matches the drawn shape. This covers\n * rect-shaped poses and `kind:'rect'`/polygon poses that carry an AABB. A pose\n * with no frame tests directly, and one whose `transform` is singular draws\n * nothing and contains nothing.\n *\n * Rotation comes from the descriptor when one is supplied, and otherwise from\n * `pose.rotation`, the convention the renderer reads. A world `tolerance` is\n * measured in the pose's own frame, so a `transform` stretches it with the\n * node.\n */\nexport function poseContainsRotated<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  const framed = descriptor === AUTO_POSE_DESCRIPTOR ? pose : framedBounds(pose, descriptor);\n  if (!poseFrameOf(framed)) return containsInFrame(pose, wx, wy, tolerance, descriptor, 0);\n  const back = poseFrameInverseOf(framed);\n  if (!back) return false;\n  const [lx, ly] = applyToPoint(back, wx, wy);\n  const rotation = (framed as { rotation?: number }).rotation ?? 0;\n  return containsInFrame(pose, lx, ly, tolerance, descriptor, rotation);\n}\n\n/** `(x, y)` is in the pose's own frame, which reaches world by `rotation`. */\nfunction containsInFrame<TPose>(\n  pose: TPose,\n  x: number,\n  y: number,\n  tolerance: number | PoseSlop | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  rotation: number,\n): boolean {\n  const pathLike = isPathLike(pose);\n  const reach = tolerance === undefined\n    ? (pathLike ? DEFAULT_PATH_STROKE_SLOP : 0)\n    : typeof tolerance === 'number' ? tolerance : (tolerance.reach ?? 0);\n  const screen = typeof tolerance === 'object' ? tolerance : undefined;\n  const { opts } = slopForStrokeHit(screen, rotation);\n  if (pathLike) {\n    // Precise inside-filled-region OR within-stroke-slop. Replaces the old\n    // \"AABB-conservative-fallback\" path that returned true anywhere inside\n    // the path's bounding box (which over-picked on open / non-convex paths).\n    if (pointInPath(pose, x, y)) return true;\n    return strokeHitTest(pose, x, y, reach, opts);\n  }\n  const b = aabbOfPose(pose, descriptor);\n  // `reach` is the caller's budget for being at least as generous as whatever\n  // refinement follows: the stroke's outward reach, which this function\n  // cannot see. Grown square, so it contains the round band the refinement\n  // tests.\n  const grown = {\n    kind: 'rect' as const,\n    x: b.x - reach, y: b.y - reach, width: b.width + 2 * reach, height: b.height + 2 * reach,\n  };\n  if (pointInPath(grown, x, y)) return true;\n  return hasSlop(screen) && strokeHitTest(grown, x, y, 0, opts);\n}\n\n/** The box, rotation, and `transform` a descriptor-read pose is drawn in. */\nfunction framedBounds<TPose>(pose: TPose, descriptor: PoseDescriptor<unknown>): unknown {\n  const b = descriptor.getBounds(pose);\n  return {\n    x: b.x, y: b.y, width: b.width, height: b.height,\n    rotation: descriptor.getRotation?.(pose) ?? 0,\n    transform: poseLinearOf(pose) ?? undefined,\n  };\n}\n"],"mappings":";;;;;AAiBA,SAAgBA,EACd,GACA,IAAsCC,GAC9B;CACR,OAAOC,EAAW,UAAUC,CAAI;AAClC;AAKA,IAAMC,IAA2B;AAgBjC,SAAgBC,EACd,GACA,GACA,GACA,GACA,IAAsCJ,GAC7B;CACT,OAAOK,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,CAAC;AAC/D;AAgBA,SAAgBQ,EACd,GACA,GACA,GACA,GACA,IAAsCT,GAC7B;CACT,IAAMU,IAAST,MAAeD,IAAuBE,IAAOS,EAAaT,GAAMD,CAAU;CACzF,IAAI,CAACW,EAAYF,CAAM,GAAG,OAAOL,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,CAAC;CACvF,IAAMY,IAAOC,EAAmBJ,CAAM;CACtC,IAAI,CAACG,GAAM,OAAO;CAClB,IAAM,CAACE,GAAIC,KAAMC,EAAaJ,GAAMP,GAAIC,CAAE;CAE1C,OAAOF,EAAgBH,GAAMa,GAAIC,GAAIR,GAAWP,GAD9BS,EAAiC,YAAY,CACK;AACtE;AAGA,SAASL,EACP,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMa,IAAWC,EAAWjB,CAAI,GAC1BkB,IAAQZ,MAAc,KAAA,IACvBU,IAAWf,IAA2B,IACvC,OAAOK,KAAc,WAAWA,IAAaA,EAAU,SAAS,GAC9Da,IAAS,OAAOb,KAAc,WAAWA,IAAY,KAAA,GACrD,EAAE,YAASc,EAAiBD,GAAQE,CAAQ;CAClD,IAAIL,GAKF,OADIM,EAAYtB,GAAMuB,GAAGC,CAAC,IAAU,KAC7BC,EAAczB,GAAMuB,GAAGC,GAAGN,GAAOQ,CAAI;CAE9C,IAAMC,IAAI9B,EAAWG,GAAMD,CAAU,GAK/B6B,IAAQ;EACZ,MAAM;EACN,GAAGD,EAAE,IAAIT;EAAO,GAAGS,EAAE,IAAIT;EAAO,OAAOS,EAAE,QAAQ,IAAIT;EAAO,QAAQS,EAAE,SAAS,IAAIT;CACrF;CAEA,OADII,EAAYM,GAAOL,GAAGC,CAAC,IAAU,KAC9BK,EAAQV,CAAM,KAAKM,EAAcG,GAAOL,GAAGC,GAAG,GAAGE,CAAI;AAC9D;AAGA,SAASjB,EAAoB,GAAa,GAA8C;CACtF,IAAMkB,IAAI5B,EAAW,UAAUC,CAAI;CACnC,OAAO;EACL,GAAG2B,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;EAC1C,UAAU5B,EAAW,cAAcC,CAAI,KAAK;EAC5C,WAAW8B,EAAa9B,CAAI,KAAK,KAAA;CACnC;AACF"}
+{"version":3,"file":"poseGeometry.js","names":["aabbOfPose","AUTO_POSE_DESCRIPTOR","descriptor","pose","DEFAULT_PATH_STROKE_SLOP","poseContains","containsInFrame","wx","wy","tolerance","poseContainsRotated","framed","framedBounds","frame","poseFrameOf","back","poseFrameInverseOf","lx","ly","applyToPoint","poseLinearOf","WORLD_SCALE","pathLike","isPathLike","world","throughFrame","stretched","reach","screen","slopForStrokeHit","pointInPath","x","y","strokeHitTest","opts","b","grown","hasSlop"],"sources":["../../../src/canvas/SceneCanvas/poseGeometry.ts"],"sourcesContent":["/**\n * Pose-shape helpers shared by `<SceneCanvas>` internals. Every bounds read goes through a\n * `PoseDescriptor`, defaulting to `AUTO_POSE_DESCRIPTOR`, so a consumer-supplied descriptor\n * reaches hit-test, marquee, and bounds extraction alike.\n */\nimport type { Bounds } from 'tools/builtin/select';\nimport { applyToPoint, pointInPath, strokeHitTest, type Affine } from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { framedBounds } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR, isPathLike } from 'core/geometry/autoPoseDescriptor';\nimport { poseFrameInverseOf, poseFrameOf, poseLinearOf } from '@weasel-js/geom';\nimport { hasSlop, slopForStrokeHit, type ScreenSlop } from 'core/viewport/screenSlop';\n\nexport { isPathLike };\n\nexport function aabbOfPose<TPose>(\n  pose: TPose,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): Bounds {\n  return descriptor.getBounds(pose);\n}\n\n/** Default slop for the stroke-distance hit-test on paths, in world units. Independent of\n *  the stroke's rendered width, which the hit-test layer doesn't know. */\nconst DEFAULT_PATH_STROKE_SLOP = 4;\n\n/** A containment slop: `reach` world units the caller knows the ink extends\n *  past the pose (a stroke's outward half-width), then `px`/`scale` of screen\n *  slop measured from there. */\nexport interface PoseSlop extends ScreenSlop {\n  reach?: number;\n}\n\n/**\n * @param tolerance - Grab slop. A number is **world** units and grows the\n *   AABB test and the path stroke-distance test alike; a {@link PoseSlop}\n *   is measured on screen, from `reach` world units out. Defaults to\n *   {@link DEFAULT_PATH_STROKE_SLOP} for path-like poses and to `0` for rect poses.\n */\nexport function poseContains<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  return containsInFrame(pose, wx, wy, tolerance, descriptor, null, false);\n}\n\n/**\n * Containment for `<SceneCanvas>`'s default `pickEvery`. When the pose has a\n * frame (`poseFrameOf`: a rotation, a `transform`, or both), takes the query\n * point back through it and tests in the pose's own box frame, mirroring the\n * renderer's wrap so the click target matches the drawn shape. A pose with no\n * frame tests directly, and one whose `transform` is singular draws nothing and\n * contains nothing.\n *\n * Rotation comes from the descriptor when one is supplied, and otherwise from\n * `pose.rotation`, the convention the renderer reads. A `tolerance` is a\n * distance in world or on screen whatever the frame; only a `PoseSlop`'s\n * `reach` is in the pose's own frame, where the stroke it stands for is drawn.\n */\nexport function poseContainsRotated<TPose>(\n  pose: TPose,\n  wx: number,\n  wy: number,\n  tolerance?: number | PoseSlop,\n  descriptor: PoseDescriptor<unknown> = AUTO_POSE_DESCRIPTOR,\n): boolean {\n  const framed = descriptor === AUTO_POSE_DESCRIPTOR ? pose : framedBounds(pose, descriptor);\n  const frame = poseFrameOf(framed);\n  if (!frame) return containsInFrame(pose, wx, wy, tolerance, descriptor, null, false);\n  const back = poseFrameInverseOf(framed);\n  if (!back) return false;\n  const [lx, ly] = applyToPoint(back, wx, wy);\n  return containsInFrame(pose, lx, ly, tolerance, descriptor, frame, poseLinearOf(framed) !== null);\n}\n\nconst WORLD_SCALE = { x: 1, y: 1 };\n\n/** `(x, y)` is in the pose's own frame, which reaches world by `frame`.\n *  `stretched` is whether that frame changes lengths: it carries a `transform`. */\nfunction containsInFrame<TPose>(\n  pose: TPose,\n  x: number,\n  y: number,\n  tolerance: number | PoseSlop | undefined,\n  descriptor: PoseDescriptor<unknown>,\n  frame: Affine | null,\n  stretched: boolean,\n): boolean {\n  const pathLike = isPathLike(pose);\n  const world = typeof tolerance === 'object' ? undefined\n    : tolerance ?? (pathLike ? DEFAULT_PATH_STROKE_SLOP : 0);\n  // A world distance is not one in a stretched frame, so it is tested through\n  // the frame, as a screen slop is: at a scale of one.\n  const throughFrame = stretched && world !== undefined && world > 0;\n  const reach = throughFrame ? 0 : world ?? (tolerance as PoseSlop).reach ?? 0;\n  const screen = throughFrame ? { px: world, scale: WORLD_SCALE }\n    : typeof tolerance === 'object' ? tolerance : undefined;\n  const { opts } = slopForStrokeHit(screen, frame);\n  if (pathLike) {\n    // Inside the filled region, or within stroke slop.\n    if (pointInPath(pose, x, y)) return true;\n    return strokeHitTest(pose, x, y, reach, opts);\n  }\n  const b = aabbOfPose(pose, descriptor);\n  // `reach` is the caller's budget for being at least as generous as whatever\n  // refinement follows: the stroke's outward reach, which this function\n  // cannot see. Grown square, so it contains the round band the refinement\n  // tests.\n  const grown = {\n    kind: 'rect' as const,\n    x: b.x - reach, y: b.y - reach, width: b.width + 2 * reach, height: b.height + 2 * reach,\n  };\n  if (pointInPath(grown, x, y)) return true;\n  return hasSlop(screen) && strokeHitTest(grown, x, y, 0, opts);\n}\n"],"mappings":";;;;;AAeA,SAAgBA,EACd,GACA,IAAsCC,GAC9B;CACR,OAAOC,EAAW,UAAUC,CAAI;AAClC;AAIA,IAAMC,IAA2B;AAejC,SAAgBC,EACd,GACA,GACA,GACA,GACA,IAAsCJ,GAC7B;CACT,OAAOK,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,MAAM,EAAK;AACzE;AAeA,SAAgBQ,EACd,GACA,GACA,GACA,GACA,IAAsCT,GAC7B;CACT,IAAMU,IAAST,MAAeD,IAAuBE,IAAOS,EAAaT,GAAMD,CAAU,GACnFW,IAAQC,EAAYH,CAAM;CAChC,IAAI,CAACE,GAAO,OAAOP,EAAgBH,GAAMI,GAAIC,GAAIC,GAAWP,GAAY,MAAM,EAAK;CACnF,IAAMa,IAAOC,EAAmBL,CAAM;CACtC,IAAI,CAACI,GAAM,OAAO;CAClB,IAAM,CAACE,GAAIC,KAAMC,EAAaJ,GAAMR,GAAIC,CAAE;CAC1C,OAAOF,EAAgBH,GAAMc,GAAIC,GAAIT,GAAWP,GAAYW,GAAOO,EAAaT,CAAM,MAAM,IAAI;AAClG;AAEA,IAAMU,IAAc;CAAE,GAAG;CAAG,GAAG;AAAE;AAIjC,SAASf,EACP,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMgB,IAAWC,EAAWpB,CAAI,GAC1BqB,IAAQ,OAAOf,KAAc,WAAW,KAAA,IAC1CA,MAAca,IAAWlB,IAA2B,IAGlDqB,IAAeC,KAAaF,MAAU,KAAA,KAAaA,IAAQ,GAC3DG,IAAQF,IAAe,IAAID,KAAUf,EAAuB,SAAS,GACrEmB,IAASH,IAAe;EAAE,IAAID;EAAO,OAAOH;CAAY,IAC1D,OAAOZ,KAAc,WAAWA,IAAY,KAAA,GAC1C,EAAE,YAASoB,EAAiBD,GAAQf,CAAK;CAC/C,IAAIS,GAGF,OADIQ,EAAY3B,GAAM4B,GAAGC,CAAC,IAAU,KAC7BC,EAAc9B,GAAM4B,GAAGC,GAAGL,GAAOO,CAAI;CAE9C,IAAMC,IAAInC,EAAWG,GAAMD,CAAU,GAK/BkC,IAAQ;EACZ,MAAM;EACN,GAAGD,EAAE,IAAIR;EAAO,GAAGQ,EAAE,IAAIR;EAAO,OAAOQ,EAAE,QAAQ,IAAIR;EAAO,QAAQQ,EAAE,SAAS,IAAIR;CACrF;CAEA,OADIG,EAAYM,GAAOL,GAAGC,CAAC,IAAU,KAC9BK,EAAQT,CAAM,KAAKK,EAAcG,GAAOL,GAAGC,GAAG,GAAGE,CAAI;AAC9D"}

package/dist/canvas/SceneCanvas/props.js

@@ -1,38 +1,39 @@
 import { HANDLE_BASE_PX as e, targetSizesPx as t } from "../../core/device/targets.js";
 import { defaultDrawOne as n, defaultPaintBounds as r, paintBoundsFor as i } from "../defaultDrawOne.js";
 import { KIT_SHAPE_KINDS as a } from "../../core/shapeKinds.js";
+import { isCustomEntry as o } from "../layerSlots.js";
 import "@weasel-js/routing/react";
 //#region src/canvas/SceneCanvas/props.ts
-var o = e;
-function s(e, a = 1) {
-	let o = {
+var s = e;
+function c(e, a = 1) {
+	let s = {
 		scene: {
 			drawOne: n,
 			paintBounds: r
 		},
 		selectionOverlay: { handles: { size: t(a).handle } }
 	};
-	if (!e) return o;
-	let s = { ...e };
-	if (!("scene" in e)) s.scene = o.scene;
-	else if (e.scene === null) s.scene = null;
+	if (!e) return s;
+	let c = { ...e };
+	if (!("scene" in e)) c.scene = s.scene;
+	else if (e.scene === null || o(e.scene)) c.scene = e.scene;
 	else {
 		let t = {
-			...o.scene,
+			...s.scene,
 			...e.scene
 		};
-		s.scene = e.scene && "paintBounds" in e.scene ? t : {
+		c.scene = e.scene && "paintBounds" in e.scene ? t : {
 			...t,
 			paintBounds: i(t.drawOne)
 		};
 	}
-	return s.selectionOverlay = "selectionOverlay" in e ? e.selectionOverlay === null ? null : {
-		...o.selectionOverlay,
+	return c.selectionOverlay = "selectionOverlay" in e ? e.selectionOverlay === null || o(e.selectionOverlay) ? e.selectionOverlay : {
+		...s.selectionOverlay,
 		...e.selectionOverlay
-	} : o.selectionOverlay, s;
+	} : s.selectionOverlay, c;
 }
-var c = ["select", "hand"], l = [...c, ...a];
+var l = ["select", "hand"], u = [...l, ...a];
 //#endregion
-export { l as BUILTIN_TOOL_IDS, o as DEFAULT_HANDLE_SIZE, c as NON_SHAPE_BUILTIN_TOOLS, s as mergeLayersWithDefaults };
+export { u as BUILTIN_TOOL_IDS, s as DEFAULT_HANDLE_SIZE, l as NON_SHAPE_BUILTIN_TOOLS, c as mergeLayersWithDefaults };
 
 //# sourceMappingURL=props.js.map

package/dist/canvas/SceneCanvas/props.js.map

@@ -1 +1 @@
-{"version":3,"file":"props.js","names":["DEFAULT_HANDLE_SIZE","HANDLE_BASE_PX","mergeLayersWithDefaults","defaults","defaultDrawOne","defaultPaintBounds","targetSizesPx","targetScale","user","result","scene","paintBoundsFor","NON_SHAPE_BUILTIN_TOOLS","BUILTIN_TOOL_IDS","KIT_SHAPE_KINDS"],"sources":["../../../src/canvas/SceneCanvas/props.ts"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport type { FillStyle } from '@weasel-js/paint';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { Yoke } from '@weasel-js/routing/react';\nimport type { PasteOmission } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, NodeId, Scene, SerializedScene } from 'core/scene/types';\nimport type { SelectionApi, UseSelectionOptions } from 'core/selection/useSelection';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\nimport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nimport type { PanBounds } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\nimport type {\n  ContentHandlerEntry\n} from 'features/ingestion';\nimport type { PinchZoomOptions } from 'interactions/actions/defaults/pinchZoom';\nimport type { WheelPanOptions } from 'interactions/actions/defaults/viewportWheelPan';\nimport type { ViewportZoomAnimateOptions, ViewportZoomOptions } from 'interactions/actions/defaults/viewportZoom';\nimport type { SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { UseRotateOptions } from 'interactions/actions/rotate/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport type { ReactNode } from 'react';\nimport type { Bounds } from 'tools/builtin/select';\nimport type { Animator } from '../../animation/types';\nimport { HANDLE_BASE_PX, targetSizesPx } from '../../core/device/targets';\nimport type { DeviceProfile } from '../../core/device/types';\nimport type { NodeRoutingEntry } from '../../core/scene/NodeRouting';\nimport type { DebugConfig } from '../../debug/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { DrawCommand, ShaderProgramHandle } from '../../renderer';\nimport type { AnyTool } from '../../tools/overlayBinding';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasProps, LayersMap, SceneSlotConfig } from '../Canvas';\nimport type { CanvasViewProps } from '../CanvasView';\nimport { defaultDrawOne, defaultPaintBounds, paintBoundsFor } from '../defaultDrawOne';\nimport type {\n  InsertNodeFactory,\n  InsertPaint\n} from '../deps';\nimport type { SceneToAdapterOptions } from '../sceneAdapter';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport type {\n  Feature\n} from './features';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\nimport type { VersionCheck } from './useContributionRoles';\n\n/**\n * Minimal adapter surface the legacy bridge factories need for delete /\n * duplicate / group / ungroup. Extracted from `SceneCanvasAdapter` to avoid\n * threading the full generic type through `StandardActionsRegistrar` (which is\n * non-generic). The actual adapter supplied is always a `SceneCanvasAdapter`\n * so the cast is safe.\n */\nexport interface BridgeAdapter {\n  applyOps(ops: Op[], label?: string): void;\n  insertNode(node: { id: string; [k: string]: unknown }): void;\n  removeNode(id: string): void;\n  setSelection(ids: string[]): void;\n}\n\n/** Default size in CSS pixels for selection corner-handles AND their\n *  hit-test radius, at `targetScale = 1`. Used by the SceneCanvas defaults;\n *  consumers override via `selectTool.handleHitRadius` or\n *  `layers.selectionOverlay.handles.size`.\n *\n *  Deliberately unscaled: consumers reading this constant keep getting the\n *  number they always got. Kit-internal use sites multiply by\n *  `DeviceProfile.targetScale`. */\nexport const DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\n// ---------------------------------------------------------------------------\n// Dev-only coord trace\n// ---------------------------------------------------------------------------\n\n/**\n * `import.meta.env.DEV`, read through a cast rather than off a typed\n * `ImportMeta`. Core must not depend on a bundler's ambient augmentation\n * (`vite/client`) to compile — until core moved into `packages/core/`, two\n * call sites below read `import.meta.env` bare and only type-checked because\n * `apps/site/vite-env.d.ts` leaked its `/// <reference types=\"vite/client\" />`\n * into the shared root-tsconfig program. Isolating core's build surfaced it.\n * Mirrors the same cast in dispatcher.ts and buildDeps.ts.\n */\n/** `<SceneCanvas longPress>`. */\nexport interface SceneCanvasLongPress {\n  /**\n   * Shown while a long-press is held and some binding would fire on it.\n   * Default: a ring that fills around the press point\n   * (`createLongPressFeedbackContribution()`), static under\n   * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces\n   * it, reading the `longPress` dep. Installed beside `ambient`, so under a\n   * `tools` takeover add it to your own `useTools` call instead.\n   */\n  feedback?: boolean | SurfaceContribution;\n  /** Default true. A long-press some binding handled pulses\n   *  `navigator.vibrate` briefly, for touch and pen, where the API exists. */\n  haptics?: boolean;\n  /** Hold time in ms. Default `LONG_PRESS_MS` (500). */\n  duration?: number;\n}\n\n/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,\n *  since the defaults fill in whatever it leaves out. */\nexport type SceneCanvasLayers<TNode extends { id: string }, TPose> = LayersMap<\n  TNode,\n  TPose,\n  Partial<SceneSlotConfig<TNode, TPose>>\n>;\n\n/** Deep-merge user-supplied `layers` with kit defaults. Slots the user\n *  doesn't mention get filled with defaults; slots explicitly set to\n *  `null` are dropped (the existing \"disable this slot\" convention).\n *  Partial slot configs (e.g. `{ scene: { drawOne: customFn } }`) are\n *  shallow-spread on top of the default slot config.\n *\n *  `targetScale` comes from the resolved {@link DeviceProfile}. It is a\n *  parameter rather than a read because this function is module-scope and\n *  the profile is a hook value; the caller inside the component passes it. */\nexport function mergeLayersWithDefaults<TData, TLayer extends string, TPose>(\n  user: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined,\n  targetScale = 1,\n): LayersMap<Node<TData, TLayer, TPose>, TPose> {\n  const defaults = {\n    scene: {\n      drawOne: defaultDrawOne as (\n        node: Node<TData, TLayer, TPose>,\n        pose: TPose,\n      ) => DrawCommand[],\n      paintBounds: defaultPaintBounds<TData, TLayer, TPose>,\n    },\n    selectionOverlay: { handles: { size: targetSizesPx(targetScale).handle } },\n  };\n\n  if (!user) return defaults as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  // Start from a shallow copy of the user map so unknown slots pass through.\n  const result = { ...user } as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  if (!('scene' in user)) {\n    result.scene = defaults.scene;\n  } else if (user.scene === null) {\n    result.scene = null;\n  } else {\n    const scene = { ...defaults.scene, ...user.scene };\n    result.scene = user.scene && 'paintBounds' in user.scene\n      ? scene\n      : { ...scene, paintBounds: paintBoundsFor<TData, TLayer, TPose>(scene.drawOne) };\n  }\n\n  if (!('selectionOverlay' in user)) {\n    result.selectionOverlay = defaults.selectionOverlay;\n  } else if (user.selectionOverlay === null) {\n    result.selectionOverlay = null;\n  } else {\n    result.selectionOverlay = { ...defaults.selectionOverlay, ...user.selectionOverlay };\n  }\n\n  return result;\n}\n\n/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop\n *  is supplied, via `defaultTools`. */\nexport type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId;\n\n/** Built-in tool ids that aren't shape tools — the ones with no entry in\n *  the `core/shapeKinds` table. */\nexport const NON_SHAPE_BUILTIN_TOOLS: readonly Exclude<BuiltinToolId, BuiltinShapeToolId>[] = ['select', 'hand'];\n\n/** Every built-in tool id, shape tools included. */\nexport const BUILTIN_TOOL_IDS: readonly BuiltinToolId[] = [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS];\n\n/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields\n *  modality dispatch needs; extends as the kit's `Hit` type evolves. */\nexport interface SceneCanvasHit {\n  id: string;\n  kind: string;\n}\n\n/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing\n *  else it renders that scene and keeps a selection no input sets; `features`\n *  turns behavior on by preset, and the rest configures what those turn on. */\nexport type SceneCanvasProps<TData, TLayer extends string, TPose> =\n  Omit<\n    CanvasProps<Node<TData, TLayer, TPose>, TPose>,\n    | 'adapter'\n    | 'moveOptions' | 'resizeOptions' | 'rotateOptions'\n    | 'snap' | 'pickEvery' | 'boundsOf' | 'handleHitRadius'\n    | 'selection' | 'selectionOptions' | 'tools'\n    | 'layers'          // stripped so we can re-add as optional below\n    | 'onBackgroundClick' // SceneCanvas synthesizes this; not a consumer prop\n    | 'getIsVisible'    // SceneCanvas synthesizes this from chromeVisibility\n    | 'contentVersion'  // SceneCanvas wires this to the scene's own version\n    | 'layerVisibility' | 'layerOrder' // re-declared below: they gate picking here too\n    | 'debug'           // re-declared below with SceneCanvas's own `slops`\n  >\n  & {\n    /** A `Scene` (typically from `useScene`) — or a `SerializedScene`\n     *  JSON object, which SceneCanvas bakes into a Scene internally on\n     *  first render. The serialized form is read once; subsequent\n     *  changes to the prop are ignored. Pass a `key` prop on\n     *  `<SceneCanvas>` to force a fresh canvas from updated JSON.\n     *\n     *  The accepted JSON shape is intentionally relaxed (`version:\n     *  number` rather than `1` literal) so a `import json from './x.json'`\n     *  result satisfies the type without an `as` cast — Vite infers\n     *  number-literal types as `number` from JSON, which the strict\n     *  `SerializedScene<…>` would reject. */\n    scene:\n      | Scene<TData, TLayer, TPose>\n      | SerializedScene<TData, TLayer, TPose>\n      | { version: number; systemLayers?: ReadonlyArray<{ id: string }>; nodes: ReadonlyArray<unknown> };\n\n    /** Layer configuration. When omitted, SceneCanvas applies kit defaults\n     *  (a scene slot that paints `node.data.fill` rects + a default\n     *  selection overlay). A partial scene or selection-overlay config is\n     *  spread over that slot's defaults; pass `slot: null` to suppress a\n     *  default explicitly. */\n    layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;\n\n    /** Layout strategies keyed by container node id (or a resolver), for\n     *  containers whose scene node declares none (`ContainerNode.layout`\n     *  wins). Applied to a drag and to every other change to their children,\n     *  through the scene's layout pass. */\n    layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];\n\n    /** Which layout container a drag lands in when several contain the drop\n     *  point — the innermost (default), the topmost in paint order, or only\n     *  containers whose strategy declares a `dropRegion`. Decides both the\n     *  drag-time reflow preview and the commit. */\n    layoutDropTarget?: LayoutDropTargetMode;\n\n    /** Carries the siblings a layout reflow displaces to their slots over time\n     *  instead of snapping them — `useAnimatedReflow` builds one. Covers a\n     *  drag's reflow and every one the scene records (an insert, delete,\n     *  reorder or resize inside a laid-out container). Absent or `null`,\n     *  they snap. */\n    reflowTransition?: ReflowTransition<TPose> | null;\n\n    /** How a child's stored pose folds into its parent's frame. Omit for the\n     *  absolute-pose model, where a container groups its children but imposes\n     *  no transform. Pass `RIGID_POSE_COMPOSITION` to make a container's pose\n     *  a frame, so rotating it rotates its contents and moving it carries them\n     *  without touching their poses. */\n    poseComposition?: SceneToAdapterOptions<TData, TLayer, TPose>['poseComposition'];\n\n    /**\n     * Optional consumer seam for eager geometry sync: lets pose-transform\n     * actions (move, resize, nudge, flip — NOT rotate) also rewrite a node's\n     * data-held geometry. Given a node and the affine `m` applied to its pose,\n     * `transform(node, m)` returns updated `data` (geometry mapped by `m`) or\n     * `null` for nodes with no data-held geometry.\n     *\n     * Strictly opt-in: when absent, the kit emits only the pose op and leaves\n     * `data` untouched. Consumers wire this via `geometryProjection={myProjection}`.\n     *\n     * @see GeometryProjection\n     */\n    geometryProjection?: GeometryProjection;\n\n    /**\n     * Routing-trait classifiers — list of `NodeRoutingEntry` entries. The kit\n     * constructs a `NodeRouting` registry per-`<SceneCanvas>` from this prop,\n     * then uses the resulting classifier to derive each hit's `kind` when\n     * building `getNodeAtPoint`. Tool routing tables (e.g.\n     * `{ target: 'rect', actionId: 'move' }`) match against the produced\n     * kind strings.\n     *\n     * Pass `defaultNodeRouting` to pick up the kit's built-in shape kinds\n     * (rect, ellipse, polygon, …) for `data: { kind: '<shape>' }` nodes.\n     * Spread additional entries for consumer-defined kinds.\n     *\n     * See `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`.\n     *\n     * **Memoize the `routing` value.** The kit memoizes the registry on the\n     * prop's reference identity. Passing a fresh array each render\n     * (e.g. `routing={[...defaultNodeRouting, custom]}` inline) rebuilds the\n     * registry and cascades into a new adapter, churning gesture state.\n     * Define the list as a module-level constant, or wrap it in `useMemo`.\n     * (`defaultNodeRouting` alone is a stable module-level constant; spreading\n     * it with extras is what needs the memo.)\n     */\n    routing?: readonly NodeRoutingEntry[];\n\n    /** How to read and rewrite this scene's poses. Every built-in action,\n     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`\n     *  (rect poses and `Path` poses). */\n    poseDescriptor?: PoseDescriptor<TPose>;\n\n    // --- Geometry: hit-test + bounds overrides consumed by the internal\n    //     `useSelectTool`. Ignored if the consumer passes their own `tools`. ---\n    geometry?: {\n      /** Hit-test override. Return the topmost id, the full back-to-front hit\n       *  stack (`string[]`), or `null` for empty space. The stack form lets a\n       *  consumer with domain overlap ordering (e.g. children over their\n       *  container) feed the kit's `pickTopMostHit` the true order instead of\n       *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */\n      pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n      boundsOf?: (id: string) => Bounds | null;\n      /**\n       * What \"the pointer is on this node\" means for the default body-pick.\n       *\n       * - `'pose'` — the node's pose rect, rotation honored. What every\n       *   consumer got before `'shape'` existed, and now the opt-out.\n       * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter\n       *   actually lays down: its silhouette (`findShapeSilhouette`) filled\n       *   or not per the painter's `ink`, plus its outline widened by the\n       *   stroke half-width and `pickTolerancePx`. A click in the concave\n       *   notch of a star, in the corner outside an ellipse, or in the blank\n       *   half of a text box falls through to whatever is beneath; a click on\n       *   the thin outline of an unfilled shape hits it.\n       *\n       * Painters with no silhouette are unaffected — they keep the pose-rect\n       * answer either way, so this can never make a node unreachable.\n       *\n       * Ignored when `pickEvery` is supplied: that override owns the test.\n       */\n      picking?: 'pose' | 'shape';\n      /**\n       * Grab slop around a shape's outline, in **screen** pixels. Default 4.\n       *\n       * Screen pixels rather than world units so the target keeps its\n       * apparent size at any zoom. It widens the outline test under\n       * `picking: 'shape'` (a 1px hairline is otherwise a half-world-unit\n       * target, which is unhittable), and it grows the pose-rect pre-filter\n       * so those outline hits survive it. Set `0` for exact geometry.\n       */\n      pickTolerancePx?: number;\n    };\n\n    // --- Selection options. `pickBest` and `handleHitRadius` configure the\n    //     internal select tool, and are ignored under a `tools` takeover;\n    //     `move`, `snap`, `resize` and `rotate` configure the `move`,\n    //     `resize` and `rotate` presets, and apply either way. ---\n    selectTool?: {\n      move?: UseMoveOptions<TPose>;\n      resize?: UseResizeOptions<TPose>;\n      /** Rotation options, or `false` to disable rotation entirely — drops the\n       *  `rotate` action AND hides the selection rotation-handle chrome, so a\n       *  consumer whose objects don't rotate (e.g. a floor-plan / garden\n       *  editor) opts out with a single switch instead of pairing\n       *  `actions={{ rotate: null }}` with a `chromeVisibility` override. */\n      rotate?: UseRotateOptions<TPose> | false;\n      snap?: SnapStrategy<TPose>;\n      handleHitRadius?: number;\n      /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n       *  the live alt state + current selection so consumers can implement\n       *  alt-cycling through an overlapping stack. Default: top-most hit\n       *  (alt ignored). */\n      pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    };\n\n    // --- Insert tool: when `create` is supplied, the synthesized adapter\n    //     exposes `commitInsert` and inserted objects are added as leaves on\n    //     `layer` (default `'default'`). ---\n    insertTool?: {\n      create: SceneToAdapterOptions<TData, TLayer, TPose>['commitInsert'];\n      layer?: TLayer;\n    };\n\n    /** Consumer node factories for the `insert` action, keyed by tool `kind`.\n     *  Each factory receives the drag AABB + tool `extras` and returns the\n     *  node's `data` (in this canvas's own data shape) plus an optional `pose`.\n     *  A factory for a kit kind (`rect`, `line`, …) replaces the kit's default\n     *  `{ path, fill }` node for that kind; a factory for a novel kind (e.g.\n     *  `text`) adds insert support the kit doesn't ship. The dep supplies id,\n     *  layer, and the undoable op. Return `null` to reject an insert. */\n    insertNodeFactories?: Record<string, InsertNodeFactory>;\n\n    /** The fill and stroke a kit-built shape is inserted with, by tool `kind`\n     *  and insert count; the kit keeps the geometry. Default\n     *  `paletteInsertPaint`, the kit palette in turn. A kind with a factory in\n     *  `insertNodeFactories` is not asked. */\n    insertPaint?: InsertPaint;\n\n    /** External-content ingestion (OS drop / clipboard paste / picker).\n     *  `handlers` are consumer content handlers registered for this canvas's\n     *  lifetime (priority 0 by default — they beat the kit's `image/*` /\n     *  `image/svg+xml` handlers at -100/-90). `resolveSrc` overrides the\n     *  image handler's `data:`-URI embed (e.g. upload to an asset store,\n     *  return the URL). `svg.unpack` makes the kit SVG handler parse dropped\n     *  SVG files into native scene nodes instead of keeping each one a\n     *  single embedded-image node.\n     *  `clipboard` configures the kit weasel-JSON paste handler: enabled by\n     *  default (pastes of weasel clipboard payloads re-materialize through\n     *  this canvas's adapter); `reviver` restores JSON-unfriendly values the\n     *  copying side encoded via `jsonReplacer` (typed arrays etc.);\n     *  `enabled: false` opts the canvas out — but note the kit handler\n     *  still consumes weasel-matching items at match time; on a disabled\n     *  canvas it declines inert (a dwarn, nothing ingested) rather than\n     *  falling through. Only items that never match (non-weasel text)\n     *  flow on to other handlers.\n     *  `clipboard` also governs Cmd/Ctrl+V under the `edit` preset; the rest\n     *  takes the `ingest` preset.\n     *  Memoize `handlers` (useState/useMemo/module const) — an inline array\n     *  literal re-registers the handlers on every render. The same applies\n     *  to `clipboard.reviver`: an inline function identity-churns the\n     *  memoized clipboard ctx each render (harmless but wasteful). */\n    ingestion?: {\n      handlers?: ContentHandlerEntry[];\n      resolveSrc?: (file: File) => Promise<string>;\n      svg?: SvgIngestOptions;\n      clipboard?: {\n        reviver?: (key: string, value: unknown) => unknown;\n        enabled?: boolean;\n        /** Called when a paste left copied nodes out, with each one and the\n         *  reason. `useClipboardOps` takes the same callback as\n         *  `onPasteOmitted` for a paste from its own in-memory copy. */\n        onOmitted?: (omitted: PasteOmission[]) => void;\n      };\n    };\n\n    // --- Selection ---\n    selection?: SelectionApi;\n    selectionOptions?: UseSelectionOptions;\n\n    /**\n     * `false` stops the canvas writing the selection: no click, marquee,\n     * lasso, action or tool, and no op committed through the adapter it hands\n     * its tools. The consumer's own `SelectionApi` — the `selection` prop, or\n     * `useSelection({ scene })` — still writes, and the canvas draws what it\n     * holds. Undo and redo still restore the selection each history entry\n     * recorded. Default `true`.\n     *\n     * Click policy (whether shift-click extends) is the selection's `mode`:\n     * `useSelection({ mode: 'multi' })`, or `selectionOptions={{ mode: 'multi' }}`\n     * for the selection the canvas builds itself.\n     */\n    selectable?: boolean;\n\n    /**\n     * Behavior presets to turn on, composable in any combination. A canvas\n     * with none renders its scene and keeps a selection (the `selection` API\n     * works) that no input sets: no tools, no standard actions or their keys,\n     * no clipboard, no drop or paste, and no selection chrome. The dispatcher\n     * is still mounted, so bindings a consumer adds work.\n     *\n     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool\n     *   (H, or hold Space). Passing `viewport` implies it.\n     * - `select` — the select tool, as the initial active tool and Escape's\n     *   return target: click to pick, drag on empty to marquee, click on empty\n     *   to clear.\n     * - `outline` — the selection outline, whichever tool sets the selection.\n     * - `pick` — `select` and `outline`.\n     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it\n     *   runs under any tool that does not claim the drag.\n     * - `resize` — resize handles, drawn and bound.\n     * - `rotate` — the rotation handle, drawn and bound.\n     * - `transform` — `resize` and `rotate`.\n     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,\n     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,\n     *   and their keys. Cmd/Ctrl+V pastes nodes a kit canvas copied, from\n     *   this tab or another, and nothing else.\n     * - `arrange` — align, distribute, reorder, flip.\n     * - `paths` — pathfinder operations, path-edit entry and anchor editing.\n     * - `ingest` — dropped and pasted content: images, SVG, files, and\n     *   whatever `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop.\n     * - `draw` — all of the above.\n     *\n     * Tools add the actions they bind — a shape tool brings `insert` — so\n     * `defaultTools` composes with any preset. `actions` then adds, overrides\n     * or removes on top of what the presets registered.\n     */\n    features?: readonly Feature[];\n\n    // --- Tools: extend, override, or take over ---\n    /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.\n     *\n     *  **Patch form** (`Record<string, AnyTool | true | false>`): merged\n     *  into the built-in registry on top of whatever `defaultTools` and\n     *  `features` already selected.\n     *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,\n     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown\n     *      built-in ids warn in dev and are ignored.\n     *    - `AnyTool` adds a new id or replaces an existing one\n     *      (dev-only warning on replace).\n     *    - `false` omits a bundled tool entirely.\n     *  Auto-wiring (keybindings, dispatcher, action registry) still runs.\n     *\n     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and\n     *  this `tools` value is forwarded to Canvas as-is — the consumer owns\n     *  active-slot management, and `pick`'s select tool is theirs to supply.\n     *  Every other preset still applies. Keybindings are still auto-wired\n     *  against the supplied registry; pass `enableKeybindings={false}` to opt\n     *  out. */\n    tools?: ToolsApi | Record<string, AnyTool | true | false>;\n\n    /**\n     * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas\n     * still mounts its tools but routes no keyboard input to them: it neither\n     * subscribes the legacy `useKeybindings` hook (tool hotkeys) nor lets the\n     * gesture dispatcher attach its `keydown`/`keyup` listeners (modern\n     * keyboard-bound actions like delete / escape / nudge). Pointer, wheel, and\n     * contextmenu interactions are unaffected. Leaves the consumer free to call\n     * `useKeybindings(tools, { ... })` themselves (e.g. with `disable`,\n     * `overrides`, or `defaultTool`).\n     */\n    enableKeybindings?: boolean;\n\n    /**\n     * Take the keyboard on mount, as a press in the canvas would. A key that\n     * reaches the page goes to the canvas the user last pressed or scrolled\n     * in, and to no canvas before the first such interaction, so a canvas in a\n     * side panel does not take Space from a page that wants it. An app whose\n     * canvas is the page sets this so its shortcuts work before the first\n     * click. Default `false`.\n     */\n    claimKeys?: boolean;\n\n    /**\n     * Auto-mount the gesture dispatcher (`useGestureDispatcher`) inside\n     * `<SceneCanvas>`. Default `true`. When `false`, the dispatcher is not\n     * wired — useful in tests or demos that drive actions through alternative\n     * mechanisms, or that want to call `useGestureDispatcher` themselves.\n     *\n     * The dispatcher reads registered actions' `defaultBinding` fields and\n     * routes matching window keydown / canvas pointer / wheel events to the\n     * corresponding `invoker.run` (or `invoker.start` for ongoing gestures).\n     */\n    enableGestureDispatcher?: boolean;\n\n    /**\n     * Called once after SceneCanvas constructs (or receives) its\n     * `ToolsApi`. Useful for introspection — e.g. the toolkit-builder\n     * dev surface walks `tools.registry` to render the live route table.\n     * Fires with the consumer-supplied `tools` prop when present, or with\n     * the internally-synthesized one otherwise.\n     */\n    onToolsCreated?: (tools: ToolsApi) => void;\n\n    /**\n     * Built-in tools SceneCanvas registers in its internal `useTools`, on top\n     * of the ones presets bring (`select` from `pick`, `hand` from `view`).\n     * Default: none. Each tool also registers the kit actions it binds, so\n     * `['rect']` brings `insert`. Ignored when the consumer supplies their own\n     * `tools` prop.\n     */\n    defaultTools?: readonly BuiltinToolId[];\n\n    /** Per-tool option overrides for the built-in shape/lasso/clone tools.\n     *  Each entry is a narrow subset of the underlying hook's options\n     *  surface — `lasso.mode`, `clone.cloneSelection`, etc. */\n    toolOptions?: BuiltinToolOptions;\n\n    /** Initial active-slot tool id. Default: `'select'` when it is\n     *  registered, otherwise none — a canvas can run on ambient bindings\n     *  alone. Must be one of the registered tools. The lasso demo starts with\n     *  `initialActiveTool=\"lasso\"`. Ignored when the consumer supplies their\n     *  own `tools` prop. */\n    initialActiveTool?: string;\n\n    /** Always-on entries to register alongside the internal tools — every one\n     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions\n     *  and `attach` all install from this one list, and uninstall when the\n     *  entry leaves it. A tool is a contribution too, so one can go here. If\n     *  you supply your own `tools` prop, this is ignored — wire `ambient`\n     *  through your own `useTools` call instead. */\n    ambient?: readonly SurfaceContribution[];\n\n    /** What an entry's `requires` does when the running kit does not meet\n     *  it: `'warn'` (the default) logs in development, `'strict'` throws,\n     *  `'off'` skips the check. */\n    versionCheck?: VersionCheck;\n\n    /** Touch and pen long-press: its hold time, its haptic, and the\n     *  feedback shown while it is held. */\n    longPress?: SceneCanvasLongPress;\n\n    /** Configures the `view` preset, and implies it: passing this turns\n     *  `view` on.\n     *\n     *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or\n     *    an object to tune. Omitted means off.\n     *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0) and `pinchZoom`\n     *    (two-finger pinch) are on under `view`; pass `false` to disable one.\n     *    All three are wired by registering the kit's `viewport.*` action\n     *    descriptors with the actions registry — disabling via the `actions`\n     *    prop (`actions: { 'viewport.wheelPan': null }`) also works and runs\n     *    after this.\n     *\n     *  Without `view`, none of them are wired. */\n    viewport?: {\n      inertia?: boolean | { friction?: number; minSpeed?: number; boundary?: 'stop' | 'bounce' | 'spring'; bounds?: PanBounds };\n      /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8\n       *  clamp; `false` disables. An object sets the scale clamp. */\n      pinchZoom?: boolean | PinchZoomOptions;\n      /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults\n       *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes\n       *  duration, easing, interpolator and the reset-branch duration. Wheel\n       *  and pinch are unaffected — their input already samples every frame. */\n      animatedZoom?: boolean | ViewportZoomAnimateOptions;\n      /** Wheel pan. `true`/omitted = on; `false` disables; an object locks the\n       *  axis (`{ axis: 'x' }`) so a single-axis viewport needs no commit clamp. */\n      pan?: boolean | WheelPanOptions;\n      /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the\n       *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}\n       *  object to bind zoom to plain wheel (`wheel: 'plain'`, pair with\n       *  `pan: false`) and/or set `min`/`max` scale clamps. */\n      zoom?: boolean | ViewportZoomOptions;\n      /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).\n       *  When supplied, replaces the default reset-to-identity behavior —\n       *  consumers typically refit the document page into the workspace via\n       *  `fitViewToBounds`. Return the target `View` to let the kit animate\n       *  there when `animatedZoom` is on; return nothing to dispatch it\n       *  yourself, which is what a controlled canvas does. */\n      recenter?: () => View | void;\n    };\n\n    /**\n     * @experimental\n     * Override / disable / extend the default action set. Resolution rules:\n     * see `docs/superpowers/specs/2026-05-09-actions-registry-design.md` §D.\n     * Pass `null` to disable all defaults.\n     */\n    actions?: ActionsProp;\n\n    /**\n     * @experimental\n     * Inputs the kit can't synthesize on its own — currently `cloneNode`\n     * for the `duplicate` default. When omitted, the `duplicate` default is\n     * silently dropped from the registered set.\n     */\n    /** @deprecated unused after legacy-bridge removal; will be deleted */\n    actionDefaults?: {\n      cloneNode?: (id: NodeId, offset: { dx: number; dy: number }) => { id: NodeId };\n      /** Per-clone offset for the duplicate default. Default {dx:8,dy:8}. */\n      duplicateOffset?: { dx: number; dy: number };\n      /** Base nudge step. Default 1. */\n      nudgeStep?: number;\n      /** Shifted nudge step. Default 10. */\n      nudgeShiftStep?: number;\n    };\n\n    /**\n     * @experimental\n     * Optional resolver: given a scene node, return a short human-readable\n     * \"kind\" label (e.g. `'rectangle'`, `'path'`, `'sticky note'`). When\n     * supplied, the kit publishes per-id kinds into any surrounding\n     * `<SelectionContextProvider>` so non-canvas UI (palette, status bar)\n     * can render type-aware copy. Return `undefined` to skip an entry.\n     *\n     * Default behavior when omitted: containers report `'group'`, paths\n     * (poses with a `kind` property) report `'path'`, everything else is\n     * left unlabelled.\n     */\n    describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;\n\n    /**\n     * Optional animator to bind for per-frame redraws. When supplied,\n     * SceneCanvas subscribes to `animator.onTick` and requests a redraw on\n     * every active animation frame, and paints `animator.colorOverrides`\n     * onto the scene's nodes: the kit's path and shape painters apply them,\n     * and a custom `drawOne` receives them as `ctx.vertexColors`. Scene\n     * mutations trigger repaints automatically, but `colorOverrides` writes\n     * do not.\n     *\n     * Omit when no animation channel touches the render pipeline; idle\n     * frames don't cost anything if no animations are active (the animator's\n     * subscriber list stays quiet).\n     */\n    animator?: Animator;\n\n    /**\n     * Extra views on this canvas: each is a camera over a rect of the same\n     * surface, drawn through one GL context, with input routed to it. The flat\n     * `view` / `onViewChange` props above stay the canvas's own camera — view\n     * zero — and are unaffected by anything declared here.\n     *\n     * Order is paint and hit order, low to high. Each entry is a\n     * `<CanvasView>`; mounting one as a child is the same declaration, and\n     * children land after every entry here.\n     */\n    views?: readonly CanvasViewProps[];\n\n    /**\n     * Children rendered alongside the canvas, inside its input scope (e.g.\n     * shortcuts overlays, probes).\n     */\n    children?: ReactNode;\n\n    /**\n     * A yoke to join, from `useYoke()`: canvases on one yoke share the\n     * active tool, the gesture in flight and history. Omitted, this canvas\n     * keeps its own.\n     */\n    yoke?: Yoke;\n\n    /**\n     * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,\n     * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a\n     * composable {@link Condition} built from the\n     * `cond()` builder. Merged on top of the kit's `defaultVisibilityRules`;\n     * unspecified ids fall through to the defaults.\n     *\n     * Set an id to `never` to suppress a chrome element entirely (also\n     * unhittable). Set to `always` to force-show. Mix `cond(...)` chains\n     * (e.g. `selectionIs(1).and(focused).andNot(gesturing)`) for the in-\n     * between cases.\n     */\n    chromeVisibility?: import('features/chrome-caps').VisibilityRules;\n\n    /**\n     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).\n     * The canvas reads the active mode from it to gate chrome, tool\n     * activation and the dispatcher's eligibility filter, repaints when it\n     * switches, and hands every registered mode to the dev-time route-conflict\n     * check. Omitted, the canvas behaves as the kit's normal mode and nothing\n     * revokes anchor editing.\n     */\n    modes?: ModeRegistry;\n\n    /**\n     * Override detected device facts. Merged over what `matchMedia` reports;\n     * `targetScale` is re-derived from the merged `coarsePointer` unless you\n     * override it explicitly.\n     *\n     * Reach for this in three cases: tests that need a coarse profile without\n     * stubbing `matchMedia`, demos that want to show touch-sized chrome on a\n     * desktop, and hybrid devices where the media query guesses wrong.\n     */\n    device?: Partial<DeviceProfile>;\n\n    /**\n     * Optional live focus getter for chrome-caps' `focused` ctx field.\n     * SceneCanvas does not own focus state by default — wire this when\n     * your visibility rules read the `focused` atom (e.g. the kit's\n     * default `selection.rotation-handle` rule requires focus). Omit\n     * to default `focused` to `true` (rule fires regardless of focus).\n     */\n    getFocused?: () => boolean;\n\n    /**\n     * Custom shader programs to compile on the renderer. Forwarded directly\n     * to `<Canvas shaders={...} />`. See `CanvasProps.shaders` for details.\n     */\n    shaders?: ShaderProgramHandle[];\n\n    /**\n     * Flatness tolerance for curve tessellation, in world units. Forwarded\n     * directly to `<Canvas flattenTolerance={...} />`. See\n     * `CanvasProps.flattenTolerance` for details.\n     */\n    flattenTolerance?: number;\n\n    /**\n     * FillStyle applied to the full canvas behind the scene. Accepts the kit's\n     * `FillStyle` union (solid / pattern / linear-gradient / radial-gradient /\n     * conic-gradient) so consumers don't have to author a background node\n     * just to colorize the canvas. Rendered as a screen-space layer slotted\n     * before `'scene'` — independent of pan / zoom.\n     */\n    backgroundFill?: FillStyle;\n    /**\n     * Dev HUD: when true, mounts a fixed-position widget in the top-left\n     * of the viewport showing live cursor coords in both viewport\n     * (client) and canvas (world) frames. Useful for diagnosing pointer-\n     * coord drift / pan-zoom misalignment without instrumenting events.\n     */\n    cursorCoordsHud?: boolean;\n    /**\n     * Dev HUD: when true, mounts a fixed-position widget just below the\n     * cursor-coords HUD listing the ids returned by `pickEvery(world)`\n     * under the cursor. Useful for diagnosing hit-test order and\n     * container/leaf overlap during select-tool work.\n     */\n    pickHud?: boolean;\n    /**\n     * The debug overlay: `<Canvas debug>`'s config, plus `slops: true` for\n     * translucent halos at every affordance hit zone. `false` turns it off;\n     * absent reads `?debug=…` from the URL, as `<Canvas>` does.\n     */\n    debug?: (DebugConfig & { slops?: boolean }) | false;\n    /**\n     * Dev HUD: when true (or object), mounts a fixed-position widget below\n     * the pick HUD showing the active modality mode, active-slot tool, and\n     * hotkey stack. Pass `{ modeId }` to populate the mode line.\n     */\n    modalityHud?: boolean | { modeId?: string };\n\n    /**\n     * Optional per-id alpha multiplier for the scene-render slot. When\n     * supplied, each node's draw output is wrapped in a `GroupDrawCommand`\n     * with the returned alpha so the renderer applies the multiplier.\n     * Values equal to 1 are a no-op (no wrapper emitted). Typical use:\n     * scoping-dim integration dims non-active nodes during a mode transition.\n     *\n     * Defaults to `() => 1` (no effect).\n     */\n    alphaFor?: (id: string) => number;\n\n    /**\n     * Show or hide render layers in this canvas's own view, by id — the map\n     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed\n     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer\n     * here and nowhere else.\n     *\n     * A layer hidden this way is gone from this view: it does not paint, and a\n     * click, a marquee or Cmd+A here passes over it. Another view of the same\n     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and\n     * can still take it. It applies on top of the scene's own\n     * `LayerRecord.visible` and cannot show a layer the scene hides.\n     */\n    layerVisibility?: Record<string, boolean>;\n\n    /**\n     * Draw order for this view, by render-layer id, bottom first. A listed\n     * order is the whole list: a scene layer left out of it is neither painted\n     * nor picked here. See `CanvasProps.layerOrder`.\n     */\n    layerOrder?: string[];\n\n    /**\n     * Optional per-id pointer-interactivity predicate. When supplied, ids\n     * for which the predicate returns `false` are excluded from hit-test\n     * results — `getNodeAtPoint` returns null for those positions.\n     * Typical use: scoping-dim integration suppresses pointer events for\n     * non-active nodes during a mode transition.\n     *\n     * Defaults to `() => true` (all nodes are interactive).\n     */\n    isPointerInteractive?: (id: string) => boolean;\n\n    /**\n     * Called when the user double-clicks the canvas. Receives the hit node\n     * (id + kind) at the double-click position, or `null` when the click\n     * lands on empty canvas. Wired internally via a `dblclick` listener on\n     * the canvas element so it doesn't interfere with the pointer-gesture\n     * pipeline.\n     *\n     * Typical use: modality dispatch — enter path-edit on a path node,\n     * isolation on a group, text-edit on a text node.\n     */\n    onDoubleClick?: (hit: SceneCanvasHit | null) => void;\n    /** Called on every click — a press and release without a drag — with the\n     *  node under it, or `null` on empty canvas. Fires after the click's own\n     *  behavior, so a pick it made is already in the selection, and fires\n     *  again on a node that was already picked. */\n    onClick?: (hit: SceneCanvasHit | null) => void;\n  };\n"],"mappings":";;;;;AAyEA,IAAaA,IAAsBC;AAkDnC,SAAgBC,EACd,GACA,IAAc,GACgC;CAC9C,IAAMC,IAAW;EACf,OAAO;GACL,SAASC;GAIT,aAAaC;EACf;EACA,kBAAkB,EAAE,SAAS,EAAE,MAAMC,EAAcC,CAAW,CAAC,CAAC,OAAO,EAAE;CAC3E;CAEA,IAAI,CAACC,GAAM,OAAOL;CAGlB,IAAMM,IAAS,EAAE,GAAGD,EAAK;CAEzB,IAAI,EAAE,WAAWA,IACf,EAAO,QAAQL,EAAS;MACnB,IAAIK,EAAK,UAAU,MACxB,EAAO,QAAQ;MACV;EACL,IAAME,IAAQ;GAAE,GAAGP,EAAS;GAAO,GAAGK,EAAK;EAAM;EACjD,EAAO,QAAQA,EAAK,SAAS,iBAAiBA,EAAK,QAC/CE,IACA;GAAE,GAAGA;GAAO,aAAaC,EAAqCD,EAAM,OAAO;EAAE;CACnF;CAUA,OARA,AACED,EAAO,mBADH,sBAAsBD,IAEjBA,EAAK,qBAAqB,OACT,OAEA;EAAE,GAAGL,EAAS;EAAkB,GAAGK,EAAK;CAAiB,IAJzDL,EAAS,kBAO9BM;AACT;AAQA,IAAaG,IAAiF,CAAC,UAAU,MAAM,GAGlGC,IAA6C,CAAC,GAAGD,GAAyB,GAAGE,CAAe"}
+{"version":3,"file":"props.js","names":["DEFAULT_HANDLE_SIZE","HANDLE_BASE_PX","mergeLayersWithDefaults","defaults","defaultDrawOne","defaultPaintBounds","targetSizesPx","targetScale","user","result","isCustomEntry","scene","paintBoundsFor","NON_SHAPE_BUILTIN_TOOLS","BUILTIN_TOOL_IDS","KIT_SHAPE_KINDS"],"sources":["../../../src/canvas/SceneCanvas/props.ts"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport type { PathEditHost } from './pathEditHost';\nimport type { Paint } from '@weasel-js/paint';\nimport type { ActionsProp, ActionTunings } from '@weasel-js/routing';\nimport { Yoke } from '@weasel-js/routing/react';\nimport type { PasteOmission } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene, SerializedScene } from 'core/scene/types';\nimport type { SelectionApi, UseSelectionOptions } from 'core/selection/useSelection';\nimport { KIT_SHAPE_KINDS, type BuiltinShapeToolId } from 'core/shapeKinds';\nimport type {\n  ContentHandlerEntry\n} from 'features/ingestion';\nimport type { SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { UseRotateOptions } from 'interactions/actions/rotate/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport type { ReactNode } from 'react';\nimport type { Bounds } from 'tools/builtin/select';\nimport type { Animator } from '@weasel-js/animator';\nimport { HANDLE_BASE_PX, targetSizesPx } from '../../core/device/targets';\nimport type { DeviceProfile } from '../../core/device/types';\nimport type { NodeRoutingEntry } from '../../core/scene/NodeRouting';\nimport type { DebugConfig } from '../../debug/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { DrawCommand, ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { Tool, ToolsApi } from '../../tools/overlayBinding';\nimport type { SceneSlotConfig } from '../buildSceneLayer';\nimport type { CanvasProps } from '../Canvas';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport type { CanvasViewProps } from '../CanvasView';\nimport { defaultDrawOne, defaultPaintBounds, paintBoundsFor } from '../defaultDrawOne';\nimport type {\n  InsertNodeFactory,\n  InsertPaint\n} from '../deps';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport type { CameraProps } from '../useCanvasView';\nimport type {\n  Feature\n} from './features';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\nimport type { VersionCheck } from './useContributionRoles';\nimport type { SceneCanvasViewport } from './viewportProp';\n\n/** The adapter surface delete / duplicate / group / ungroup need, narrowed from\n *  `SceneCanvasAdapter` because `StandardActionsRegistrar` is non-generic. */\nexport interface BridgeAdapter {\n  applyOps(ops: Op[], label?: string): void;\n  insertNode(node: { id: string; [k: string]: unknown }): void;\n  removeNode(id: string): void;\n  setSelection(ids: string[]): void;\n}\n\n/** Default size in CSS pixels for selection corner-handles AND their\n *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal\n *  use sites multiply by `DeviceProfile.targetScale`. */\nexport const DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\n/** `<SceneCanvas longPress>`. */\nexport interface SceneCanvasLongPress {\n  /**\n   * Shown while a long-press is held and some binding would fire on it.\n   * Default: a ring that fills around the press point\n   * (`createLongPressFeedbackContribution()`), static under\n   * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces\n   * it, reading the `longPress` dep. Installed beside `ambient`, so under a\n   * `tools` takeover add it to your own `useTools` call instead.\n   */\n  feedback?: boolean | SurfaceContribution;\n  /** Default true. A long-press some binding handled pulses\n   *  `navigator.vibrate` briefly, for touch and pen, where the API exists. */\n  haptics?: boolean;\n  /** Hold time in ms. Default `LONG_PRESS_MS` (500). */\n  duration?: number;\n}\n\n/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,\n *  since the defaults fill in whatever it leaves out. */\nexport type SceneCanvasLayers<TNode extends { id: string }, TPose> = LayersMap<\n  TNode,\n  TPose,\n  Partial<SceneSlotConfig<TNode, TPose>>\n>;\n\n/** Deep-merge user-supplied `layers` with kit defaults. Slots the user\n *  doesn't mention get filled with defaults; slots explicitly set to\n *  `null` are dropped. Partial slot configs are shallow-spread on top of the\n *  default slot config. `targetScale` comes from the resolved {@link DeviceProfile}. */\nexport function mergeLayersWithDefaults<TData, TLayer extends string, TPose>(\n  user: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined,\n  targetScale = 1,\n): LayersMap<Node<TData, TLayer, TPose>, TPose> {\n  const defaults = {\n    scene: {\n      drawOne: defaultDrawOne as (\n        node: Node<TData, TLayer, TPose>,\n        pose: TPose,\n      ) => DrawCommand[],\n      paintBounds: defaultPaintBounds<TData, TLayer, TPose>,\n    },\n    selectionOverlay: { handles: { size: targetSizesPx(targetScale).handle } },\n  };\n\n  if (!user) return defaults as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  // Start from a shallow copy of the user map so unknown slots pass through.\n  const result = { ...user } as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  if (!('scene' in user)) {\n    result.scene = defaults.scene;\n  } else if (user.scene === null || isCustomEntry(user.scene)) {\n    result.scene = user.scene;\n  } else {\n    const scene = { ...defaults.scene, ...user.scene };\n    result.scene = user.scene && 'paintBounds' in user.scene\n      ? scene\n      : { ...scene, paintBounds: paintBoundsFor<TData, TLayer, TPose>(scene.drawOne) };\n  }\n\n  if (!('selectionOverlay' in user)) {\n    result.selectionOverlay = defaults.selectionOverlay;\n  } else if (user.selectionOverlay === null || isCustomEntry(user.selectionOverlay)) {\n    result.selectionOverlay = user.selectionOverlay;\n  } else {\n    result.selectionOverlay = { ...defaults.selectionOverlay, ...user.selectionOverlay };\n  }\n\n  return result;\n}\n\n/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop\n *  is supplied, via `defaultTools`. */\nexport type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId;\n\n/** Built-in tool ids that aren't shape tools — the ones with no entry in\n *  the `core/shapeKinds` table. */\nexport const NON_SHAPE_BUILTIN_TOOLS: readonly Exclude<BuiltinToolId, BuiltinShapeToolId>[] = ['select', 'hand'];\n\n/** Every built-in tool id, shape tools included. */\nexport const BUILTIN_TOOL_IDS: readonly BuiltinToolId[] = [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS];\n\n/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields\n *  modality dispatch needs; extends as the kit's `Hit` type evolves. */\nexport interface SceneCanvasHit {\n  id: string;\n  kind: string;\n}\n\n/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing\n *  else it renders that scene and keeps a selection no input sets; `features`\n *  turns behavior on by preset, and the rest configures what those turn on. */\nexport type SceneCanvasProps<TData, TLayer extends string, TPose> =\n  Omit<\n    CanvasProps<TPose>,\n    | 'adapter' | 'boundsOf' | 'selection' | 'tools'\n    | 'viewState'       // SceneCanvas makes the camera from the view props below\n    | 'layers'          // stripped so we can re-add as optional below\n    | 'getIsVisible'    // SceneCanvas synthesizes this from chromeVisibility\n    | 'contentVersion'  // SceneCanvas wires this to the scene's own version\n    | 'layerVisibility' | 'layerOrder' // re-declared below: they gate picking here too\n    | 'debug'           // re-declared below with SceneCanvas's own `slops`\n  > & CameraProps\n  & {\n    /** A `Scene` (typically from `useScene`) — or a `SerializedScene` JSON\n     *  object, which SceneCanvas bakes into a Scene on first render. The\n     *  serialized form is read once; pass a `key` on `<SceneCanvas>` to force\n     *  a fresh canvas from updated JSON.\n     *\n     *  The JSON shape is relaxed (`version: number` rather than the `1`\n     *  literal) so an `import json from './x.json'` result satisfies the type\n     *  without an `as` cast. */\n    scene:\n      | Scene<TData, TLayer, TPose>\n      | SerializedScene<TData, TLayer, TPose>\n      | { version: number; systemLayers?: ReadonlyArray<{ id: string }>; nodes: ReadonlyArray<unknown> };\n\n    /** Layer configuration. When omitted, SceneCanvas applies kit defaults\n     *  (a scene slot that paints `node.data.fill` rects + a default\n     *  selection overlay). A partial scene or selection-overlay config is\n     *  spread over that slot's defaults; pass `slot: null` to suppress a\n     *  default explicitly. */\n    layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;\n\n    /** Which layout container a drag lands in when several contain the drop\n     *  point — the innermost (default), the topmost in paint order, or only\n     *  containers whose strategy declares a `dropRegion`. Decides both the\n     *  drag-time reflow preview and the commit. */\n    layoutDropTarget?: LayoutDropTargetMode;\n\n    /** Carries the siblings a layout reflow displaces to their slots over time\n     *  instead of snapping them — `useAnimatedReflow` builds one. Covers a\n     *  drag's reflow and every one the scene records (an insert, delete,\n     *  reorder or resize inside a laid-out container). Absent or `null`,\n     *  they snap. */\n    reflowTransition?: ReflowTransition<TPose> | null;\n\n    /**\n     * Lets pose-transform actions (move, resize, nudge, flip — NOT rotate) also rewrite a\n     * node's data-held geometry. Given a node and the affine `m` applied to its pose,\n     * `transform(node, m)` returns updated `data`, or `null` for nodes with no data-held\n     * geometry. When absent, the kit emits only the pose op and leaves `data` untouched.\n     *\n     * @see GeometryProjection\n     */\n    geometryProjection?: GeometryProjection;\n\n    /**\n     * Routing-trait classifiers. The kit builds a `NodeRouting` registry per `<SceneCanvas>`\n     * from this prop and uses it to derive each hit's `kind`, which tool routing tables\n     * (e.g. `{ target: 'rect', actionId: 'move' }`) match against. Pass `defaultNodeRouting`\n     * for the kit's built-in shape kinds; spread additional entries for consumer-defined\n     * kinds.\n     *\n     * **Memoize the `routing` value.** The registry is memoized on the prop's reference\n     * identity: a fresh array each render rebuilds it and cascades into a new adapter,\n     * churning gesture state.\n     */\n    routing?: readonly NodeRoutingEntry[];\n\n    /** How to read and rewrite this scene's poses. Every built-in action,\n     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`\n     *  (rect poses and `Path` poses). */\n    poseDescriptor?: PoseDescriptor<TPose>;\n\n    // --- Geometry: hit-test + bounds overrides consumed by the internal\n    //     `useSelectTool`. Ignored if the consumer passes their own `tools`. ---\n    geometry?: {\n      /** Hit-test override. Return the topmost id, the full back-to-front hit\n       *  stack (`string[]`), or `null` for empty space. The stack form lets a\n       *  consumer with domain overlap ordering (e.g. children over their\n       *  container) feed the kit's `pickTopMostHit` the true order instead of\n       *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */\n      pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n      boundsOf?: (id: string) => Bounds | null;\n      /**\n       * What \"the pointer is on this node\" means for the default body-pick.\n       *\n       * - `'pose'` — the node's pose rect, rotation honored.\n       * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter\n       *   actually lays down: its silhouette filled or not per the painter's `ink`, plus\n       *   its outline widened by the stroke half-width and `pickTolerancePx`.\n       *\n       * Painters with no silhouette keep the pose-rect answer either way. Ignored when\n       * `pickEvery` is supplied: that override owns the test.\n       */\n      picking?: 'pose' | 'shape';\n      /**\n       * Grab slop around a shape's outline, in **screen** pixels, so the target keeps\n       * its apparent size at any zoom. Default 4. It widens the outline test under\n       * `picking: 'shape'` and grows the pose-rect pre-filter so those outline hits\n       * survive it. Set `0` for exact geometry.\n       */\n      pickTolerancePx?: number;\n    };\n\n    // --- Selection options. `pickBest` and `handleHitRadius` configure the\n    //     internal select tool, and are ignored under a `tools` takeover;\n    //     `move`, `snap`, `resize` and `rotate` configure the `move`,\n    //     `resize` and `rotate` presets, and apply either way. ---\n    selectTool?: {\n      move?: UseMoveOptions<TPose>;\n      resize?: UseResizeOptions<TPose>;\n      /** Rotation options, or `false` to disable rotation entirely — drops the\n       *  `rotate` action AND hides the selection rotation-handle chrome. */\n      rotate?: UseRotateOptions<TPose> | false;\n      snap?: SnapStrategy<TPose>;\n      handleHitRadius?: number;\n      /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n       *  the live alt state + current selection so consumers can implement\n       *  alt-cycling through an overlapping stack. Default: top-most hit\n       *  (alt ignored). */\n      pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    };\n\n    /** Consumer node factories for the `insert` action, keyed by tool `kind`.\n     *  Each factory receives the drag AABB + tool `extras` and returns the\n     *  node's `data` (in this canvas's own data shape) plus an optional `pose`.\n     *  A factory for a kit kind (`rect`, `line`, …) replaces the kit's default\n     *  `{ path, fill }` node for that kind; a factory for a novel kind (e.g.\n     *  `text`) adds insert support the kit doesn't ship. The dep supplies id,\n     *  layer, and the undoable op. Return `null` to reject an insert. */\n    insertNodeFactories?: Record<string, InsertNodeFactory>;\n\n    /** The fill, stroke, and fill rule a kit-built shape is inserted with, by\n     *  tool `kind` and insert count; the kit keeps the geometry. Default\n     *  `paletteInsertPaint`, the kit palette in turn. A kind with a factory in\n     *  `insertNodeFactories` is not asked. */\n    insertPaint?: InsertPaint;\n\n    /** External-content ingestion (OS drop / clipboard paste / picker).\n     *\n     *  - `handlers` — consumer content handlers registered for this canvas's\n     *    lifetime (priority 0 by default — they beat the kit's `image/*` /\n     *    `image/svg+xml` handlers at -100/-90).\n     *  - `resolveSrc` — overrides the image handler's `data:`-URI embed (e.g.\n     *    upload to an asset store, return the URL).\n     *  - `svg.unpack` — makes the kit SVG handler parse dropped SVG files into\n     *    native scene nodes instead of one embedded-image node each.\n     *  - `clipboard` — the kit weasel-JSON paste handler, enabled by default.\n     *    `reviver` restores JSON-unfriendly values the copying side encoded via\n     *    `jsonReplacer`. `enabled: false` opts the canvas out, but the kit\n     *    handler still consumes weasel-matching items and declines them inert\n     *    rather than letting them fall through. Also governs Cmd/Ctrl+V under\n     *    the `edit` preset; the rest takes the `ingest` preset.\n     *\n     *  Memoize `handlers` and `clipboard.reviver`: an inline array literal\n     *  re-registers the handlers on every render. */\n    ingestion?: {\n      handlers?: ContentHandlerEntry[];\n      resolveSrc?: (file: File) => Promise<string>;\n      svg?: SvgIngestOptions;\n      clipboard?: {\n        reviver?: (key: string, value: unknown) => unknown;\n        enabled?: boolean;\n        /** Called when a paste left copied nodes out, with each one and the\n         *  reason. `useClipboardOps` takes the same callback as\n         *  `onPasteOmitted` for a paste from its own in-memory copy. */\n        onOmitted?: (omitted: PasteOmission[]) => void;\n      };\n    };\n\n    selection?: SelectionApi;\n    selectionOptions?: UseSelectionOptions;\n\n    /**\n     * `false` stops the canvas writing the selection: no click, marquee,\n     * lasso, action or tool, and no op committed through the adapter it hands\n     * its tools. The consumer's own `SelectionApi` — the `selection` prop, or\n     * `useSelection({ scene })` — still writes, and the canvas draws what it\n     * holds. Undo and redo still restore the selection each history entry\n     * recorded. Default `true`.\n     *\n     * Click policy (whether shift-click extends) is the selection's `mode`:\n     * `useSelection({ mode: 'multi' })`, or `selectionOptions={{ mode: 'multi' }}`\n     * for the selection the canvas builds itself.\n     */\n    selectable?: boolean;\n\n    /**\n     * Behavior presets to turn on, composable in any combination. A canvas\n     * with none renders its scene and keeps a selection (the `selection` API\n     * works) that no input sets: no tools, no standard actions or their keys,\n     * no clipboard, no drop or paste, and no selection chrome. The dispatcher\n     * is still mounted, so bindings a consumer adds work.\n     *\n     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool\n     *   (H, or hold Space). Passing `viewport` implies it.\n     * - `select` — the select tool, as the initial active tool and Escape's\n     *   return target: click to pick, drag on empty to marquee, click on empty\n     *   to clear.\n     * - `outline` — the selection outline, whichever tool sets the selection.\n     * - `pick` — `select` and `outline`.\n     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it\n     *   runs under any tool that does not claim the drag.\n     * - `resize` — resize handles, drawn and bound.\n     * - `rotate` — the rotation handle, drawn and bound.\n     * - `transform` — `resize` and `rotate`.\n     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,\n     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,\n     *   and their keys. Cmd/Ctrl+V pastes nodes a kit canvas copied, from\n     *   this tab or another, and nothing else.\n     * - `arrange` — align, distribute, reorder, flip.\n     * - `paths` — pathfinder operations, path-edit entry and anchor editing.\n     * - `ingest` — dropped and pasted content: images, SVG, files, and\n     *   whatever `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop.\n     * - `draw` — all of the above.\n     *\n     * Tools add the actions they bind — a shape tool brings `insert` — so\n     * `defaultTools` composes with any preset. `actions` then adds, overrides\n     * or removes on top of what the presets registered.\n     */\n    features?: readonly Feature[];\n\n    /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.\n     *\n     *  **Patch form** (`Record<string, Tool | true | false>`): merged\n     *  into the built-in registry on top of whatever `defaultTools` and\n     *  `features` already selected.\n     *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,\n     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown\n     *      built-in ids warn in dev and are ignored.\n     *    - `Tool` adds a new id or replaces an existing one\n     *      (dev-only warning on replace).\n     *    - `false` omits a bundled tool entirely.\n     *  Auto-wiring (keybindings, dispatcher, action registry) still runs.\n     *\n     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and\n     *  this `tools` value is forwarded to Canvas as-is — the consumer owns\n     *  active-slot management, and `pick`'s select tool is theirs to supply.\n     *  Every other preset still applies. Keybindings are still auto-wired\n     *  against the supplied registry; pass `enableKeybindings={false}` to opt\n     *  out. */\n    tools?: ToolsApi | Record<string, Tool | true | false>;\n\n    /**\n     * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas still mounts\n     * its tools but routes no keyboard input to them — neither tool hotkeys nor\n     * keyboard-bound actions like delete / escape / nudge. Pointer, wheel, and contextmenu\n     * interactions are unaffected.\n     */\n    enableKeybindings?: boolean;\n\n    /**\n     * Take the keyboard on mount, as a press in the canvas would. A key that\n     * reaches the page goes to the canvas the user last pressed or scrolled\n     * in, and to no canvas before the first such interaction, so a canvas in a\n     * side panel does not take Space from a page that wants it. An app whose\n     * canvas is the page sets this so its shortcuts work before the first\n     * click. Default `false`.\n     */\n    claimKeys?: boolean;\n\n    /**\n     * Auto-mount the gesture dispatcher (`useGestureDispatcher`). Default `true`. `false` is\n     * for tests or demos that drive actions another way, or that call\n     * `useGestureDispatcher` themselves.\n     */\n    enableGestureDispatcher?: boolean;\n\n    /** Called with the `ToolsApi` SceneCanvas constructs or receives, whenever its identity\n     *  changes. For introspection. */\n    onToolsCreated?: (tools: ToolsApi) => void;\n\n    /**\n     * Built-in tools SceneCanvas registers in its internal `useTools`, on top\n     * of the ones presets bring (`select` from `pick`, `hand` from `view`).\n     * Default: none. Each tool also registers the kit actions it binds, so\n     * `['rect']` brings `insert`. Ignored when the consumer supplies their own\n     * `tools` prop.\n     */\n    defaultTools?: readonly BuiltinToolId[];\n\n    /** Per-tool option overrides for the built-in shape/lasso/clone tools.\n     *  Each entry is a narrow subset of the underlying hook's options\n     *  surface — `lasso.mode`, `clone.cloneSelection`, etc. */\n    toolOptions?: BuiltinToolOptions;\n\n    /** Initial active-slot tool id. Default: `'select'` when it is\n     *  registered, otherwise none — a canvas can run on ambient bindings\n     *  alone. Must be one of the registered tools. Ignored when the consumer\n     *  supplies their own `tools` prop. */\n    initialActiveTool?: string;\n\n    /** Always-on entries to register alongside the internal tools — every one\n     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions\n     *  and `attach` all install from this one list, and uninstall when the\n     *  entry leaves it. A tool is a contribution too, so one can go here. If\n     *  you supply your own `tools` prop, this is ignored — wire `ambient`\n     *  through your own `useTools` call instead. */\n    ambient?: readonly SurfaceContribution[];\n\n    /** What an entry's `requires` does when the running kit does not meet\n     *  it: `'warn'` (the default) logs in development, `'strict'` throws,\n     *  `'off'` skips the check. */\n    versionCheck?: VersionCheck;\n\n    /** Touch and pen long-press: its hold time, its haptic, and the\n     *  feedback shown while it is held. */\n    longPress?: SceneCanvasLongPress;\n\n    /** Configures the `view` preset, and implies it. See {@link SceneCanvasViewport}. */\n    viewport?: SceneCanvasViewport;\n\n    /**\n     * Tune actions on this canvas without restating them, keyed by action id:\n     * `params` every invocation starts from, and `bindings` added beside the\n     * action's own. A tuning applies to whichever descriptor holds the id, a\n     * preset's or a tool's. Pass a stable object; a params thunk is read on\n     * every call. See the core README (\"Tuning an action\").\n     */\n    tune?: ActionTunings;\n\n    /**\n     * @experimental\n     * Replace, add or mute whole action descriptors. Pass `null` to disable\n     * all defaults. To change a built-in's params or add a key, use `tune`.\n     */\n    actions?: ActionsProp;\n\n    /**\n     * @experimental\n     * Given a scene node, return a short human-readable \"kind\" label (e.g. `'rectangle'`,\n     * `'sticky note'`), which the kit publishes per id into any surrounding\n     * `<SelectionContextProvider>`. Return `undefined` to skip an entry. When omitted,\n     * containers report `'group'`, poses with a `kind` property report `'path'`, and\n     * everything else is left unlabelled.\n     */\n    describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;\n\n    /**\n     * Animator to bind for per-frame redraws. SceneCanvas requests a redraw on every active\n     * animation frame and paints `animator.colorOverrides` onto the scene's nodes: the\n     * kit's path and shape painters apply them, and a custom `drawOne` receives them as\n     * `ctx.vertexColors`.\n     */\n    animator?: Animator;\n\n    /**\n     * Extra views on this canvas: each is a camera over a rect of the same\n     * surface, drawn through one GL context, with input routed to it. The flat\n     * `view` / `onViewChange` props above stay the canvas's own camera — view\n     * zero — and are unaffected by anything declared here.\n     *\n     * Order is paint and hit order, low to high. Each entry is a\n     * `<CanvasView>`; mounting one as a child is the same declaration, and\n     * children land after every entry here.\n     */\n    views?: readonly CanvasViewProps[];\n\n    /**\n     * Children rendered alongside the canvas, inside its input scope (e.g.\n     * shortcuts overlays, probes).\n     */\n    children?: ReactNode;\n\n    /**\n     * A yoke to join, from `useYoke()`: canvases on one yoke share the\n     * active tool, the gesture in flight and history. Omitted, this canvas\n     * keeps its own.\n     */\n    yoke?: Yoke;\n\n    /**\n     * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,\n     * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a composable\n     * {@link Condition} built from the `cond()` builder, merged on top of the kit's\n     * `defaultVisibilityRules`. Set an id to `never` to suppress a chrome element\n     * entirely (also unhittable), or to `always` to force-show.\n     */\n    chromeVisibility?: import('features/chrome-caps').VisibilityRules;\n\n    /**\n     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).\n     * The canvas reads the active mode from it to gate chrome, tool\n     * activation and the dispatcher's eligibility filter, repaints when it\n     * switches, and hands every registered mode to the dev-time route-conflict\n     * check. Omitted, the canvas behaves as the kit's normal mode and nothing\n     * revokes anchor editing.\n     */\n    modes?: ModeRegistry;\n\n    /** Hands which path is being anchor-edited to the host. See {@link PathEditHost}. */\n    pathEdit?: PathEditHost;\n\n    /**\n     * Override detected device facts. Merged over what `matchMedia` reports;\n     * `targetScale` is re-derived from the merged `coarsePointer` unless you\n     * override it explicitly.\n     */\n    device?: Partial<DeviceProfile>;\n\n    /**\n     * Live focus getter for chrome-caps' `focused` ctx field, for visibility rules that\n     * read the `focused` atom (the kit's default `selection.rotation-handle` rule does).\n     * Omit to default `focused` to `true`.\n     */\n    getFocused?: () => boolean;\n\n    /** Custom shader programs to compile on the renderer. See `CanvasProps.shaders`. */\n    shaders?: ShaderProgramHandle[];\n\n    /** Flatness tolerance for curve tessellation, in world units. See\n     *  `CanvasProps.flattenTolerance`. */\n    flattenTolerance?: number;\n\n    /** Fill for the full canvas behind the scene, drawn as a screen-space layer slotted\n     *  before `'scene'` — independent of pan / zoom. */\n    backgroundFill?: Paint;\n    /** Dev HUD: a fixed-position widget showing live cursor coords in both viewport\n     *  (client) and canvas (world) frames. */\n    cursorCoordsHud?: boolean;\n    /** Dev HUD: a fixed-position widget listing the ids `pickEvery(world)` returns under\n     *  the cursor. */\n    pickHud?: boolean;\n    /**\n     * The debug overlay: `<Canvas debug>`'s config, plus `slops: true` for\n     * translucent halos at every affordance hit zone. `false` turns it off;\n     * absent reads `?debug=…` from the URL, as `<Canvas>` does.\n     */\n    debug?: (DebugConfig & { slops?: boolean }) | false;\n    /**\n     * Dev HUD: when true (or object), mounts a fixed-position widget below\n     * the pick HUD showing the active modality mode, active-slot tool, and\n     * hotkey stack. Pass `{ modeId }` to populate the mode line.\n     */\n    modalityHud?: boolean | { modeId?: string };\n\n    /**\n     * Per-id alpha multiplier for the scene-render slot: each node's draw output is wrapped\n     * in a group with the returned alpha, and 1 emits no wrapper. Typical use: dimming\n     * non-active nodes during a mode transition.\n     */\n    alphaFor?: (id: string) => number;\n\n    /**\n     * Show or hide render layers in this canvas's own view, by id — the map\n     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed\n     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer\n     * here and nowhere else.\n     *\n     * A layer hidden this way is gone from this view: it does not paint, and a\n     * click, a marquee or Cmd+A here passes over it. Another view of the same\n     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and\n     * can still take it. It applies on top of the scene's own\n     * `LayerRecord.visible` and cannot show a layer the scene hides.\n     */\n    layerVisibility?: Record<string, boolean>;\n\n    /**\n     * Draw order for this view, by render-layer id, bottom first. A listed\n     * order is the whole list: a scene layer left out of it is neither painted\n     * nor picked here. See `CanvasProps.layerOrder`.\n     */\n    layerOrder?: string[];\n\n    /**\n     * Per-id pointer-interactivity predicate: an id it returns `false` for is excluded from\n     * hit-test results. Typical use: suppressing pointer events for dimmed nodes.\n     */\n    isPointerInteractive?: (id: string) => boolean;\n\n    /**\n     * Called when the user double-clicks the canvas, with the hit node (id + kind) at that\n     * position, or `null` on empty canvas. Typical use: modality dispatch — enter path-edit\n     * on a path node, isolation on a group, text-edit on a text node.\n     */\n    onDoubleClick?: (hit: SceneCanvasHit | null) => void;\n    /** Called on every click — a press and release without a drag — with the\n     *  node under it, or `null` on empty canvas. Fires after the click's own\n     *  behavior, so a pick it made is already in the selection, and fires\n     *  again on a node that was already picked. */\n    onClick?: (hit: SceneCanvasHit | null) => void;\n  };\n"],"mappings":";;;;;;AA4DA,IAAaA,IAAsBC;AAgCnC,SAAgBC,EACd,GACA,IAAc,GACgC;CAC9C,IAAMC,IAAW;EACf,OAAO;GACL,SAASC;GAIT,aAAaC;EACf;EACA,kBAAkB,EAAE,SAAS,EAAE,MAAMC,EAAcC,CAAW,CAAC,CAAC,OAAO,EAAE;CAC3E;CAEA,IAAI,CAACC,GAAM,OAAOL;CAGlB,IAAMM,IAAS,EAAE,GAAGD,EAAK;CAEzB,IAAI,EAAE,WAAWA,IACf,EAAO,QAAQL,EAAS;MACnB,IAAIK,EAAK,UAAU,QAAQE,EAAcF,EAAK,KAAK,GACxD,EAAO,QAAQA,EAAK;MACf;EACL,IAAMG,IAAQ;GAAE,GAAGR,EAAS;GAAO,GAAGK,EAAK;EAAM;EACjD,EAAO,QAAQA,EAAK,SAAS,iBAAiBA,EAAK,QAC/CG,IACA;GAAE,GAAGA;GAAO,aAAaC,EAAqCD,EAAM,OAAO;EAAE;CACnF;CAUA,OARA,AACEF,EAAO,mBADH,sBAAsBD,IAEjBA,EAAK,qBAAqB,QAAQE,EAAcF,EAAK,gBAAgB,IACpDA,EAAK,mBAEL;EAAE,GAAGL,EAAS;EAAkB,GAAGK,EAAK;CAAiB,IAJzDL,EAAS,kBAO9BM;AACT;AAQA,IAAaI,IAAiF,CAAC,UAAU,MAAM,GAGlGC,IAA6C,CAAC,GAAGD,GAAyB,GAAGE,CAAe"}

package/dist/canvas/SceneCanvas/scenePointQuery.js

@@ -0,0 +1,50 @@
+import { toPlane as e } from "../../core/viewport/parallax.js";
+import { findShapeInk as t, shapeCoversPoint as n } from "../NodeShape.js";
+import { poseContains as r, poseContainsRotated as i } from "./poseGeometry.js";
+import { applyToPoint as a, meanScale as o, pathContainsPoint as s } from "@weasel-js/geom";
+//#region src/canvas/SceneCanvas/scenePointQuery.ts
+function c(c, l, u) {
+	let d = (f, p, m) => {
+		let h = o(m), g = {
+			px: u,
+			scale: m
+		};
+		return {
+			hits: (e, a, o) => {
+				let s = l ? t(e, a, { scale: h }) : null, u = {
+					...g,
+					px: g.px + (s?.outsetPx ?? 0),
+					reach: s?.outset ?? 0
+				};
+				return (o ? r(o, f, p, u, c) : i(a, f, p, u, c)) ? !l || n(e, a, f, p, {
+					tolerance: g,
+					scale: h,
+					derivedPath: o
+				}) : !1;
+			},
+			clipAdmits: (e) => s(e, f, p),
+			inPlane: (t) => {
+				let n = e(t, {
+					x: f,
+					y: p
+				});
+				return d(n.x, n.y, {
+					x: m.x / t.scale.x,
+					y: m.y / t.scale.y
+				});
+			},
+			inCopy: (e) => {
+				let [t, n] = a(e, f, p), r = Math.sqrt(Math.abs(e[0] * e[3] - e[1] * e[2]));
+				return d(t, n, {
+					x: m.x / r,
+					y: m.y / r
+				});
+			}
+		};
+	};
+	return d;
+}
+//#endregion
+export { c as scenePointQuery };
+
+//# sourceMappingURL=scenePointQuery.js.map

package/dist/canvas/SceneCanvas/scenePointQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scenePointQuery.js","names":["scenePointQuery","pointQuery","scale","meanScale","s","tolerance","pickTolerancePx","ink","shapePicking","findShapeInk","n","pose","slop","derived","poseContains","px","py","d","poseContainsRotated","shapeCoversPoint","pathContainsPoint","clip","p","toPlane","m","x","y","applyToPoint","k"],"sources":["../../../src/canvas/SceneCanvas/scenePointQuery.ts"],"sourcesContent":["import { applyToPoint, meanScale, pathContainsPoint } from '@weasel-js/geom';\nimport type { PickQuery } from 'canvas/pickWalk';\nimport { findShapeInk, shapeCoversPoint } from 'canvas/NodeShape';\nimport { toPlane } from 'core/viewport/parallax';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { poseContains, poseContainsRotated } from './poseGeometry';\n\n/** The point query `<SceneCanvas>`'s default pick asks: a world point with\n *  `pickTolerancePx` of screen slop, refined to the painter's ink when\n *  `shapePicking` is on. */\nexport function scenePointQuery<TPose>(\n  d: PoseDescriptor<unknown>,\n  shapePicking: boolean,\n  pickTolerancePx: number,\n): (px: number, py: number, s: { x: number; y: number }) => PickQuery<TPose> {\n  // `s` makes the slop a screen distance, so the grab zone stays the same\n  // apparent thickness at any zoom and on every axis. A `{ px }` stroke's\n  // reach is on screen too, and joins the slop there.\n  const pointQuery = (px: number, py: number, s: { x: number; y: number }): PickQuery<TPose> => {\n    const scale = meanScale(s);\n    const tolerance = { px: pickTolerancePx, scale: s };\n    return {\n      hits: (n, pose, derived) => {\n        // The pre-filter has to be at least as generous as the refinement\n        // that follows it, or it rejects points the refinement would have\n        // claimed. A stroke reaches past the pose box by `outset` — a whole\n        // stroke width for an outer align — on top of the pointer slop.\n        const ink = shapePicking ? findShapeInk(n as never, pose, { scale }) : null;\n        // A derived node's pose is a placeholder — typically zero-sized at\n        // the origin — so its own box rejects every point the path covers.\n        // The path is the region to test instead, and `poseContains` already\n        // reads a path-like pose as one.\n        const slop = { ...tolerance, px: tolerance.px + (ink?.outsetPx ?? 0), reach: ink?.outset ?? 0 };\n        const admitted = derived\n          ? poseContains(derived as never, px, py, slop, d as PoseDescriptor<unknown>)\n          : poseContainsRotated(pose, px, py, slop, d as PoseDescriptor<unknown>);\n        if (!admitted) return false;\n        // `shapeCoversPoint` narrows the rect to the ink the painter actually\n        // lays down (and answers `true` for painters that have no silhouette,\n        // so nothing becomes unpickable).\n        return !shapePicking\n          || shapeCoversPoint(n as never, pose, px, py, {\n            tolerance, scale, derivedPath: derived,\n          });\n      },\n      clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n      inPlane: (m) => {\n        const p = toPlane(m, { x: px, y: py });\n        return pointQuery(p.x, p.y, { x: s.x / m.scale.x, y: s.y / m.scale.y });\n      },\n      inCopy: (m) => {\n        const [x, y] = applyToPoint(m, px, py);\n        const k = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));\n        return pointQuery(x, y, { x: s.x / k, y: s.y / k });\n      },\n    };\n  };\n  return pointQuery;\n}\n"],"mappings":";;;;;AAUA,SAAgBA,EACd,GACA,GACA,GAC2E;CAI3E,IAAMC,KAAc,GAAY,GAAY,MAAkD;EAC5F,IAAMC,IAAQC,EAAUC,CAAC,GACnBC,IAAY;GAAE,IAAIC;GAAiB,OAAOF;EAAE;EAClD,OAAO;GACL,OAAO,GAAG,GAAM,MAAY;IAK1B,IAAMG,IAAMC,IAAeC,EAAaC,GAAYC,GAAM,EAAE,SAAM,CAAC,IAAI,MAKjEC,IAAO;KAAE,GAAGP;KAAW,IAAIA,EAAU,MAAME,GAAK,YAAY;KAAI,OAAOA,GAAK,UAAU;IAAE;IAQ9F,QAPiBM,IACbC,EAAaD,GAAkBE,GAAIC,GAAIJ,GAAMK,CAA4B,IACzEC,EAAoBP,GAAMI,GAAIC,GAAIJ,GAAMK,CAA4B,KAKjE,CAACT,KACHW,EAAiBT,GAAYC,GAAMI,GAAIC,GAAI;KAC5C;KAAW;KAAO,aAAaH;IACjC,CAAC,IAPmB;GAQxB;GACA,aAAa,MAASO,EAAkBC,GAAMN,GAAIC,CAAE;GACpD,UAAU,MAAM;IACd,IAAMM,IAAIC,EAAQC,GAAG;KAAE,GAAGT;KAAI,GAAGC;IAAG,CAAC;IACrC,OAAOf,EAAWqB,EAAE,GAAGA,EAAE,GAAG;KAAE,GAAGlB,EAAE,IAAIoB,EAAE,MAAM;KAAG,GAAGpB,EAAE,IAAIoB,EAAE,MAAM;IAAE,CAAC;GACxE;GACA,SAAS,MAAM;IACb,IAAM,CAACC,GAAGC,KAAKC,EAAaH,GAAGT,GAAIC,CAAE,GAC/BY,IAAI,KAAK,KAAK,KAAK,IAAIJ,EAAE,KAAKA,EAAE,KAAKA,EAAE,KAAKA,EAAE,EAAE,CAAC;IACvD,OAAOvB,EAAWwB,GAAGC,GAAG;KAAE,GAAGtB,EAAE,IAAIwB;KAAG,GAAGxB,EAAE,IAAIwB;IAAE,CAAC;GACpD;EACF;CACF;CACA,OAAO3B;AACT"}

package/dist/canvas/SceneCanvas/shapeGeneratorProperties.js

@@ -0,0 +1,52 @@
+import { SHAPE_COUNT_RANGE as e, STAR_RATIO_RANGE as t } from "../../features/paths/shapeGenerator.js";
+import { decimal as n } from "@weasel-js/quantity";
+//#region src/canvas/SceneCanvas/shapeGeneratorProperties.ts
+var r = n({
+	maxPlaces: 2,
+	grouping: !1
+}), i = {
+	polygon: {
+		name: "Polygon",
+		showIf: { path: "data.generator.sides" },
+		members: { "data.generator.sides": {
+			kind: "number",
+			display: r,
+			name: "Sides",
+			description: "Number of sides.",
+			default: 6,
+			min: e.min,
+			max: e.max,
+			step: 1
+		} }
+	},
+	star: {
+		name: "Star",
+		showIf: { path: "data.generator.points" },
+		members: {
+			"data.generator.points": {
+				kind: "number",
+				display: r,
+				name: "Points",
+				description: "Number of points.",
+				default: 5,
+				min: e.min,
+				max: e.max,
+				step: 1
+			},
+			"data.generator.innerRadiusRatio": {
+				kind: "number",
+				name: "Inner",
+				description: "Inner radius as a fraction of the outer one.",
+				default: .5,
+				min: t.min,
+				max: t.max,
+				step: .01,
+				control: "slider"
+			}
+		}
+	}
+};
+//#endregion
+export { i as SHAPE_GENERATOR_SECTIONS };
+
+//# sourceMappingURL=shapeGeneratorProperties.js.map

package/dist/canvas/SceneCanvas/shapeGeneratorProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeGeneratorProperties.js","names":["WHOLE","decimal","SHAPE_GENERATOR_SECTIONS","SHAPE_COUNT_RANGE","STAR_RATIO_RANGE"],"sources":["../../../src/canvas/SceneCanvas/shapeGeneratorProperties.ts"],"sourcesContent":["import type { PrefSection } from '@weasel-js/prefs';\nimport { decimal } from '@weasel-js/quantity';\nimport { SHAPE_COUNT_RANGE, STAR_RATIO_RANGE } from 'features/paths/shapeGenerator';\n\nconst WHOLE = decimal({ maxPlaces: 2, grouping: false });\n\n/**\n * The rows that edit a polygon's or a star's `data.generator`, each shown only\n * on a node holding that kind's generator. A write to one regenerates the\n * shape through the entry's `settle` (`settleShapeGenerator`).\n */\nexport const SHAPE_GENERATOR_SECTIONS: Record<string, PrefSection> = {\n  polygon: {\n    name: 'Polygon',\n    showIf: { path: 'data.generator.sides' },\n    members: {\n      'data.generator.sides': {\n        kind: 'number', display: WHOLE, name: 'Sides', description: 'Number of sides.',\n        default: 6, min: SHAPE_COUNT_RANGE.min, max: SHAPE_COUNT_RANGE.max, step: 1,\n      },\n    },\n  },\n  star: {\n    name: 'Star',\n    showIf: { path: 'data.generator.points' },\n    members: {\n      'data.generator.points': {\n        kind: 'number', display: WHOLE, name: 'Points', description: 'Number of points.',\n        default: 5, min: SHAPE_COUNT_RANGE.min, max: SHAPE_COUNT_RANGE.max, step: 1,\n      },\n      'data.generator.innerRadiusRatio': {\n        kind: 'number', name: 'Inner', description: 'Inner radius as a fraction of the outer one.',\n        default: 0.5, min: STAR_RATIO_RANGE.min, max: STAR_RATIO_RANGE.max, step: 0.01, control: 'slider',\n      },\n    },\n  },\n};\n"],"mappings":";;;AAIA,IAAMA,IAAQC,EAAQ;CAAE,WAAW;CAAG,UAAU;AAAM,CAAC,GAO1CC,IAAwD;CACnE,SAAS;EACP,MAAM;EACN,QAAQ,EAAE,MAAM,uBAAuB;EACvC,SAAS,EACP,wBAAwB;GACtB,MAAM;GAAU,SAASF;GAAO,MAAM;GAAS,aAAa;GAC5D,SAAS;GAAG,KAAKG,EAAkB;GAAK,KAAKA,EAAkB;GAAK,MAAM;EAC5E,EACF;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ,EAAE,MAAM,wBAAwB;EACxC,SAAS;GACP,yBAAyB;IACvB,MAAM;IAAU,SAASH;IAAO,MAAM;IAAU,aAAa;IAC7D,SAAS;IAAG,KAAKG,EAAkB;IAAK,KAAKA,EAAkB;IAAK,MAAM;GAC5E;GACA,mCAAmC;IACjC,MAAM;IAAU,MAAM;IAAS,aAAa;IAC5C,SAAS;IAAK,KAAKC,EAAiB;IAAK,KAAKA,EAAiB;IAAK,MAAM;IAAM,SAAS;GAC3F;EACF;CACF;AACF"}

package/dist/canvas/SceneCanvas/toolRegistry.js

@@ -0,0 +1,23 @@
+import { IS_DEV as e } from "./isDev.js";
+import { featureToolIds as t } from "./features.js";
+import { BUILTIN_TOOL_IDS as n } from "./props.js";
+//#region src/canvas/SceneCanvas/toolRegistry.ts
+function r(r) {
+	let { builtins: i, defaultTools: a = [], enabled: o, patch: s, dev: c = e } = r, l = {}, u = t(o);
+	for (let e of n) {
+		let t = s?.[e];
+		t !== !1 && (t === !0 || a.includes(e) || u.has(e)) && (l[e] = i[e]);
+	}
+	for (let [e, t] of Object.entries(s ?? {})) if (t !== !1) {
+		if (t === !0) {
+			c && !n.includes(e) && console.warn(`[SceneCanvas] tools.${e}=true is not a known built-in id; ignoring`);
+			continue;
+		}
+		c && e in l && console.warn(`[SceneCanvas] tools prop overrides bundled "${e}" tool`), l[e] = t;
+	}
+	return l;
+}
+//#endregion
+export { r as resolveToolRegistry };
+
+//# sourceMappingURL=toolRegistry.js.map

package/dist/canvas/SceneCanvas/toolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolRegistry.js","names":["resolveToolRegistry","IS_DEV","args","registry","preset","featureToolIds","enabled","id","BUILTIN_TOOL_IDS","patched","patch","defaultTools","builtins","value","dev"],"sources":["../../../src/canvas/SceneCanvas/toolRegistry.ts"],"sourcesContent":["import type { Tool } from 'tools/overlayBinding';\nimport { featureToolIds, type BaseFeature } from './features';\nimport { IS_DEV } from './isDev';\nimport { BUILTIN_TOOL_IDS, type BuiltinToolId } from './props';\n\n/** The patch form of `<SceneCanvas tools>`: per id, `true` mounts that\n *  built-in, `false` leaves it out, and a tool adds or replaces one. */\nexport type ToolsPatch = Record<string, Tool | true | false>;\n\n/** One tool per built-in id, mounted or not. */\nexport type BuiltinTools = Record<BuiltinToolId, Tool>;\n\nexport interface ResolveToolRegistryArgs {\n  builtins: BuiltinTools;\n  /** Built-ins asked for by id. */\n  defaultTools?: readonly BuiltinToolId[];\n  /** The presets the canvas runs with, each bringing the tools its\n   *  `FEATURE_PRESETS` row names. */\n  enabled: ReadonlySet<BaseFeature>;\n  patch: ToolsPatch | null;\n  /** Whether to warn about a patch entry that is probably a mistake. */\n  dev?: boolean;\n}\n\n/**\n * The tool registry a canvas mounts when it is not handed a whole `ToolsApi`.\n *\n * Built-ins come first, in `BUILTIN_TOOL_IDS` order whatever order they were\n * asked for in; a patch tool replaces a mounted one where it stands, and any\n * other is appended in patch order. That order is the palette's.\n */\nexport function resolveToolRegistry(args: ResolveToolRegistryArgs): Record<string, Tool> {\n  const { builtins, defaultTools = [], enabled, patch, dev = IS_DEV } = args;\n  const registry: Record<string, Tool> = {};\n  const preset = featureToolIds(enabled);\n  for (const id of BUILTIN_TOOL_IDS) {\n    const patched = patch?.[id];\n    if (patched === false) continue;\n    const asked = patched === true || defaultTools.includes(id) || preset.has(id);\n    if (asked) registry[id] = builtins[id];\n  }\n  for (const [id, value] of Object.entries(patch ?? {})) {\n    if (value === false) continue;\n    if (value === true) {\n      if (dev && !(BUILTIN_TOOL_IDS as readonly string[]).includes(id)) {\n        console.warn(`[SceneCanvas] tools.${id}=true is not a known built-in id; ignoring`);\n      }\n      continue;\n    }\n    if (dev && id in registry) {\n      console.warn(`[SceneCanvas] tools prop overrides bundled \"${id}\" tool`);\n    }\n    registry[id] = value;\n  }\n  return registry;\n}\n"],"mappings":";;;;AA+BA,SAAgBA,EAAoB,GAAqD;CACvF,IAAM,EAAE,aAAU,kBAAe,CAAC,GAAG,YAAS,UAAO,SAAMC,MAAWC,GAChEC,IAAiC,CAAC,GAClCC,IAASC,EAAeC,CAAO;CACrC,KAAK,IAAMC,KAAMC,GAAkB;EACjC,IAAMC,IAAUC,IAAQH;EACxB,AAAIE,MAAY,OACFA,MAAY,MAAQE,EAAa,SAASJ,CAAE,KAAKH,EAAO,IAAIG,CAAE,OACjE,EAASA,KAAMK,EAASL;CACrC;CACA,KAAK,IAAM,CAACA,GAAIM,MAAU,OAAO,QAAQH,KAAS,CAAC,CAAC,GAClD,IAAIG,MAAU,IACd;MAAIA,MAAU,IAAM;GAClB,AAAIC,KAAO,CAAEN,EAAuC,SAASD,CAAE,KAC7D,QAAQ,KAAK,uBAAuBA,EAAG,2CAA2C;GAEpF;EACF;EAIA,AAHIO,KAAOP,KAAMJ,KACf,QAAQ,KAAK,+CAA+CI,EAAG,OAAO,GAExE,EAASA,KAAMM;CAJf;CAMF,OAAOV;AACT"}

package/dist/canvas/SceneCanvas/useActionTunings.js

@@ -0,0 +1,17 @@
+import { useEffect as e } from "react";
+import { useActionsRegistry as t } from "@weasel-js/routing/react";
+//#region src/canvas/SceneCanvas/useActionTunings.ts
+function n(n) {
+	let r = t();
+	e(() => {
+		if (!r || !n) return;
+		let e = Object.entries(n).flatMap(([e, t]) => t ? [r.tune(e, t)] : []);
+		return () => {
+			for (let t of e) t();
+		};
+	}, [r, n]);
+}
+//#endregion
+export { n as useActionTunings };
+
+//# sourceMappingURL=useActionTunings.js.map

package/dist/canvas/SceneCanvas/useActionTunings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionTunings.js","names":["useActionTunings","reg","useActionsRegistry","tune","releases","id","release"],"sources":["../../../src/canvas/SceneCanvas/useActionTunings.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport type { ActionTuning, ActionTunings } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\n\n/** Hold `tune`'s tunings on the registry in scope for as long as the object\n *  is the same one. */\nexport function useActionTunings(tune: ActionTunings | undefined): void {\n  const reg = useActionsRegistry();\n  useEffect(() => {\n    if (!reg || !tune) return;\n    const releases = Object.entries(tune).flatMap(([id, t]) => (t ? [reg.tune(id, t as ActionTuning)] : []));\n    return () => { for (const release of releases) release(); };\n  }, [reg, tune]);\n}\n"],"mappings":";;;AAMA,SAAgBA,EAAiB,GAAuC;CACtE,IAAMC,IAAMC,EAAmB;CAC/B,QAAgB;EACd,IAAI,CAACD,KAAO,CAACE,GAAM;EACnB,IAAMC,IAAW,OAAO,QAAQD,CAAI,CAAC,CAAC,SAAS,CAACE,GAAI,OAAQ,IAAI,CAACJ,EAAI,KAAKI,GAAI,CAAiB,CAAC,IAAI,CAAC,CAAE;EACvG,aAAa;GAAE,KAAK,IAAMC,KAAWF,GAAU,EAAQ;EAAG;CAC5D,GAAG,CAACH,GAAKE,CAAI,CAAC;AAChB"}

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -42,7 +42,12 @@ function r(r, i) {
 		i
 	]);
 }
+function i(e, t) {
+	if (e === null) return null;
+	let n = { ...e ?? {} };
+	return t in n || (n[t] = null), n;
+}
 //#endregion
-export { r as useActionsPropResolver };
+export { i as actionsMuting, r as useActionsPropResolver };
 
 //# sourceMappingURL=useActionsPropResolver.js.map

package/dist/canvas/SceneCanvas/useActionsPropResolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * `useActionsPropResolver` — applies the `actions` prop overrides on top of\n * whatever `useStandardActions` registered. Runs after it (caller mounts this\n * hook last). Resolution rules:\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n"],"mappings":";;;;AAuBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC"}
+{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev","actionsMuting"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * Applies the `actions` prop overrides on top of whatever is already\n * registered, so the caller mounts this hook last.\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n\n/**\n * `actions` with `id` muted. A caller's own entry for `id` still wins, and\n * `null` (every default muted) is left as it is.\n */\nexport function actionsMuting(actions: ActionsProp | undefined, id: string): ActionsProp {\n  if (actions === null) return null;\n  const merged = { ...(actions ?? {}) } as Record<string, unknown>;\n  if (!(id in merged)) merged[id] = null;\n  return merged as ActionsProp;\n}\n"],"mappings":";;;;AAsBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC;AAMA,SAAgBC,EAAc,GAAkC,GAAyB;CACvF,IAAIf,MAAY,MAAM,OAAO;CAC7B,IAAMa,IAAS,EAAE,GAAIb,KAAW,CAAC,EAAG;CAEpC,OADMG,KAAMU,MAAS,EAAOV,KAAM,OAC3BU;AACT"}