@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/deps/layout.js

@@ -1,28 +1,40 @@
-import { asNodeId as e } from "../../core/scene/types.js";
-import { useEffect as t } from "react";
-import { useLatest as n } from "@weasel-js/react";
-import { useDepSource as r } from "@weasel-js/routing/react";
+import { asNodeId } from "../../core/scene/types.js";
+import { useEffect } from "react";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/layout.ts
-function i(i, a, o) {
-	let s = n({
-		dropTarget: a,
-		reflow: o
+/**
+* `useLayoutDepSource` — wires the `layout` dep consumed by `moveAction`'s
+* drag-time reflow pass. A container's layout is the one its scene node
+* declares (`scene.layoutOf`). Carries the `layoutDropTarget` mode, and hands
+* every reflow the scene records to the reflow transition so it glides as a
+* drag's does. Always registers; returns null for a container that declares
+* no layout, so the reflow pass is a no-op without churning dep registration
+* on prop changes.
+*/
+function useLayoutDepSource(scene, dropTarget, reflow) {
+	const ref = useLatest({
+		dropTarget,
+		reflow
 	});
-	r("layout", () => ({
-		getLayout: (t) => i.layoutOf(e(t)),
-		dropTarget: s.current.dropTarget,
+	useDepSource("layout", () => ({
+		getLayout: (containerId) => scene.layoutOf(asNodeId(containerId)),
+		dropTarget: ref.current.dropTarget,
 		get reflow() {
-			return s.current.reflow ?? null;
+			return ref.current.reflow ?? null;
 		}
-	})), t(() => i.onReflow((e) => {
-		let t = s.current.reflow;
-		if (t) for (let n of e) {
-			let e = n.id;
-			t.settle(e, t.poseOf(e) === void 0 ? { from: n.from } : void 0);
+	}));
+	useEffect(() => scene.onReflow((moves) => {
+		const glide = ref.current.reflow;
+		if (!glide) return;
+		for (const m of moves) {
+			const id = m.id;
+			glide.settle(id, glide.poseOf(id) === void 0 ? { from: m.from } : void 0);
 		}
-	}), [i, s]);
+	}), [scene, ref]);
 }
-//#endregion
-export { i as useLayoutDepSource };
 
+//#endregion
+export { useLayoutDepSource };
 //# sourceMappingURL=layout.js.map

package/dist/canvas/deps/layout.js.map

@@ -1 +1 @@
-{"version":3,"file":"layout.js","names":["useLayoutDepSource","ref","useLatest","useDepSource","scene","asNodeId","containerId","useEffect","glide","m","moves","id"],"sources":["../../../src/canvas/deps/layout.ts"],"sourcesContent":["/**\n * `useLayoutDepSource` — wires the `layout` dep consumed by `moveAction`'s\n * drag-time reflow pass. A container's layout is the one its scene node\n * declares (`scene.layoutOf`). Carries the `layoutDropTarget` mode, and hands\n * every reflow the scene records to the reflow transition so it glides as a\n * drag's does. Always registers; returns null for a container that declares\n * no layout, so the reflow pass is a no-op without churning dep registration\n * on prop changes.\n */\nimport { useEffect } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LayoutDep } from 'interactions/actions/depSchema';\nimport type { Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\n\nexport function useLayoutDepSource(\n  scene: Scene<unknown, string, unknown>,\n  dropTarget?: LayoutDropTargetMode,\n  reflow?: ReflowTransition<unknown> | null,\n): void {\n  const ref = useLatest({ dropTarget, reflow });\n\n  useDepSource('layout', (): LayoutDep => ({\n    getLayout: (containerId) => scene.layoutOf(asNodeId(containerId)),\n    dropTarget: ref.current.dropTarget,\n    get reflow() { return ref.current.reflow ?? null; },\n  }));\n\n  useEffect(() => scene.onReflow((moves) => {\n    const glide = ref.current.reflow;\n    if (!glide) return;\n    for (const m of moves) {\n      // One already gliding carries on from where it is shown.\n      const id = m.id as string;\n      glide.settle(id, glide.poseOf(id) === undefined ? { from: m.from } : undefined);\n    }\n  }), [scene, ref]);\n}\n"],"mappings":";;;;;AAiBA,SAAgBA,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAU;EAAE;EAAY;CAAO,CAAC;CAQ5C,AANAC,EAAa,iBAA4B;EACvC,YAAY,MAAgBC,EAAM,SAASC,EAASC,CAAW,CAAC;EAChE,YAAYL,EAAI,QAAQ;EACxB,IAAI,SAAS;GAAE,OAAOA,EAAI,QAAQ,UAAU;EAAM;CACpD,EAAE,GAEFM,QAAgBH,EAAM,UAAU,MAAU;EACxC,IAAMI,IAAQP,EAAI,QAAQ;EAC1B,IAAKO,GACL,KAAK,IAAMC,KAAKC,GAAO;GAErB,IAAMC,IAAKF,EAAE;GACb,EAAM,OAAOE,GAAIH,EAAM,OAAOG,CAAE,MAAM,KAAA,IAAY,EAAE,MAAMF,EAAE,KAAK,IAAI,KAAA,CAAS;EAChF;CACF,CAAC,GAAG,CAACL,GAAOH,CAAG,CAAC;AAClB"}
+{"version":3,"file":"layout.js","names":[],"sources":["../../../src/canvas/deps/layout.ts"],"sourcesContent":["/**\n * `useLayoutDepSource` — wires the `layout` dep consumed by `moveAction`'s\n * drag-time reflow pass. A container's layout is the one its scene node\n * declares (`scene.layoutOf`). Carries the `layoutDropTarget` mode, and hands\n * every reflow the scene records to the reflow transition so it glides as a\n * drag's does. Always registers; returns null for a container that declares\n * no layout, so the reflow pass is a no-op without churning dep registration\n * on prop changes.\n */\nimport { useEffect } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { LayoutDep } from 'interactions/actions/depSchema';\nimport type { Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\n\nexport function useLayoutDepSource(\n  scene: Scene<unknown, string, unknown>,\n  dropTarget?: LayoutDropTargetMode,\n  reflow?: ReflowTransition<unknown> | null,\n): void {\n  const ref = useLatest({ dropTarget, reflow });\n\n  useDepSource('layout', (): LayoutDep => ({\n    getLayout: (containerId) => scene.layoutOf(asNodeId(containerId)),\n    dropTarget: ref.current.dropTarget,\n    get reflow() { return ref.current.reflow ?? null; },\n  }));\n\n  useEffect(() => scene.onReflow((moves) => {\n    const glide = ref.current.reflow;\n    if (!glide) return;\n    for (const m of moves) {\n      // One already gliding carries on from where it is shown.\n      const id = m.id as string;\n      glide.settle(id, glide.poseOf(id) === undefined ? { from: m.from } : undefined);\n    }\n  }), [scene, ref]);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,SAAgB,mBACd,OACA,YACA,QACM;CACN,MAAM,MAAM,UAAU;EAAE;EAAY;CAAO,CAAC;CAE5C,aAAa,iBAA4B;EACvC,YAAY,gBAAgB,MAAM,SAAS,SAAS,WAAW,CAAC;EAChE,YAAY,IAAI,QAAQ;EACxB,IAAI,SAAS;GAAE,OAAO,IAAI,QAAQ,UAAU;EAAM;CACpD,EAAE;CAEF,gBAAgB,MAAM,UAAU,UAAU;EACxC,MAAM,QAAQ,IAAI,QAAQ;EAC1B,IAAI,CAAC,OAAO;EACZ,KAAK,MAAM,KAAK,OAAO;GAErB,MAAM,KAAK,EAAE;GACb,MAAM,OAAO,IAAI,MAAM,OAAO,EAAE,MAAM,SAAY,EAAE,MAAM,EAAE,KAAK,IAAI,MAAS;EAChF;CACF,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC;AAClB"}

package/dist/canvas/deps/nodeAtPoint.js

@@ -1,19 +1,33 @@
-import { asNodeId as e } from "../../core/scene/types.js";
-import { useLatest as t } from "@weasel-js/react";
-import { useDepSource as n } from "@weasel-js/routing/react";
+import { asNodeId } from "../../core/scene/types.js";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/nodeAtPoint.ts
-function r(r) {
-	let i = t(r);
-	n("nodeAtPoint", () => (t, n) => {
-		let r = i.current(t.x, t.y);
-		if (r.length === 0) return null;
-		if (!n) return e(r[r.length - 1]);
-		let a = n instanceof Set ? n : new Set(n);
-		for (let t = r.length - 1; t >= 0; t--) if (!a.has(e(r[t]))) return e(r[t]);
-		return null;
+/**
+* `useNodeAtPointDepSource` — wires the `nodeAtPoint` dep consumed by
+* `moveAction` (reparent-on-drop) and any other action needing a
+* single-best pick. Delegates to `<SceneCanvas>`'s `pickEvery` (the
+* back-to-front pose-walking picker) so consumer-supplied geometry
+* overrides are honored automatically.
+*
+* The exclude set is consulted front-to-back: the dep returns the
+* topmost id that isn't in `exclude`, which lets callers ignore the
+* node(s) they're currently manipulating without separate plumbing.
+*/
+function useNodeAtPointDepSource(pickEvery) {
+	const pickRef = useLatest(pickEvery);
+	useDepSource("nodeAtPoint", () => {
+		return (point, exclude) => {
+			const ids = pickRef.current(point.x, point.y);
+			if (ids.length === 0) return null;
+			if (!exclude) return asNodeId(ids[ids.length - 1]);
+			const ex = exclude instanceof Set ? exclude : new Set(exclude);
+			for (let i = ids.length - 1; i >= 0; i--) if (!ex.has(asNodeId(ids[i]))) return asNodeId(ids[i]);
+			return null;
+		};
 	});
 }
-//#endregion
-export { r as useNodeAtPointDepSource };
 
+//#endregion
+export { useNodeAtPointDepSource };
 //# sourceMappingURL=nodeAtPoint.js.map

package/dist/canvas/deps/nodeAtPoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodeAtPoint.js","names":["useNodeAtPointDepSource","pickRef","useLatest","pickEvery","ids","point","exclude","asNodeId","ex","i"],"sources":["../../../src/canvas/deps/nodeAtPoint.ts"],"sourcesContent":["/**\n * `useNodeAtPointDepSource` — wires the `nodeAtPoint` dep consumed by\n * `moveAction` (reparent-on-drop) and any other action needing a\n * single-best pick. Delegates to `<SceneCanvas>`'s `pickEvery` (the\n * back-to-front pose-walking picker) so consumer-supplied geometry\n * overrides are honored automatically.\n *\n * The exclude set is consulted front-to-back: the dep returns the\n * topmost id that isn't in `exclude`, which lets callers ignore the\n * node(s) they're currently manipulating without separate plumbing.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeAtPointDep } from 'interactions/actions/depSchema';\nimport { asNodeId } from 'core/scene/types';\n\nexport function useNodeAtPointDepSource(\n  pickEvery: (worldX: number, worldY: number) => string[],\n): void {\n  const pickRef = useLatest(pickEvery);\n\n  useDepSource('nodeAtPoint', (): NodeAtPointDep => {\n    return (point, exclude) => {\n      const ids = pickRef.current(point.x, point.y);\n      if (ids.length === 0) return null;\n      if (!exclude) {\n        // `pickEvery` returns back-to-front; topmost is the last entry.\n        return asNodeId(ids[ids.length - 1]);\n      }\n      const ex = exclude instanceof Set ? exclude : new Set(exclude);\n      for (let i = ids.length - 1; i >= 0; i--) {\n        if (!ex.has(asNodeId(ids[i]))) return asNodeId(ids[i]);\n      }\n      return null;\n    };\n  });\n}\n"],"mappings":";;;;AAgBA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAS;CAEnC,EAAa,sBACH,GAAO,MAAY;EACzB,IAAMC,IAAMH,EAAQ,QAAQI,EAAM,GAAGA,EAAM,CAAC;EAC5C,IAAID,EAAI,WAAW,GAAG,OAAO;EAC7B,IAAI,CAACE,GAEH,OAAOC,EAASH,EAAIA,EAAI,SAAS,EAAE;EAErC,IAAMI,IAAKF,aAAmB,MAAMA,IAAU,IAAI,IAAIA,CAAO;EAC7D,KAAK,IAAIG,IAAIL,EAAI,SAAS,GAAGK,KAAK,GAAG,KACnC,IAAI,CAACD,EAAG,IAAID,EAASH,EAAIK,EAAE,CAAC,GAAG,OAAOF,EAASH,EAAIK,EAAE;EAEvD,OAAO;CACT,CACD;AACH"}
+{"version":3,"file":"nodeAtPoint.js","names":[],"sources":["../../../src/canvas/deps/nodeAtPoint.ts"],"sourcesContent":["/**\n * `useNodeAtPointDepSource` — wires the `nodeAtPoint` dep consumed by\n * `moveAction` (reparent-on-drop) and any other action needing a\n * single-best pick. Delegates to `<SceneCanvas>`'s `pickEvery` (the\n * back-to-front pose-walking picker) so consumer-supplied geometry\n * overrides are honored automatically.\n *\n * The exclude set is consulted front-to-back: the dep returns the\n * topmost id that isn't in `exclude`, which lets callers ignore the\n * node(s) they're currently manipulating without separate plumbing.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeAtPointDep } from 'interactions/actions/depSchema';\nimport { asNodeId } from 'core/scene/types';\n\nexport function useNodeAtPointDepSource(\n  pickEvery: (worldX: number, worldY: number) => string[],\n): void {\n  const pickRef = useLatest(pickEvery);\n\n  useDepSource('nodeAtPoint', (): NodeAtPointDep => {\n    return (point, exclude) => {\n      const ids = pickRef.current(point.x, point.y);\n      if (ids.length === 0) return null;\n      if (!exclude) {\n        // `pickEvery` returns back-to-front; topmost is the last entry.\n        return asNodeId(ids[ids.length - 1]);\n      }\n      const ex = exclude instanceof Set ? exclude : new Set(exclude);\n      for (let i = ids.length - 1; i >= 0; i--) {\n        if (!ex.has(asNodeId(ids[i]))) return asNodeId(ids[i]);\n      }\n      return null;\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,wBACd,WACM;CACN,MAAM,UAAU,UAAU,SAAS;CAEnC,aAAa,qBAAqC;EAChD,QAAQ,OAAO,YAAY;GACzB,MAAM,MAAM,QAAQ,QAAQ,MAAM,GAAG,MAAM,CAAC;GAC5C,IAAI,IAAI,WAAW,GAAG,OAAO;GAC7B,IAAI,CAAC,SAEH,OAAO,SAAS,IAAI,IAAI,SAAS,EAAE;GAErC,MAAM,KAAK,mBAAmB,MAAM,UAAU,IAAI,IAAI,OAAO;GAC7D,KAAK,IAAI,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KACnC,IAAI,CAAC,GAAG,IAAI,SAAS,IAAI,EAAE,CAAC,GAAG,OAAO,SAAS,IAAI,EAAE;GAEvD,OAAO;EACT;CACF,CAAC;AACH"}

package/dist/canvas/deps/pathLeaf.js

@@ -0,0 +1,66 @@
+import { poseLinearOf, worldEditToStorage } from "@weasel-js/geom";
+
+//#region src/canvas/deps/pathLeaf.ts
+/** How `g` draws a leaf at `world`, or null for a pose it reads no finite box from. */
+function drawnPose(g, world) {
+	const b = g.getBounds(world);
+	if (!b || ![
+		b.x,
+		b.y,
+		b.width,
+		b.height
+	].every(Number.isFinite)) return null;
+	const rotation = g.getRotation?.(world) ?? 0;
+	const transform = poseLinearOf(world) ?? void 0;
+	return {
+		world,
+		g,
+		box: {
+			x: b.x,
+			y: b.y,
+			width: b.width,
+			height: b.height,
+			rotation,
+			transform
+		}
+	};
+}
+/** A world-space piece as a world pose of the source's kind plus the path it draws. */
+function storePiece({ world, g, box }, piece) {
+	const keepsRotation = !!g.withRotation && g.supportsRotation?.(world) !== false;
+	const rotation = box.rotation ?? 0;
+	if (rotation !== 0 && !keepsRotation) {
+		const baked = worldEditToStorage({
+			...box,
+			rotation: 0
+		}, piece);
+		return {
+			pose: g.fromBounds(baked.pose, world),
+			path: baked.path
+		};
+	}
+	const { pose: b, path } = worldEditToStorage(box, piece);
+	const dst = {
+		x: b.x,
+		y: b.y,
+		width: b.width,
+		height: b.height
+	};
+	const pose = g.remapBounds(world, g.getBounds(world), dst);
+	return {
+		pose: rotation !== 0 ? g.withRotation(pose, rotation) : pose,
+		path
+	};
+}
+/** The path a leaf stores, or null for one that is not a free path leaf: a
+*  group, a locked leaf, one whose geometry derives from other nodes. */
+function leafPath(scene, node) {
+	if (node.kind !== "leaf" || node.derivePath || node.derivePose) return null;
+	if (scene.isLocked(node.id)) return null;
+	const path = node.data?.path;
+	return path && (path.kind === "rect" || path.kind === "polygon") ? path : null;
+}
+
+//#endregion
+export { drawnPose, leafPath, storePiece };
+//# sourceMappingURL=pathLeaf.js.map

package/dist/canvas/deps/pathLeaf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathLeaf.js","names":[],"sources":["../../../src/canvas/deps/pathLeaf.ts"],"sourcesContent":["/**\n * Path leaves as the kit's own path deps read and write them: geometry in\n * `data.path`, drawn through the box its pose describes.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { poseLinearOf, worldEditToStorage, type PathInWorldPose } from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Node, Scene } from 'core/scene/types';\n\n/** A path leaf's world pose, and the box, rotation, and transform its path is drawn through. */\nexport interface DrawnPose {\n  world: unknown;\n  g: PoseDescriptor<unknown>;\n  box: PathInWorldPose;\n}\n\n/** How `g` draws a leaf at `world`, or null for a pose it reads no finite box from. */\nexport function drawnPose(g: PoseDescriptor<unknown>, world: unknown): DrawnPose | null {\n  const b = g.getBounds(world);\n  if (!b || ![b.x, b.y, b.width, b.height].every(Number.isFinite)) return null;\n  const rotation = g.getRotation?.(world) ?? 0;\n  const transform = poseLinearOf(world) ?? undefined;\n  return { world, g, box: { x: b.x, y: b.y, width: b.width, height: b.height, rotation, transform } };\n}\n\n/** A world-space piece as a world pose of the source's kind plus the path it draws. */\nexport function storePiece({ world, g, box }: DrawnPose, piece: Path): { pose: unknown; path: Path } {\n  const keepsRotation = !!g.withRotation && g.supportsRotation?.(world) !== false;\n  const rotation = box.rotation ?? 0;\n  if (rotation !== 0 && !keepsRotation) {\n    const baked = worldEditToStorage({ ...box, rotation: 0 }, piece);\n    return { pose: g.fromBounds(baked.pose, world), path: baked.path };\n  }\n  const { pose: b, path } = worldEditToStorage(box, piece);\n  const dst = { x: b.x, y: b.y, width: b.width, height: b.height };\n  const pose = g.remapBounds(world, g.getBounds(world), dst);\n  return { pose: rotation !== 0 ? g.withRotation!(pose, rotation) : pose, path };\n}\n\n/** The path a leaf stores, or null for one that is not a free path leaf: a\n *  group, a locked leaf, one whose geometry derives from other nodes. */\nexport function leafPath(scene: Scene<unknown, string, unknown>, node: Node<unknown, string, unknown>): Path | null {\n  if (node.kind !== 'leaf' || node.derivePath || node.derivePose) return null;\n  if (scene.isLocked(node.id)) return null;\n  const path = (node.data as { path?: unknown } | null)?.path as Path | undefined;\n  return path && (path.kind === 'rect' || path.kind === 'polygon') ? path : null;\n}\n"],"mappings":";;;;AAiBA,SAAgB,UAAU,GAA4B,OAAkC;CACtF,MAAM,IAAI,EAAE,UAAU,KAAK;CAC3B,IAAI,CAAC,KAAK,CAAC;EAAC,EAAE;EAAG,EAAE;EAAG,EAAE;EAAO,EAAE;CAAM,CAAC,CAAC,MAAM,OAAO,QAAQ,GAAG,OAAO;CACxE,MAAM,WAAW,EAAE,cAAc,KAAK,KAAK;CAC3C,MAAM,YAAY,aAAa,KAAK,KAAK;CACzC,OAAO;EAAE;EAAO;EAAG,KAAK;GAAE,GAAG,EAAE;GAAG,GAAG,EAAE;GAAG,OAAO,EAAE;GAAO,QAAQ,EAAE;GAAQ;GAAU;EAAU;CAAE;AACpG;;AAGA,SAAgB,WAAW,EAAE,OAAO,GAAG,OAAkB,OAA4C;CACnG,MAAM,gBAAgB,CAAC,CAAC,EAAE,gBAAgB,EAAE,mBAAmB,KAAK,MAAM;CAC1E,MAAM,WAAW,IAAI,YAAY;CACjC,IAAI,aAAa,KAAK,CAAC,eAAe;EACpC,MAAM,QAAQ,mBAAmB;GAAE,GAAG;GAAK,UAAU;EAAE,GAAG,KAAK;EAC/D,OAAO;GAAE,MAAM,EAAE,WAAW,MAAM,MAAM,KAAK;GAAG,MAAM,MAAM;EAAK;CACnE;CACA,MAAM,EAAE,MAAM,GAAG,SAAS,mBAAmB,KAAK,KAAK;CACvD,MAAM,MAAM;EAAE,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG,OAAO,EAAE;EAAO,QAAQ,EAAE;CAAO;CAC/D,MAAM,OAAO,EAAE,YAAY,OAAO,EAAE,UAAU,KAAK,GAAG,GAAG;CACzD,OAAO;EAAE,MAAM,aAAa,IAAI,EAAE,aAAc,MAAM,QAAQ,IAAI;EAAM;CAAK;AAC/E;;;AAIA,SAAgB,SAAS,OAAwC,MAAmD;CAClH,IAAI,KAAK,SAAS,UAAU,KAAK,cAAc,KAAK,YAAY,OAAO;CACvE,IAAI,MAAM,SAAS,KAAK,EAAE,GAAG,OAAO;CACpC,MAAM,OAAQ,KAAK,MAAoC;CACvD,OAAO,SAAS,KAAK,SAAS,UAAU,KAAK,SAAS,aAAa,OAAO;AAC5E"}

package/dist/canvas/deps/pathLeafDeps.js

@@ -0,0 +1,13 @@
+import { useSliceDepSource } from "./slice.js";
+import { useBooleansAdapterSource } from "./booleans.js";
+
+//#region src/canvas/deps/pathLeafDeps.ts
+/** The kit deps that rewrite a scene's path leaves: `slice` and `booleansAdapter`. */
+function usePathLeafDepSources(scene, selection, adapter, poseDescriptor) {
+	useSliceDepSource(scene, selection, adapter, poseDescriptor);
+	useBooleansAdapterSource(scene, selection, adapter, poseDescriptor);
+}
+
+//#endregion
+export { usePathLeafDepSources };
+//# sourceMappingURL=pathLeafDeps.js.map

package/dist/canvas/deps/pathLeafDeps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathLeafDeps.js","names":[],"sources":["../../../src/canvas/deps/pathLeafDeps.ts"],"sourcesContent":["import type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { useBooleansAdapterSource } from './booleans';\nimport { useSliceDepSource, type OpsApplier } from './slice';\n\n/** The kit deps that rewrite a scene's path leaves: `slice` and `booleansAdapter`. */\nexport function usePathLeafDepSources(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  poseDescriptor?: PoseDescriptor<unknown>,\n): void {\n  useSliceDepSource(scene, selection, adapter, poseDescriptor);\n  useBooleansAdapterSource(scene, selection, adapter, poseDescriptor);\n}\n"],"mappings":";;;;;AAOA,SAAgB,sBACd,OACA,WACA,SACA,gBACM;CACN,kBAAkB,OAAO,WAAW,SAAS,cAAc;CAC3D,yBAAyB,OAAO,WAAW,SAAS,cAAc;AACpE"}

package/dist/canvas/deps/poseDescriptor.js

@@ -1,12 +1,14 @@
-import { AUTO_POSE_DESCRIPTOR as e } from "../../core/geometry/autoPoseDescriptor.js";
-import { useLatest as t } from "@weasel-js/react";
-import { useDepSource as n } from "@weasel-js/routing/react";
+import { AUTO_POSE_DESCRIPTOR } from "../../core/geometry/autoPoseDescriptor.js";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/poseDescriptor.ts
-function r(r) {
-	let i = t(r);
-	n("poseDescriptor", () => i.current ?? e);
+/** Publish the pose descriptor every built-in action reads. */
+function usePoseDescriptorDepSource(descriptor) {
+	const ref = useLatest(descriptor);
+	useDepSource("poseDescriptor", () => ref.current ?? AUTO_POSE_DESCRIPTOR);
 }
-//#endregion
-export { r as usePoseDescriptorDepSource };
 
+//#endregion
+export { usePoseDescriptorDepSource };
 //# sourceMappingURL=poseDescriptor.js.map

package/dist/canvas/deps/poseDescriptor.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseDescriptor.js","names":["usePoseDescriptorDepSource","ref","useLatest","descriptor","AUTO_POSE_DESCRIPTOR"],"sources":["../../../src/canvas/deps/poseDescriptor.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** Publish the pose descriptor every built-in action reads. */\nexport function usePoseDescriptorDepSource(\n  descriptor: PoseDescriptor<unknown> | undefined,\n): void {\n  const ref = useLatest(descriptor);\n  useDepSource('poseDescriptor', () => ref.current ?? AUTO_POSE_DESCRIPTOR);\n}\n"],"mappings":";;;;AAMA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,wBAAwBF,EAAI,WAAWG,CAAoB;AAC1E"}
+{"version":3,"file":"poseDescriptor.js","names":[],"sources":["../../../src/canvas/deps/poseDescriptor.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** Publish the pose descriptor every built-in action reads. */\nexport function usePoseDescriptorDepSource(\n  descriptor: PoseDescriptor<unknown> | undefined,\n): void {\n  const ref = useLatest(descriptor);\n  useDepSource('poseDescriptor', () => ref.current ?? AUTO_POSE_DESCRIPTOR);\n}\n"],"mappings":";;;;;;AAMA,SAAgB,2BACd,YACM;CACN,MAAM,MAAM,UAAU,UAAU;CAChC,aAAa,wBAAwB,IAAI,WAAW,oBAAoB;AAC1E"}

package/dist/canvas/deps/previewPaths.js

@@ -0,0 +1,44 @@
+import { createPathOverlay } from "../pathOverlay.js";
+import { useMemo } from "react";
+import { useDepSource } from "@weasel-js/routing/react";
+
+//#region src/canvas/deps/previewPaths.ts
+/**
+* `usePreviewPathsDepSource` — wires the `previewPaths` dep: where an
+* action's `preview` draws what it would make, over this canvas.
+*/
+/** The layer id the previewed paths are drawn on. */
+var PREVIEW_PATHS_LAYER_ID = "weasel-action-preview";
+/** A {@link PreviewPathsDep} drawing on the canvas `api` answers, its layer
+*  attached only while something is shown. */
+function createPreviewPaths(api) {
+	const overlay = createPathOverlay({
+		id: PREVIEW_PATHS_LAYER_ID,
+		label: "Action preview"
+	});
+	let detach = null;
+	let current = 0;
+	return { show(paths) {
+		const canvas = api();
+		if (!canvas) return () => {};
+		const mine = ++current;
+		overlay.set(paths);
+		if (!detach) detach = canvas.registerLayer(overlay.layer);
+		canvas.requestRedraw();
+		return () => {
+			if (mine !== current) return;
+			overlay.clear();
+			detach?.();
+			detach = null;
+			canvas.requestRedraw();
+		};
+	} };
+}
+function usePreviewPathsDepSource(canvasApiRef) {
+	const dep = useMemo(() => createPreviewPaths(() => canvasApiRef.current), [canvasApiRef]);
+	useDepSource("previewPaths", () => dep);
+}
+
+//#endregion
+export { PREVIEW_PATHS_LAYER_ID, createPreviewPaths, usePreviewPathsDepSource };
+//# sourceMappingURL=previewPaths.js.map

package/dist/canvas/deps/previewPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"previewPaths.js","names":[],"sources":["../../../src/canvas/deps/previewPaths.ts"],"sourcesContent":["/**\n * `usePreviewPathsDepSource` — wires the `previewPaths` dep: where an\n * action's `preview` draws what it would make, over this canvas.\n */\nimport { useMemo } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { createPathOverlay, type TransientPath } from 'canvas/pathOverlay';\nimport type { CanvasExtensionApi } from '../canvasExtension';\n\n/** Paths drawn over the canvas until the function `show` returns is called.\n *  A later `show` replaces what an earlier one drew, and the earlier one's\n *  function then takes nothing down. */\nexport interface PreviewPathsDep {\n  show(paths: readonly TransientPath[]): () => void;\n}\n\n/** The layer id the previewed paths are drawn on. */\nexport const PREVIEW_PATHS_LAYER_ID = 'weasel-action-preview';\n\n/** A {@link PreviewPathsDep} drawing on the canvas `api` answers, its layer\n *  attached only while something is shown. */\nexport function createPreviewPaths(api: () => CanvasExtensionApi | null): PreviewPathsDep {\n  const overlay = createPathOverlay({ id: PREVIEW_PATHS_LAYER_ID, label: 'Action preview' });\n  let detach: (() => void) | null = null;\n  let current = 0;\n  return {\n    show(paths) {\n      const canvas = api();\n      if (!canvas) return () => {};\n      const mine = ++current;\n      overlay.set(paths);\n      if (!detach) detach = canvas.registerLayer(overlay.layer);\n      canvas.requestRedraw();\n      return () => {\n        if (mine !== current) return;\n        overlay.clear();\n        detach?.();\n        detach = null;\n        canvas.requestRedraw();\n      };\n    },\n  };\n}\n\nexport function usePreviewPathsDepSource(canvasApiRef: React.RefObject<CanvasExtensionApi | null>): void {\n  const dep = useMemo(() => createPreviewPaths(() => canvasApiRef.current), [canvasApiRef]);\n  useDepSource('previewPaths', () => dep);\n}\n"],"mappings":";;;;;;;;;;AAiBA,IAAa,yBAAyB;;;AAItC,SAAgB,mBAAmB,KAAuD;CACxF,MAAM,UAAU,kBAAkB;EAAE,IAAI;EAAwB,OAAO;CAAiB,CAAC;CACzF,IAAI,SAA8B;CAClC,IAAI,UAAU;CACd,OAAO,EACL,KAAK,OAAO;EACV,MAAM,SAAS,IAAI;EACnB,IAAI,CAAC,QAAQ,aAAa,CAAC;EAC3B,MAAM,OAAO,EAAE;EACf,QAAQ,IAAI,KAAK;EACjB,IAAI,CAAC,QAAQ,SAAS,OAAO,cAAc,QAAQ,KAAK;EACxD,OAAO,cAAc;EACrB,aAAa;GACX,IAAI,SAAS,SAAS;GACtB,QAAQ,MAAM;GACd,SAAS;GACT,SAAS;GACT,OAAO,cAAc;EACvB;CACF,EACF;AACF;AAEA,SAAgB,yBAAyB,cAAgE;CACvG,MAAM,MAAM,cAAc,yBAAyB,aAAa,OAAO,GAAG,CAAC,YAAY,CAAC;CACxF,aAAa,sBAAsB,GAAG;AACxC"}

package/dist/canvas/deps/resizePolicy.js

@@ -1,35 +1,42 @@
-import { DEFAULT_RESIZE_BEHAVIORS as e } from "../../interactions/actions/resize/behaviors/index.js";
-import { useLatest as t } from "@weasel-js/react";
-import { useDepSource as n } from "@weasel-js/routing/react";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/resizePolicy.ts
-var r = (e) => e, i = Object.freeze([]);
-function a(a) {
-	let o = t(a);
-	n("resizePolicy", () => {
-		let t = o.current;
+/**
+* Wires the `resizePolicy` dep consumed by `resizeAction`. Omitted
+* `constraints` default to none; Shift's aspect lock is the snap session's.
+*/
+var IDENTITY_EXPAND = (ids) => ids;
+var EMPTY = Object.freeze([]);
+/** Publish how resizing should behave — constraints and group expansion —
+*  for the resize action to consult. */
+function useResizePolicy(options) {
+	const optsRef = useLatest(options);
+	useDepSource("resizePolicy", () => {
+		const o = optsRef.current;
 		return {
-			label: t.label,
-			transient: t.transient,
-			onGestureStart: t.onGestureStart,
-			onGestureEnd: t.onGestureEnd,
-			constraints: t.constraints ?? e,
-			pointSnap: t.pointSnap ?? i,
-			expandIds: t.expandIds ?? r
+			label: o.label,
+			transient: o.transient,
+			onGestureStart: o.onGestureStart,
+			onGestureEnd: o.onGestureEnd,
+			constraints: o.constraints ?? EMPTY,
+			expandIds: o.expandIds ?? IDENTITY_EXPAND
 		};
 	});
 }
-function o(e) {
+/** `<SceneCanvas selectTool.resize>` as {@link useResizePolicy} options.
+*  `resizable` is read by `<SceneCanvas>` itself. */
+function resizePolicyOptions(o) {
 	return {
-		constraints: e.behaviors,
-		pointSnap: e.pointSnapBehaviors,
-		expandIds: e.expandIds,
-		label: e.resizeLabel,
-		transient: e.transient,
-		onGestureStart: e.onGestureStart,
-		onGestureEnd: e.onGestureEnd
+		constraints: o.behaviors,
+		expandIds: o.expandIds,
+		label: o.resizeLabel,
+		transient: o.transient,
+		onGestureStart: o.onGestureStart,
+		onGestureEnd: o.onGestureEnd
 	};
 }
-//#endregion
-export { o as resizePolicyOptions, a as useResizePolicy };
 
+//#endregion
+export { resizePolicyOptions, useResizePolicy };
 //# sourceMappingURL=resizePolicy.js.map

package/dist/canvas/deps/resizePolicy.js.map

@@ -1 +1 @@
-{"version":3,"file":"resizePolicy.js","names":["IDENTITY_EXPAND","ids","EMPTY","useResizePolicy","optsRef","useLatest","options","o","DEFAULT_RESIZE_BEHAVIORS","resizePolicyOptions"],"sources":["../../../src/canvas/deps/resizePolicy.ts"],"sourcesContent":["/**\n * Wires the `resizePolicy` dep consumed by `resizeAction`. Omitted\n * `constraints` default to `DEFAULT_RESIZE_BEHAVIORS` (shift = aspect lock);\n * pass `[]` to disable.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { ResizePolicy } from 'interactions/actions/depSchema';\nimport type {\n  PointSnapBehavior,\n  BoundsConstraint,\n} from 'interactions/gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { DEFAULT_RESIZE_BEHAVIORS } from 'interactions/actions/resize/behaviors';\nimport type { GestureLifecycleOptions } from 'interactions/actions/gestureLifecycle';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\n\n/** Options for `useResizePolicy`. Each omitted field falls back to the kit\n *  default. */\nexport interface UseResizePolicyOptions<TPose> extends GestureLifecycleOptions {\n  constraints?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];\n  pointSnap?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never[];\n  expandIds?: (ids: string[]) => string[];\n}\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** Publish how resizing should behave — constraints, point snapping, group\n *  expansion — for the resize action to consult. */\nexport function useResizePolicy<TPose>(\n  options: UseResizePolicyOptions<TPose>,\n): void {\n  const optsRef = useLatest(options);\n\n  useDepSource('resizePolicy', (): ResizePolicy<unknown> => {\n    const o = optsRef.current;\n    return {\n      label: o.label,\n      transient: o.transient,\n      onGestureStart: o.onGestureStart,\n      onGestureEnd: o.onGestureEnd,\n      constraints: (o.constraints ?? DEFAULT_RESIZE_BEHAVIORS) as ResizePolicy<unknown>['constraints'],\n      pointSnap: (o.pointSnap ?? (EMPTY as unknown[])) as ResizePolicy<unknown>['pointSnap'],\n      expandIds: o.expandIds ?? IDENTITY_EXPAND,\n    };\n  });\n}\n\n/** `<SceneCanvas selectTool.resize>` as {@link useResizePolicy} options.\n *  `resizable` is read by `<SceneCanvas>` itself. */\nexport function resizePolicyOptions<TPose>(o: UseResizeOptions<TPose>): UseResizePolicyOptions<TPose> {\n  return {\n    constraints: o.behaviors as UseResizePolicyOptions<TPose>['constraints'],\n    pointSnap: o.pointSnapBehaviors as UseResizePolicyOptions<TPose>['pointSnap'],\n    expandIds: o.expandIds,\n    label: o.resizeLabel,\n    transient: o.transient,\n    onGestureStart: o.onGestureStart,\n    onGestureEnd: o.onGestureEnd,\n  };\n}\n"],"mappings":";;;;AAyBA,IAAMA,KAAmB,MAAkBC,GACrCC,IAA4B,OAAO,OAAO,CAAC,CAAC;AAIlD,SAAgBC,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAO;CAEjC,EAAa,sBAA6C;EACxD,IAAMC,IAAIH,EAAQ;EAClB,OAAO;GACL,OAAOG,EAAE;GACT,WAAWA,EAAE;GACb,gBAAgBA,EAAE;GAClB,cAAcA,EAAE;GAChB,aAAcA,EAAE,eAAeC;GAC/B,WAAYD,EAAE,aAAcL;GAC5B,WAAWK,EAAE,aAAaP;EAC5B;CACF,CAAC;AACH;AAIA,SAAgBS,EAA2B,GAA2D;CACpG,OAAO;EACL,aAAaF,EAAE;EACf,WAAWA,EAAE;EACb,WAAWA,EAAE;EACb,OAAOA,EAAE;EACT,WAAWA,EAAE;EACb,gBAAgBA,EAAE;EAClB,cAAcA,EAAE;CAClB;AACF"}
+{"version":3,"file":"resizePolicy.js","names":[],"sources":["../../../src/canvas/deps/resizePolicy.ts"],"sourcesContent":["/**\n * Wires the `resizePolicy` dep consumed by `resizeAction`. Omitted\n * `constraints` default to none; Shift's aspect lock is the snap session's.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { ResizePolicy } from 'interactions/actions/depSchema';\nimport type { BoundsConstraint } from 'interactions/gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureLifecycleOptions } from 'interactions/actions/gestureLifecycle';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\n\n/** Options for `useResizePolicy`. Each omitted field falls back to the kit\n *  default. */\nexport interface UseResizePolicyOptions<TPose> extends GestureLifecycleOptions {\n  constraints?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];\n  expandIds?: (ids: string[]) => string[];\n}\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY: readonly unknown[] = Object.freeze([]);\n\n/** Publish how resizing should behave — constraints and group expansion —\n *  for the resize action to consult. */\nexport function useResizePolicy<TPose>(\n  options: UseResizePolicyOptions<TPose>,\n): void {\n  const optsRef = useLatest(options);\n\n  useDepSource('resizePolicy', (): ResizePolicy<unknown> => {\n    const o = optsRef.current;\n    return {\n      label: o.label,\n      transient: o.transient,\n      onGestureStart: o.onGestureStart,\n      onGestureEnd: o.onGestureEnd,\n      constraints: (o.constraints ?? (EMPTY as unknown[])) as ResizePolicy<unknown>['constraints'],\n      expandIds: o.expandIds ?? IDENTITY_EXPAND,\n    };\n  });\n}\n\n/** `<SceneCanvas selectTool.resize>` as {@link useResizePolicy} options.\n *  `resizable` is read by `<SceneCanvas>` itself. */\nexport function resizePolicyOptions<TPose>(o: UseResizeOptions<TPose>): UseResizePolicyOptions<TPose> {\n  return {\n    constraints: o.behaviors as UseResizePolicyOptions<TPose>['constraints'],\n    expandIds: o.expandIds,\n    label: o.resizeLabel,\n    transient: o.transient,\n    onGestureStart: o.onGestureStart,\n    onGestureEnd: o.onGestureEnd,\n  };\n}\n"],"mappings":";;;;;;;;AAmBA,IAAM,mBAAmB,QAAkB;AAC3C,IAAM,QAA4B,OAAO,OAAO,CAAC,CAAC;;;AAIlD,SAAgB,gBACd,SACM;CACN,MAAM,UAAU,UAAU,OAAO;CAEjC,aAAa,sBAA6C;EACxD,MAAM,IAAI,QAAQ;EAClB,OAAO;GACL,OAAO,EAAE;GACT,WAAW,EAAE;GACb,gBAAgB,EAAE;GAClB,cAAc,EAAE;GAChB,aAAc,EAAE,eAAgB;GAChC,WAAW,EAAE,aAAa;EAC5B;CACF,CAAC;AACH;;;AAIA,SAAgB,oBAA2B,GAA2D;CACpG,OAAO;EACL,aAAa,EAAE;EACf,WAAW,EAAE;EACb,OAAO,EAAE;EACT,WAAW,EAAE;EACb,gBAAgB,EAAE;EAClB,cAAc,EAAE;CAClB;AACF"}

package/dist/canvas/deps/slice.js

@@ -1,99 +1,85 @@
-import { poseDescriptorForNode as e } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as t } from "../../core/geometry/autoPoseDescriptor.js";
-import { scenePoseFrame as n } from "../../interactions/actions/poseFrame.js";
-import { computeSliceOps as r } from "../../interactions/actions/defaults/sliceOps.js";
-import { pathInWorld as i, poseLinearOf as a, worldEditToStorage as o } from "@weasel-js/geom";
-import { useLatest as s } from "@weasel-js/react";
-import { useDepSource as c } from "@weasel-js/routing/react";
+import { poseDescriptorForNode } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR } from "../../core/geometry/autoPoseDescriptor.js";
+import { scenePoseFrame } from "../../interactions/actions/poseFrame.js";
+import { drawnPose, leafPath, storePiece } from "./pathLeaf.js";
+import { computeSliceOps } from "../../interactions/actions/defaults/sliceOps.js";
+import { pathInWorld } from "@weasel-js/geom";
+import { useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/slice.ts
-function l(e) {
-	let t = s(e);
-	c("slice", () => t.current);
+/**
+* The `slice` dep `sliceAction` and `useSliceTool` commit their cuts through.
+*
+* `<SceneCanvas>` publishes `useSliceDepSource` over its own scene. A consumer
+* replaces it with `useSliceDep` (or `useDepSource('slice', …)`) from under
+* the canvas; the newest registration wins, and a canvas child registers
+* after the canvas's own.
+*/
+/** Publish how a slice (knife cut) is performed, so the `slice` action can
+*  run against the consumer's geometry. */
+function useSliceDep(dep) {
+	const depRef = useLatest(dep);
+	useDepSource("slice", () => depRef.current);
 }
-function u(a, o, l, u) {
-	let h = s(a), g = s(o), _ = s(l), v = s(u);
-	c("slice", () => ({ commit(a) {
-		let o = h.current, s = n(o), c = v.current ?? t, l = [], u = /* @__PURE__ */ new Map();
-		for (let t of o.renderOrderNodes()) {
-			let n = p(o, t);
-			if (!n) continue;
-			let r = d(e(c, t), s.world(t.id));
-			r && (u.set(t.id, r), l.push({
-				node: t,
-				index: m(o, t),
-				worldPath: i(n, r.box)
-			}));
+/**
+* The kit `slice` dep: cut every leaf the cut crosses and swap it for its
+* pieces in one undoable batch.
+*
+* A leaf is cut when its `data.path` is a `Path` and `poseDescriptor` can read
+* its world pose as a box and a rotation; a leaf on a locked layer, or one
+* whose geometry derives from other nodes, is passed over. A piece keeps the
+* source's rotation in its pose when the descriptor can write one
+* (`withRotation`), and has the rotation baked into its path otherwise. The
+* pieces of a selected leaf take its place in the selection.
+*/
+function useSliceDepSource(scene, selection, adapter, poseDescriptor) {
+	const sceneRef = useLatest(scene);
+	const selectionRef = useLatest(selection);
+	const adapterRef = useLatest(adapter);
+	const descriptorRef = useLatest(poseDescriptor);
+	useDepSource("slice", () => ({ commit(cut) {
+		const sc = sceneRef.current;
+		const frame = scenePoseFrame(sc);
+		const descriptor = descriptorRef.current ?? AUTO_POSE_DESCRIPTOR;
+		const leaves = [];
+		const drawnAt = /* @__PURE__ */ new Map();
+		for (const node of sc.renderOrderNodes()) {
+			if (sc.isHidden(node.id)) continue;
+			const path = leafPath(sc, node);
+			if (!path) continue;
+			const drawn = drawnPose(poseDescriptorForNode(descriptor, node), frame.world(node.id));
+			if (!drawn) continue;
+			drawnAt.set(node.id, drawn);
+			leaves.push({
+				node,
+				index: siblingIndex(sc, node),
+				worldPath: pathInWorld(path, drawn.box)
+			});
 		}
-		let y = g.current, { ops: b, nextSelection: x } = r({
-			leaves: l,
-			cut: a,
-			nextId: () => o.mintId(),
-			selection: y.get(),
-			placePiece: (e, t) => {
-				let n = f(u.get(e.node.id), t);
+		const sel = selectionRef.current;
+		const { ops, nextSelection } = computeSliceOps({
+			leaves,
+			cut,
+			nextId: () => sc.mintId(),
+			selection: sel.get(),
+			placePiece: (leaf, piece) => {
+				const stored = storePiece(drawnAt.get(leaf.node.id), piece);
 				return {
-					pose: s.local(e.node.id, n.pose),
-					path: n.path
+					pose: frame.local(leaf.node.id, stored.pose),
+					path: stored.path
 				};
 			}
 		});
-		b.length !== 0 && (_.current.applyOps(b, "Slice"), x && y.set(x));
+		if (ops.length === 0) return;
+		adapterRef.current.applyOps(ops, "Slice");
+		if (nextSelection) sel.set(nextSelection);
 	} }));
 }
-function d(e, t) {
-	let n = e.getBounds(t);
-	if (!n || ![
-		n.x,
-		n.y,
-		n.width,
-		n.height
-	].every(Number.isFinite)) return null;
-	let r = e.getRotation?.(t) ?? 0, i = a(t) ?? void 0;
-	return {
-		world: t,
-		g: e,
-		box: {
-			x: n.x,
-			y: n.y,
-			width: n.width,
-			height: n.height,
-			rotation: r,
-			transform: i
-		}
-	};
-}
-function f({ world: e, g: t, box: n }, r) {
-	let i = !!t.withRotation && t.supportsRotation?.(e) !== !1, a = n.rotation ?? 0;
-	if (a !== 0 && !i) {
-		let i = o({
-			...n,
-			rotation: 0
-		}, r);
-		return {
-			pose: t.fromBounds(i.pose, e),
-			path: i.path
-		};
-	}
-	let { pose: s, path: c } = o(n, r), l = {
-		x: s.x,
-		y: s.y,
-		width: s.width,
-		height: s.height
-	}, u = t.remapBounds(e, t.getBounds(e), l);
-	return {
-		pose: a === 0 ? u : t.withRotation(u, a),
-		path: c
-	};
-}
-function p(e, t) {
-	if (t.kind !== "leaf" || t.derivePath || t.derivePose || e.isLocked(t.id)) return null;
-	let n = t.data?.path;
-	return n && (n.kind === "rect" || n.kind === "polygon") ? n : null;
+function siblingIndex(scene, node) {
+	return (node.parent == null ? scene.roots : scene.childrenOf(node.parent)).indexOf(node.id);
 }
-function m(e, t) {
-	return (t.parent == null ? e.roots : e.childrenOf(t.parent)).indexOf(t.id);
-}
-//#endregion
-export { l as useSliceDep, u as useSliceDepSource };
 
+//#endregion
+export { useSliceDep, useSliceDepSource };
 //# sourceMappingURL=slice.js.map