@weasel-js/core 1.10.1 → 1.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"slice.js","names":["useSliceDep","depRef","useLatest","dep","useSliceDepSource","sceneRef","scene","selectionRef","selection","adapterRef","adapter","descriptorRef","poseDescriptor","sc","frame","scenePoseFrame","descriptor","AUTO_POSE_DESCRIPTOR","leaves","drawnAt","node","path","sliceablePath","drawn","drawnPose","poseDescriptorForNode","siblingIndex","pathInWorld","sel","computeSliceOps","stored","storePiece","leaf","piece","ops","nextSelection","b","g","world","rotation","transform","poseLinearOf","keepsRotation","box","baked","worldEditToStorage","dst","pose"],"sources":["../../../src/canvas/deps/slice.ts"],"sourcesContent":["/**\n * The `slice` dep `sliceAction` and `useSliceTool` commit their cuts through.\n *\n * `<SceneCanvas>` publishes `useSliceDepSource` over its own scene. A consumer\n * replaces it with `useSliceDep` (or `useDepSource('slice', …)`) from under\n * the canvas; the newest registration wins, and a canvas child registers\n * after the canvas's own.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SliceDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId, Node } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { Path } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { pathInWorld, worldEditToStorage, type PathInWorldPose } from '@weasel-js/geom';\nimport { poseLinearOf } from '@weasel-js/geom';\nimport { scenePoseFrame } from 'interactions/actions/poseFrame';\nimport { computeSliceOps, type SliceLeaf } from 'interactions/actions/defaults/sliceOps';\n\n/** Publish how a slice (knife cut) is performed, so the `slice` action can\n *  run against the consumer's geometry. */\nexport function useSliceDep(dep: SliceDep): void {\n  const depRef = useLatest(dep);\n\n  useDepSource('slice', (): SliceDep => depRef.current);\n}\n\n/** What the `slice` dep writes its batch through. An adapter satisfies it. */\nexport interface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * The kit `slice` dep: cut every leaf the cut crosses and swap it for its\n * pieces in one undoable batch.\n *\n * A leaf is cut when its `data.path` is a `Path` and `poseDescriptor` can read\n * its world pose as a box and a rotation; a leaf on a locked layer, or one\n * whose geometry derives from other nodes, is passed over. A piece keeps the\n * source's rotation in its pose when the descriptor can write one\n * (`withRotation`), and has the rotation baked into its path otherwise. The\n * pieces of a selected leaf take its place in the selection.\n */\nexport function useSliceDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  poseDescriptor?: PoseDescriptor<unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const descriptorRef = useLatest(poseDescriptor);\n\n  useDepSource('slice', (): SliceDep => ({\n    commit(cut) {\n      const sc = sceneRef.current;\n      const frame = scenePoseFrame(sc);\n      const descriptor = descriptorRef.current ?? AUTO_POSE_DESCRIPTOR;\n      const leaves: SliceLeaf<Node<unknown, string, unknown>>[] = [];\n      const drawnAt = new Map<string, DrawnPose>();\n      for (const node of sc.renderOrderNodes()) {\n        const path = sliceablePath(sc, node);\n        if (!path) continue;\n        const drawn = drawnPose(poseDescriptorForNode(descriptor, node), frame.world(node.id));\n        if (!drawn) continue;\n        drawnAt.set(node.id, drawn);\n        leaves.push({ node, index: siblingIndex(sc, node), worldPath: pathInWorld(path, drawn.box) });\n      }\n\n      const sel = selectionRef.current;\n      const { ops, nextSelection } = computeSliceOps({\n        leaves,\n        cut,\n        nextId: () => sc.mintId(),\n        selection: sel.get(),\n        placePiece: (leaf, piece) => {\n          const stored = storePiece(drawnAt.get(leaf.node.id)!, piece);\n          return { pose: frame.local(leaf.node.id, stored.pose), path: stored.path };\n        },\n      });\n      if (ops.length === 0) return;\n      adapterRef.current.applyOps(ops, 'Slice');\n      if (nextSelection) sel.set(nextSelection as NodeId[]);\n    },\n  }));\n}\n\n/** A leaf's world pose, and the box, rotation, and transform its path is drawn through. */\ninterface DrawnPose {\n  world: unknown;\n  g: PoseDescriptor<unknown>;\n  box: PathInWorldPose;\n}\n\nfunction 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. */\nfunction 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\nfunction sliceablePath(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\nfunction siblingIndex(scene: Scene<unknown, string, unknown>, node: Node<unknown, string, unknown>): number {\n  const siblings = node.parent == null ? scene.roots : scene.childrenOf(node.parent);\n  return siblings.indexOf(node.id);\n}\n"],"mappings":";;;;;;;;AAwBA,SAAgBA,EAAY,GAAqB;CAC/C,IAAMC,IAASC,EAAUC,CAAG;CAE5B,EAAa,eAAyBF,EAAO,OAAO;AACtD;AAkBA,SAAgBG,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAWH,EAAUI,CAAK,GAC1BC,IAAeL,EAAUM,CAAS,GAClCC,IAAaP,EAAUQ,CAAO,GAC9BC,IAAgBT,EAAUU,CAAc;CAE9C,EAAa,gBAA0B,EACrC,OAAO,GAAK;EACV,IAAMC,IAAKR,EAAS,SACdS,IAAQC,EAAeF,CAAE,GACzBG,IAAaL,EAAc,WAAWM,GACtCC,IAAsD,CAAC,GACvDC,oBAAU,IAAI,IAAuB;EAC3C,KAAK,IAAMC,KAAQP,EAAG,iBAAiB,GAAG;GACxC,IAAMQ,IAAOC,EAAcT,GAAIO,CAAI;GACnC,IAAI,CAACC,GAAM;GACX,IAAME,IAAQC,EAAUC,EAAsBT,GAAYI,CAAI,GAAGN,EAAM,MAAMM,EAAK,EAAE,CAAC;GACrF,AAAKG,MACLJ,EAAQ,IAAIC,EAAK,IAAIG,CAAK,GAC1BL,EAAO,KAAK;IAAE;IAAM,OAAOQ,EAAab,GAAIO,CAAI;IAAG,WAAWO,EAAYN,GAAME,EAAM,GAAG;GAAE,CAAC;EAC9F;EAEA,IAAMK,IAAMrB,EAAa,SACnB,EAAE,QAAK,qBAAkBsB,EAAgB;GAC7C;GACA;GACA,cAAchB,EAAG,OAAO;GACxB,WAAWe,EAAI,IAAI;GACnB,aAAa,GAAM,MAAU;IAC3B,IAAME,IAASC,EAAWZ,EAAQ,IAAIa,EAAK,KAAK,EAAE,GAAIC,CAAK;IAC3D,OAAO;KAAE,MAAMnB,EAAM,MAAMkB,EAAK,KAAK,IAAIF,EAAO,IAAI;KAAG,MAAMA,EAAO;IAAK;GAC3E;EACF,CAAC;EACD,AAAII,EAAI,WAAW,MACnBzB,EAAW,QAAQ,SAASyB,GAAK,OAAO,GACpCC,KAAeP,EAAI,IAAIO,CAAyB;CACtD,EACF,EAAE;AACJ;AASA,SAASX,EAAU,GAA4B,GAAkC;CAC/E,IAAMY,IAAIC,EAAE,UAAUC,CAAK;CAC3B,IAAI,CAACF,KAAK,CAAC;EAACA,EAAE;EAAGA,EAAE;EAAGA,EAAE;EAAOA,EAAE;CAAM,CAAC,CAAC,MAAM,OAAO,QAAQ,GAAG,OAAO;CACxE,IAAMG,IAAWF,EAAE,cAAcC,CAAK,KAAK,GACrCE,IAAYC,EAAaH,CAAK,KAAK,KAAA;CACzC,OAAO;EAAE;EAAO;EAAG,KAAK;GAAE,GAAGF,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;GAAQ;GAAU;EAAU;CAAE;AACpG;AAGA,SAASL,EAAW,EAAE,UAAO,MAAG,UAAkB,GAA4C;CAC5F,IAAMW,IAAgB,CAAC,CAACL,EAAE,gBAAgBA,EAAE,mBAAmBC,CAAK,MAAM,IACpEC,IAAWI,EAAI,YAAY;CACjC,IAAIJ,MAAa,KAAK,CAACG,GAAe;EACpC,IAAME,IAAQC,EAAmB;GAAE,GAAGF;GAAK,UAAU;EAAE,GAAGV,CAAK;EAC/D,OAAO;GAAE,MAAMI,EAAE,WAAWO,EAAM,MAAMN,CAAK;GAAG,MAAMM,EAAM;EAAK;CACnE;CACA,IAAM,EAAE,MAAMR,GAAG,YAASS,EAAmBF,GAAKV,CAAK,GACjDa,IAAM;EAAE,GAAGV,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO,GACzDW,IAAOV,EAAE,YAAYC,GAAOD,EAAE,UAAUC,CAAK,GAAGQ,CAAG;CACzD,OAAO;EAAE,MAAMP,MAAa,IAAsCQ,IAAlCV,EAAE,aAAcU,GAAMR,CAAQ;EAAU;CAAK;AAC/E;AAEA,SAASjB,EAAc,GAAwC,GAAmD;CAEhH,IADIF,EAAK,SAAS,UAAUA,EAAK,cAAcA,EAAK,cAChDd,EAAM,SAASc,EAAK,EAAE,GAAG,OAAO;CACpC,IAAMC,IAAQD,EAAK,MAAoC;CACvD,OAAOC,MAASA,EAAK,SAAS,UAAUA,EAAK,SAAS,aAAaA,IAAO;AAC5E;AAEA,SAASK,EAAa,GAAwC,GAA8C;CAE1G,QADiBN,EAAK,UAAU,OAAOd,EAAM,QAAQA,EAAM,WAAWc,EAAK,MAAM,EAAA,CACjE,QAAQA,EAAK,EAAE;AACjC"}
+{"version":3,"file":"slice.js","names":[],"sources":["../../../src/canvas/deps/slice.ts"],"sourcesContent":["/**\n * The `slice` dep `sliceAction` and `useSliceTool` commit their cuts through.\n *\n * `<SceneCanvas>` publishes `useSliceDepSource` over its own scene. A consumer\n * replaces it with `useSliceDep` (or `useDepSource('slice', …)`) from under\n * the canvas; the newest registration wins, and a canvas child registers\n * after the canvas's own.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SliceDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId, Node } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { pathInWorld } from '@weasel-js/geom';\nimport { drawnPose, leafPath, storePiece, type DrawnPose } from './pathLeaf';\nimport { scenePoseFrame } from 'interactions/actions/poseFrame';\nimport { computeSliceOps, type SliceLeaf } from 'interactions/actions/defaults/sliceOps';\n\n/** Publish how a slice (knife cut) is performed, so the `slice` action can\n *  run against the consumer's geometry. */\nexport function useSliceDep(dep: SliceDep): void {\n  const depRef = useLatest(dep);\n\n  useDepSource('slice', (): SliceDep => depRef.current);\n}\n\n/** What the `slice` dep writes its batch through. An adapter satisfies it. */\nexport interface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * The kit `slice` dep: cut every leaf the cut crosses and swap it for its\n * pieces in one undoable batch.\n *\n * A leaf is cut when its `data.path` is a `Path` and `poseDescriptor` can read\n * its world pose as a box and a rotation; a leaf on a locked layer, or one\n * whose geometry derives from other nodes, is passed over. A piece keeps the\n * source's rotation in its pose when the descriptor can write one\n * (`withRotation`), and has the rotation baked into its path otherwise. The\n * pieces of a selected leaf take its place in the selection.\n */\nexport function useSliceDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  poseDescriptor?: PoseDescriptor<unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const descriptorRef = useLatest(poseDescriptor);\n\n  useDepSource('slice', (): SliceDep => ({\n    commit(cut) {\n      const sc = sceneRef.current;\n      const frame = scenePoseFrame(sc);\n      const descriptor = descriptorRef.current ?? AUTO_POSE_DESCRIPTOR;\n      const leaves: SliceLeaf<Node<unknown, string, unknown>>[] = [];\n      const drawnAt = new Map<string, DrawnPose>();\n      for (const node of sc.renderOrderNodes()) {\n        if (sc.isHidden(node.id)) continue;\n        const path = leafPath(sc, node);\n        if (!path) continue;\n        const drawn = drawnPose(poseDescriptorForNode(descriptor, node), frame.world(node.id));\n        if (!drawn) continue;\n        drawnAt.set(node.id, drawn);\n        leaves.push({ node, index: siblingIndex(sc, node), worldPath: pathInWorld(path, drawn.box) });\n      }\n\n      const sel = selectionRef.current;\n      const { ops, nextSelection } = computeSliceOps({\n        leaves,\n        cut,\n        nextId: () => sc.mintId(),\n        selection: sel.get(),\n        placePiece: (leaf, piece) => {\n          const stored = storePiece(drawnAt.get(leaf.node.id)!, piece);\n          return { pose: frame.local(leaf.node.id, stored.pose), path: stored.path };\n        },\n      });\n      if (ops.length === 0) return;\n      adapterRef.current.applyOps(ops, 'Slice');\n      if (nextSelection) sel.set(nextSelection as NodeId[]);\n    },\n  }));\n}\n\nfunction siblingIndex(scene: Scene<unknown, string, unknown>, node: Node<unknown, string, unknown>): number {\n  const siblings = node.parent == null ? scene.roots : scene.childrenOf(node.parent);\n  return siblings.indexOf(node.id);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,YAAY,KAAqB;CAC/C,MAAM,SAAS,UAAU,GAAG;CAE5B,aAAa,eAAyB,OAAO,OAAO;AACtD;;;;;;;;;;;;AAkBA,SAAgB,kBACd,OACA,WACA,SACA,gBACM;CACN,MAAM,WAAW,UAAU,KAAK;CAChC,MAAM,eAAe,UAAU,SAAS;CACxC,MAAM,aAAa,UAAU,OAAO;CACpC,MAAM,gBAAgB,UAAU,cAAc;CAE9C,aAAa,gBAA0B,EACrC,OAAO,KAAK;EACV,MAAM,KAAK,SAAS;EACpB,MAAM,QAAQ,eAAe,EAAE;EAC/B,MAAM,aAAa,cAAc,WAAW;EAC5C,MAAM,SAAsD,CAAC;EAC7D,MAAM,0BAAU,IAAI,IAAuB;EAC3C,KAAK,MAAM,QAAQ,GAAG,iBAAiB,GAAG;GACxC,IAAI,GAAG,SAAS,KAAK,EAAE,GAAG;GAC1B,MAAM,OAAO,SAAS,IAAI,IAAI;GAC9B,IAAI,CAAC,MAAM;GACX,MAAM,QAAQ,UAAU,sBAAsB,YAAY,IAAI,GAAG,MAAM,MAAM,KAAK,EAAE,CAAC;GACrF,IAAI,CAAC,OAAO;GACZ,QAAQ,IAAI,KAAK,IAAI,KAAK;GAC1B,OAAO,KAAK;IAAE;IAAM,OAAO,aAAa,IAAI,IAAI;IAAG,WAAW,YAAY,MAAM,MAAM,GAAG;GAAE,CAAC;EAC9F;EAEA,MAAM,MAAM,aAAa;EACzB,MAAM,EAAE,KAAK,kBAAkB,gBAAgB;GAC7C;GACA;GACA,cAAc,GAAG,OAAO;GACxB,WAAW,IAAI,IAAI;GACnB,aAAa,MAAM,UAAU;IAC3B,MAAM,SAAS,WAAW,QAAQ,IAAI,KAAK,KAAK,EAAE,GAAI,KAAK;IAC3D,OAAO;KAAE,MAAM,MAAM,MAAM,KAAK,KAAK,IAAI,OAAO,IAAI;KAAG,MAAM,OAAO;IAAK;GAC3E;EACF,CAAC;EACD,IAAI,IAAI,WAAW,GAAG;EACtB,WAAW,QAAQ,SAAS,KAAK,OAAO;EACxC,IAAI,eAAe,IAAI,IAAI,aAAyB;CACtD,EACF,EAAE;AACJ;AAEA,SAAS,aAAa,OAAwC,MAA8C;CAE1G,QADiB,KAAK,UAAU,OAAO,MAAM,QAAQ,MAAM,WAAW,KAAK,MAAM,EAC1E,CAAS,QAAQ,KAAK,EAAE;AACjC"}

package/dist/canvas/deps/snap.js

@@ -1,11 +1,62 @@
-import { useLatest as e } from "@weasel-js/react";
-import { useDepSource as t } from "@weasel-js/routing/react";
+import { snapSourcesFor } from "../../features/snap/gather.js";
+import { DEFAULT_SNAP_PX } from "../../features/snap/session2d.js";
+import { ownGeometryAt, pathSnapSource } from "../../features/paths/pathSnap/pathSnapSource.js";
+import { sceneSession2d } from "../../features/snap/sceneSession2d.js";
+import { rotationSnapSource } from "../../features/snap/rotationSource.js";
+import { useKitSettings, useLatest } from "@weasel-js/react";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/snap.ts
-function n(n) {
-	let r = e(n);
-	t("snap", () => ({ point: (e) => r.current?.(e) ?? e }));
+/**
+* `useSnapDepSource` — wires the `snap` dep whose `begin` every snapping
+* gesture runs: a session over the snap sources `session` names, writing its
+* marks to the outcome store this hook returns.
+*/
+/** The sources every canvas asks after its own, unless `omit` names one:
+*  quarter turns and other nodes' angles for a rotate, and other nodes'
+*  anchors for a point gesture, under `pathSnapSource`'s own id, so a
+*  consumer's `pathSnapSource()` takes its place. */
+var DEFAULT_SNAP_SOURCES = [rotationSnapSource(), {
+	...pathSnapSource({ only: ["anchor"] }),
+	gestures: ["point"]
+}];
+/** `listed`, one source per id (the last one listed, where it stands),
+*  then each default whose id is neither listed nor in `omit`. */
+function withDefaults(listed, omit = []) {
+	const last = new Map(listed.map((s, i) => [s.id, i]));
+	const taken = /* @__PURE__ */ new Set([...last.keys(), ...omit]);
+	return [...listed.filter((s, i) => last.get(s.id) === i), ...DEFAULT_SNAP_SOURCES.filter((s) => !taken.has(s.id))];
+}
+function useSnapDepSource(viewRef, session, store) {
+	const sessionRef = useLatest(session);
+	const kitSettings = useKitSettings();
+	useDepSource("snapReadout", () => ({ store }));
+	useDepSource("snap", () => ({ begin: (req) => {
+		const s = sessionRef.current;
+		const view = viewRef.current;
+		const sources = withDefaults([...s.sources, ...s.registry?.list() ?? []], s.omit);
+		const wantsGeometry = snapSourcesFor(sources, req.gesture).some((src) => src.roles.includes("geometry"));
+		const debug = s.debug?.() ?? void 0;
+		return sceneSession2d({
+			req,
+			scene: s.scene,
+			boxes: s.boxes(),
+			sources,
+			...wantsGeometry ? { geometryAt: (press, ids) => ownGeometryAt(s.scene, press, ids, view?.scale ?? {
+				x: 1,
+				y: 1
+			}) } : {},
+			view: () => viewRef.current,
+			reachPx: s.reachPx ?? kitSettings.get("targets.snapPx") ?? DEFAULT_SNAP_PX,
+			...s.poseDescriptor ? { poseDescriptor: s.poseDescriptor } : {},
+			...s.originProjection ? { originProjection: s.originProjection } : {},
+			...debug ? { debug } : {},
+			store
+		});
+	} }));
+	return store;
 }
-//#endregion
-export { n as useSnapDepSource };
 
+//#endregion
+export { useSnapDepSource };
 //# sourceMappingURL=snap.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"snap.js","names":["useSnapDepSource","snapRef","useLatest","snapPoint","p"],"sources":["../../../src/canvas/deps/snap.ts"],"sourcesContent":["/**\n * `useSnapDepSource` — wires the `snap` dep consumed by `insertAction`.\n *\n * Sourced from `<SceneCanvas toolOptions={{ snapPoint }} />`. The dep is a\n * live thunk over a ref, so toggling snap on/off (WeaselDraw's snap-to-grid\n * switch) takes effect on the next gesture without remounting the registry.\n *\n * Always registered (hooks can't be conditional); when no `snapPoint` is\n * supplied the dep's `point` is the identity function, which is the same\n * behavior actions fall back to when the dep is absent entirely.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { SnapDep } from 'interactions/actions/depSchema';\n\nexport function useSnapDepSource(\n  snapPoint: ((p: { x: number; y: number }) => { x: number; y: number }) | undefined,\n): void {\n  const snapRef = useLatest(snapPoint);\n\n  useDepSource('snap', (): SnapDep => ({\n    point: (p) => snapRef.current?.(p) ?? p,\n  }));\n}\n"],"mappings":";;;AAeA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAUC,EAAUC,CAAS;CAEnC,EAAa,eAAwB,EACnC,QAAQ,MAAMF,EAAQ,UAAUG,CAAC,KAAKA,EACxC,EAAE;AACJ"}
+{"version":3,"file":"snap.js","names":[],"sources":["../../../src/canvas/deps/snap.ts"],"sourcesContent":["/**\n * `useSnapDepSource` — wires the `snap` dep whose `begin` every snapping\n * gesture runs: a session over the snap sources `session` names, writing its\n * marks to the outcome store this hook returns.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useKitSettings, useLatest } from '@weasel-js/react';\nimport type { DebugSink } from '@weasel-js/routing';\nimport type { SnapDep } from 'interactions/actions/snapDep';\nimport { ownGeometryAt } from 'features/paths/pathSnap/pathSnapSource';\nimport type { View } from 'core/viewport/view';\nimport type { Scene } from 'core/scene/types';\nimport type { DrawnBoxes } from 'interactions/actions/drawnBoxes';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { OriginProjection } from 'interactions/gestures/shared/originProjection';\nimport type { SnapOutcomeStore } from 'features/snap/outcomeStore';\nimport type { SnapSourceRegistry } from 'features/snap/registry';\nimport { snapSourcesFor } from 'features/snap/gather';\nimport { sceneSession2d } from 'features/snap/sceneSession2d';\nimport { DEFAULT_SNAP_PX } from 'features/snap/session2d';\nimport type { SnapReadoutDep } from 'features/snap/readoutDep';\nimport { rotationSnapSource } from 'features/snap/rotationSource';\nimport { pathSnapSource } from 'features/paths/pathSnap/pathSnapSource';\nimport type { SnapSource } from 'features/snap/types';\n\ntype Point = { x: number; y: number };\n\n/** What `begin` reads: the scene its probes come from and the sources it asks. */\nexport interface SnapSessionSources {\n  scene: Scene<unknown, string, unknown>;\n  /** The boxes the subject is drawn with, read when a session begins. */\n  boxes: () => DrawnBoxes;\n  /** `<SceneCanvas snap.sources>`, then the presets' `snapSources`. */\n  sources: readonly SnapSource[];\n  /** Sources `useSnapSource` adds, after `sources`. */\n  registry?: SnapSourceRegistry;\n  /** Ids of the canvas's default sources to leave out. */\n  omit?: readonly string[];\n  /** Overrides the kit setting `targets.snapPx`. */\n  reachPx?: number;\n  /** How a node's rotation is read, for angle targets. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n  /** How a pose's origin is read, for the `origin` probe. */\n  originProjection?: OriginProjection<unknown>;\n  /** The canvas's debug sink, read when a session begins: each frame's\n   *  candidates are recorded into it. */\n  debug?: () => DebugSink | null | undefined;\n}\n\n/** The sources every canvas asks after its own, unless `omit` names one:\n *  quarter turns and other nodes' angles for a rotate, and other nodes'\n *  anchors for a point gesture, under `pathSnapSource`'s own id, so a\n *  consumer's `pathSnapSource()` takes its place. */\nconst DEFAULT_SNAP_SOURCES: readonly SnapSource[] = [\n  rotationSnapSource(),\n  { ...pathSnapSource({ only: ['anchor'] }), gestures: ['point'] },\n];\n\n/** `listed`, one source per id (the last one listed, where it stands),\n *  then each default whose id is neither listed nor in `omit`. */\nfunction withDefaults(listed: readonly SnapSource[], omit: readonly string[] = []): SnapSource[] {\n  const last = new Map(listed.map((s, i) => [s.id, i]));\n  const taken = new Set([...last.keys(), ...omit]);\n  return [...listed.filter((s, i) => last.get(s.id) === i), ...DEFAULT_SNAP_SOURCES.filter((s) => !taken.has(s.id))];\n}\n\nexport function useSnapDepSource(\n  viewRef: React.RefObject<View | null>,\n  session: SnapSessionSources,\n  /** The canvas's outcome store, which its readout layer draws. */\n  store: SnapOutcomeStore,\n): SnapOutcomeStore {\n  const sessionRef = useLatest(session);\n  const kitSettings = useKitSettings();\n  useDepSource('snapReadout', (): SnapReadoutDep => ({ store }));\n\n  useDepSource('snap', (): SnapDep => ({\n    begin: (req) => {\n      const s = sessionRef.current;\n      const view = viewRef.current;\n      const sources = withDefaults([...s.sources, ...(s.registry?.list() ?? [])], s.omit);\n      const wantsGeometry = snapSourcesFor(sources, req.gesture).some((src) => src.roles.includes('geometry'));\n      const debug = s.debug?.() ?? undefined;\n      return sceneSession2d({\n        req,\n        scene: s.scene,\n        boxes: s.boxes(),\n        sources,\n        ...(wantsGeometry ? { geometryAt: (press: Point, ids: readonly string[]) => ownGeometryAt(s.scene, press, ids, view?.scale ?? { x: 1, y: 1 }) } : {}),\n        view: () => viewRef.current,\n        reachPx: s.reachPx ?? kitSettings.get('targets.snapPx') ?? DEFAULT_SNAP_PX,\n        ...(s.poseDescriptor ? { poseDescriptor: s.poseDescriptor } : {}),\n        ...(s.originProjection ? { originProjection: s.originProjection } : {}),\n        ...(debug ? { debug } : {}),\n        store,\n      });\n    },\n  }));\n  return store;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqDA,IAAM,uBAA8C,CAClD,mBAAmB,GACnB;CAAE,GAAG,eAAe,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;CAAG,UAAU,CAAC,OAAO;AAAE,CACjE;;;AAIA,SAAS,aAAa,QAA+B,OAA0B,CAAC,GAAiB;CAC/F,MAAM,OAAO,IAAI,IAAI,OAAO,KAAK,GAAG,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;CACpD,MAAM,wBAAQ,IAAI,IAAI,CAAC,GAAG,KAAK,KAAK,GAAG,GAAG,IAAI,CAAC;CAC/C,OAAO,CAAC,GAAG,OAAO,QAAQ,GAAG,MAAM,KAAK,IAAI,EAAE,EAAE,MAAM,CAAC,GAAG,GAAG,qBAAqB,QAAQ,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC,CAAC;AACnH;AAEA,SAAgB,iBACd,SACA,SAEA,OACkB;CAClB,MAAM,aAAa,UAAU,OAAO;CACpC,MAAM,cAAc,eAAe;CACnC,aAAa,sBAAsC,EAAE,MAAM,EAAE;CAE7D,aAAa,eAAwB,EACnC,QAAQ,QAAQ;EACd,MAAM,IAAI,WAAW;EACrB,MAAM,OAAO,QAAQ;EACrB,MAAM,UAAU,aAAa,CAAC,GAAG,EAAE,SAAS,GAAI,EAAE,UAAU,KAAK,KAAK,CAAC,CAAE,GAAG,EAAE,IAAI;EAClF,MAAM,gBAAgB,eAAe,SAAS,IAAI,OAAO,CAAC,CAAC,MAAM,QAAQ,IAAI,MAAM,SAAS,UAAU,CAAC;EACvG,MAAM,QAAQ,EAAE,QAAQ,KAAK;EAC7B,OAAO,eAAe;GACpB;GACA,OAAO,EAAE;GACT,OAAO,EAAE,MAAM;GACf;GACA,GAAI,gBAAgB,EAAE,aAAa,OAAc,QAA2B,cAAc,EAAE,OAAO,OAAO,KAAK,MAAM,SAAS;IAAE,GAAG;IAAG,GAAG;GAAE,CAAC,EAAE,IAAI,CAAC;GACnJ,YAAY,QAAQ;GACpB,SAAS,EAAE,WAAW,YAAY,IAAI,gBAAgB,KAAK;GAC3D,GAAI,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,eAAe,IAAI,CAAC;GAC/D,GAAI,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,IAAI,CAAC;GACrE,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;GACzB;EACF,CAAC;CACH,EACF,EAAE;CACF,OAAO;AACT"}

package/dist/canvas/deps/surface.js

@@ -0,0 +1,30 @@
+import { viewToTransform } from "../../core/viewport/view.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+import { useDepSource, useMenuHost, usePointerContext } from "@weasel-js/routing/react";
+
+//#region src/canvas/deps/surface.ts
+/**
+* `useSurfaceDepSources` — the deps that describe where this canvas sits:
+* the `pointer` context, the surface's `menuHost`, and `worldToClient`, which
+* places DOM (a menu) at a world point.
+*/
+function useSurfaceDepSources(canvasRef, currentViewRef) {
+	const pointer = usePointerContext();
+	useDepSource("pointer", () => pointer ?? void 0);
+	const menuHost = useMenuHost();
+	useDepSource("menuHost", () => menuHost ?? void 0);
+	useDepSource("worldToClient", () => (x, y) => {
+		const el = canvasRef.current;
+		if (!el) return null;
+		const r = el.getBoundingClientRect();
+		const [sx, sy] = worldToScreen(x, y, viewToTransform(currentViewRef.current));
+		return {
+			x: r.left + sx,
+			y: r.top + sy
+		};
+	});
+}
+
+//#endregion
+export { useSurfaceDepSources };
+//# sourceMappingURL=surface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surface.js","names":[],"sources":["../../../src/canvas/deps/surface.ts"],"sourcesContent":["/**\n * `useSurfaceDepSources` — the deps that describe where this canvas sits:\n * the `pointer` context, the surface's `menuHost`, and `worldToClient`, which\n * places DOM (a menu) at a world point.\n */\nimport { useDepSource, useMenuHost, usePointerContext } from '@weasel-js/routing/react';\nimport { viewToTransform, type View } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\n\nexport function useSurfaceDepSources(\n  canvasRef: React.RefObject<HTMLElement | null>,\n  currentViewRef: React.RefObject<View>,\n): void {\n  const pointer = usePointerContext();\n  useDepSource('pointer', () => pointer ?? undefined);\n  const menuHost = useMenuHost();\n  useDepSource('menuHost', () => menuHost ?? undefined);\n  useDepSource('worldToClient', () => (x: number, y: number) => {\n    const el = canvasRef.current;\n    if (!el) return null;\n    const r = el.getBoundingClientRect();\n    const [sx, sy] = worldToScreen(x, y, viewToTransform(currentViewRef.current));\n    return { x: r.left + sx, y: r.top + sy };\n  });\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,qBACd,WACA,gBACM;CACN,MAAM,UAAU,kBAAkB;CAClC,aAAa,iBAAiB,WAAW,MAAS;CAClD,MAAM,WAAW,YAAY;CAC7B,aAAa,kBAAkB,YAAY,MAAS;CACpD,aAAa,wBAAwB,GAAW,MAAc;EAC5D,MAAM,KAAK,UAAU;EACrB,IAAI,CAAC,IAAI,OAAO;EAChB,MAAM,IAAI,GAAG,sBAAsB;EACnC,MAAM,CAAC,IAAI,MAAM,cAAc,GAAG,GAAG,gBAAgB,eAAe,OAAO,CAAC;EAC5E,OAAO;GAAE,GAAG,EAAE,OAAO;GAAI,GAAG,EAAE,MAAM;EAAG;CACzC,CAAC;AACH"}

package/dist/canvas/deps/textEdit.js

@@ -1,22 +1,30 @@
-import { useLatest as e } from "@weasel-js/react";
-import { useDepSource as t } from "@weasel-js/routing/react";
-import { isTextData as n } from "@weasel-js/text";
+import { isDev, useLatest } from "@weasel-js/react";
+import { isTextData } from "@weasel-js/text";
+import { useDepSource } from "@weasel-js/routing/react";
+
 //#region src/canvas/deps/textEdit.ts
-function r(r) {
-	let i = e(r);
-	t("textEdit", () => {
-		let e = i.current;
+/**
+* `useTextEditDepSource` — wires the `textEdit` dep consumed by
+* `enterTextEditAction`. Kit-default implementation is a no-op stub for
+* `startEdit` plus an `isTextNode` that asks `isTextData`. Consumers wanting real text editing override the
+* dep via their own `useDepSource('textEdit', ...)` sourced from a
+* `useSceneTextEdit` instance.
+*/
+function useTextEditDepSource(scene) {
+	const sceneRef = useLatest(scene);
+	useDepSource("textEdit", () => {
+		const sc = sceneRef.current;
 		return {
-			startEdit(e, t) {
-				process.env.NODE_ENV !== "production" && console.warn("weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.");
+			startEdit(_id, _opts) {
+				if (isDev()) console.warn("weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.");
 			},
-			isTextNode(t) {
-				return n(e.get(t)?.data);
+			isTextNode(id) {
+				return isTextData(sc.get(id)?.data);
 			}
 		};
 	});
 }
-//#endregion
-export { r as useTextEditDepSource };
 
+//#endregion
+export { useTextEditDepSource };
 //# sourceMappingURL=textEdit.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"textEdit.js","names":["useTextEditDepSource","sceneRef","useLatest","scene","sc","isTextData","id"],"sources":["../../../src/canvas/deps/textEdit.ts"],"sourcesContent":["/**\n * `useTextEditDepSource` — wires the `textEdit` dep consumed by\n * `enterTextEditAction`. Kit-default implementation is a no-op stub for\n * `startEdit` plus an `isTextNode` that asks `isTextData`. Consumers wanting real text editing override the\n * dep via their own `useDepSource('textEdit', ...)` sourced from a\n * `useSceneTextEdit` instance.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { TextEditDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { isTextData } from '@weasel-js/text';\n\nexport function useTextEditDepSource(\n  scene: Scene<unknown, string, unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n\n  useDepSource('textEdit', (): TextEditDep => {\n    const sc = sceneRef.current;\n    return {\n      startEdit(_id: string, _opts?: { caret?: number | 'all' }) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.warn(\n            'weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. ' +\n            'Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.',\n          );\n        }\n      },\n      isTextNode(id: string) {\n        return isTextData(sc.get(id as NodeId)?.data);\n      },\n    };\n  });\n}\n"],"mappings":";;;;AAaA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK;CAEhC,EAAa,kBAA+B;EAC1C,IAAMC,IAAKH,EAAS;EACpB,OAAO;GACL,UAAU,GAAa,GAAoC;IACzD,AAAA,QAAA,IAAA,aAA6B,gBAC3B,QAAQ,KACN,4LAEF;GAEJ;GACA,WAAW,GAAY;IACrB,OAAOI,EAAWD,EAAG,IAAIE,CAAY,CAAC,EAAE,IAAI;GAC9C;EACF;CACF,CAAC;AACH"}
+{"version":3,"file":"textEdit.js","names":[],"sources":["../../../src/canvas/deps/textEdit.ts"],"sourcesContent":["/**\n * `useTextEditDepSource` — wires the `textEdit` dep consumed by\n * `enterTextEditAction`. Kit-default implementation is a no-op stub for\n * `startEdit` plus an `isTextNode` that asks `isTextData`. Consumers wanting real text editing override the\n * dep via their own `useDepSource('textEdit', ...)` sourced from a\n * `useSceneTextEdit` instance.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest, isDev } from '@weasel-js/react';\nimport type { TextEditDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { isTextData } from '@weasel-js/text';\n\nexport function useTextEditDepSource(\n  scene: Scene<unknown, string, unknown>,\n): void {\n  const sceneRef = useLatest(scene);\n\n  useDepSource('textEdit', (): TextEditDep => {\n    const sc = sceneRef.current;\n    return {\n      startEdit(_id: string, _opts?: { caret?: number | 'all' }) {\n        if (isDev()) {\n          console.warn(\n            'weasel textEditDep: startEdit called but no useTextEdit hook is mounted in SceneCanvas. ' +\n            'Override the \"textEdit\" dep via useDepSource(\"textEdit\", ...) to enable in-place text editing.',\n          );\n        }\n      },\n      isTextNode(id: string) {\n        return isTextData(sc.get(id as NodeId)?.data);\n      },\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,qBACd,OACM;CACN,MAAM,WAAW,UAAU,KAAK;CAEhC,aAAa,kBAA+B;EAC1C,MAAM,KAAK,SAAS;EACpB,OAAO;GACL,UAAU,KAAa,OAAoC;IACzD,IAAI,MAAM,GACR,QAAQ,KACN,4LAEF;GAEJ;GACA,WAAW,IAAY;IACrB,OAAO,WAAW,GAAG,IAAI,EAAY,CAAC,EAAE,IAAI;GAC9C;EACF;CACF,CAAC;AACH"}

package/dist/canvas/deps/view.js

@@ -1,43 +1,55 @@
-import { useMemo as e } from "react";
-import { useLatest as t } from "@weasel-js/react";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/deps/view.ts
-function n(n, r, i, a, o, s, c) {
-	let l = t({
-		currentViewRef: n,
-		onViewChange: r,
-		recenter: i,
-		hostSize: a,
-		animation: o,
-		decay: s,
-		layerIsPainted: c
-	}), u = !!i, d = !!a, f = !!o, p = !!s, m = !!c;
-	return e(() => ({
-		get: () => l.current.currentViewRef.current,
-		set: (e) => {
-			l.current.animation?.stopIfExternal(), l.current.onViewChange(e);
+/**
+* Builds a stable `ViewApi` that reads from `currentViewRef` and writes via
+* `onViewChange`. It does **not** call `useDepSource('view', ...)` itself:
+* `useStandardActions` publishes the `view` dep it is handed.
+*/
+function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize, animation, decay, layerIsPainted) {
+	const wiring = useLatest({
+		currentViewRef,
+		onViewChange,
+		recenter,
+		hostSize,
+		animation,
+		decay,
+		layerIsPainted
+	});
+	const hasRecenter = !!recenter;
+	const hasHostSize = !!hostSize;
+	const hasAnimation = !!animation;
+	const hasDecay = !!decay;
+	const hasLayerIsPainted = !!layerIsPainted;
+	return useMemo(() => ({
+		get: () => wiring.current.currentViewRef.current,
+		set: (v) => {
+			wiring.current.animation?.stopIfExternal();
+			wiring.current.onViewChange(v);
 		},
-		...u ? { recenter: () => l.current.recenter() } : {},
-		...d ? { hostSize: () => l.current.hostSize() } : {},
-		...f ? {
-			animate: (e, t) => l.current.animation.animate(e, t),
-			stopAnimation: () => l.current.animation.stop(),
-			animationTarget: () => l.current.animation.target()
+		...hasRecenter ? { recenter: () => wiring.current.recenter() } : {},
+		...hasHostSize ? { hostSize: () => wiring.current.hostSize() } : {},
+		...hasAnimation ? {
+			animate: (to, opts) => wiring.current.animation.animate(to, opts),
+			stopAnimation: () => wiring.current.animation.stop(),
+			animationTarget: () => wiring.current.animation.target()
 		} : {},
-		...p ? {
-			decay: (e) => l.current.decay.start(e),
-			stopDecay: () => l.current.decay.cancel()
+		...hasDecay ? {
+			decay: (config) => wiring.current.decay.start(config),
+			stopDecay: () => wiring.current.decay.cancel()
 		} : {},
-		...m ? { layerIsPainted: (e) => l.current.layerIsPainted(e) } : {}
+		...hasLayerIsPainted ? { layerIsPainted: (layerId) => wiring.current.layerIsPainted(layerId) } : {}
 	}), [
-		l,
-		u,
-		d,
-		f,
-		p,
-		m
+		wiring,
+		hasRecenter,
+		hasHostSize,
+		hasAnimation,
+		hasDecay,
+		hasLayerIsPainted
 	]);
 }
-//#endregion
-export { n as useViewDepSource };
 
+//#endregion
+export { useViewDepSource };
 //# sourceMappingURL=view.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":["useViewDepSource","wiring","useLatest","hasRecenter","recenter","hasHostSize","hostSize","hasAnimation","animation","hasDecay","decay","hasLayerIsPainted","layerIsPainted","useMemo","v","to","opts","config","layerId"],"sources":["../../../src/canvas/deps/view.ts"],"sourcesContent":["/**\n * Builds a stable `ViewApi` that reads from `currentViewRef` and writes via\n * `onViewChange`. It does **not** call `useDepSource('view', ...)` itself:\n * `useStandardActions` publishes the `view` dep it is handed.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type React from 'react';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { DecayLoopConfig } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\n\ninterface Wiring {\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  recenter?: () => View | void;\n  hostSize?: () => { width: number; height: number } | null;\n  animation?: ViewAnimationApi;\n  decay?: DecayApi;\n  layerIsPainted?: (layerId: string) => boolean;\n}\n\n/** The slice of `useDecayLoop` the view dep republishes. */\nexport interface DecayApi {\n  start(config: DecayLoopConfig): void;\n  cancel(): void;\n}\n\nexport function useViewDepSource(\n  currentViewRef: React.RefObject<View>,\n  onViewChange: (v: View) => void,\n  recenter?: () => View | void,\n  hostSize?: () => { width: number; height: number } | null,\n  animation?: ViewAnimationApi,\n  decay?: DecayApi,\n  layerIsPainted?: (layerId: string) => boolean,\n): ViewApi {\n  // Every method reads through this, so the latest onViewChange / recenter /\n  // runner is captured without the API object itself changing identity.\n  const wiring = useLatest<Wiring>({\n    currentViewRef, onViewChange, recenter, hostSize, animation, decay, layerIsPainted,\n  });\n\n  // An unwired optional member must read falsy — `viewportZoomAction` branches\n  // on `view.recenter`, and a forwarder is truthy — so the identity-stable API\n  // is rebuilt whenever that presence set changes.\n  const hasRecenter = !!recenter;\n  const hasHostSize = !!hostSize;\n  const hasAnimation = !!animation;\n  const hasDecay = !!decay;\n  const hasLayerIsPainted = !!layerIsPainted;\n  return useMemo((): ViewApi => ({\n    get: () => wiring.current.currentViewRef.current,\n    // Not the canvas's only cancel feed (`onViewChange` is), but a `view` dep\n    // wired to something other than a `<SceneCanvas>` has only this one.\n    set: (v: View) => {\n      wiring.current.animation?.stopIfExternal();\n      wiring.current.onViewChange(v);\n    },\n    ...(hasRecenter ? { recenter: () => wiring.current.recenter!() } : {}),\n    ...(hasHostSize ? { hostSize: () => wiring.current.hostSize!() } : {}),\n    ...(hasAnimation\n      ? {\n          animate: (to: View, opts?: Parameters<ViewAnimationApi['animate']>[1]) =>\n            wiring.current.animation!.animate(to, opts),\n          stopAnimation: () => wiring.current.animation!.stop(),\n          animationTarget: () => wiring.current.animation!.target(),\n        }\n      : {}),\n    ...(hasDecay\n      ? {\n          decay: (config: DecayLoopConfig) => wiring.current.decay!.start(config),\n          stopDecay: () => wiring.current.decay!.cancel(),\n        }\n      : {}),\n    ...(hasLayerIsPainted\n      ? { layerIsPainted: (layerId: string) => wiring.current.layerIsPainted!(layerId) }\n      : {}),\n  }), [wiring, hasRecenter, hasHostSize, hasAnimation, hasDecay, hasLayerIsPainted]);\n}\n"],"mappings":";;;AA6BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CAGT,IAAMC,IAASC,EAAkB;EAC/B;EAAgB;EAAc;EAAU;EAAU;EAAW;EAAO;CACtE,CAAC,GAKKC,IAAc,CAAC,CAACC,GAChBC,IAAc,CAAC,CAACC,GAChBC,IAAe,CAAC,CAACC,GACjBC,IAAW,CAAC,CAACC,GACbC,IAAoB,CAAC,CAACC;CAC5B,OAAOC,SAAwB;EAC7B,WAAWZ,EAAO,QAAQ,eAAe;EAGzC,MAAM,MAAY;GAEhB,AADAA,EAAO,QAAQ,WAAW,eAAe,GACzCA,EAAO,QAAQ,aAAaa,CAAC;EAC/B;EACA,GAAIX,IAAc,EAAE,gBAAgBF,EAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAII,IAAc,EAAE,gBAAgBJ,EAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAIM,IACA;GACE,UAAU,GAAU,MAClBN,EAAO,QAAQ,UAAW,QAAQc,GAAIC,CAAI;GAC5C,qBAAqBf,EAAO,QAAQ,UAAW,KAAK;GACpD,uBAAuBA,EAAO,QAAQ,UAAW,OAAO;EAC1D,IACA,CAAC;EACL,GAAIQ,IACA;GACE,QAAQ,MAA4BR,EAAO,QAAQ,MAAO,MAAMgB,CAAM;GACtE,iBAAiBhB,EAAO,QAAQ,MAAO,OAAO;EAChD,IACA,CAAC;EACL,GAAIU,IACA,EAAE,iBAAiB,MAAoBV,EAAO,QAAQ,eAAgBiB,CAAO,EAAE,IAC/E,CAAC;CACP,IAAI;EAACjB;EAAQE;EAAaE;EAAaE;EAAcE;EAAUE;CAAiB,CAAC;AACnF"}
+{"version":3,"file":"view.js","names":[],"sources":["../../../src/canvas/deps/view.ts"],"sourcesContent":["/**\n * Builds a stable `ViewApi` that reads from `currentViewRef` and writes via\n * `onViewChange`. It does **not** call `useDepSource('view', ...)` itself:\n * `useStandardActions` publishes the `view` dep it is handed.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type React from 'react';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { DecayLoopConfig } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\n\ninterface Wiring {\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  recenter?: () => View | void;\n  hostSize?: () => { width: number; height: number } | null;\n  animation?: ViewAnimationApi;\n  decay?: DecayApi;\n  layerIsPainted?: (layerId: string) => boolean;\n}\n\n/** The slice of `useDecayLoop` the view dep republishes. */\nexport interface DecayApi {\n  start(config: DecayLoopConfig): void;\n  cancel(): void;\n}\n\nexport function useViewDepSource(\n  currentViewRef: React.RefObject<View>,\n  onViewChange: (v: View) => void,\n  recenter?: () => View | void,\n  hostSize?: () => { width: number; height: number } | null,\n  animation?: ViewAnimationApi,\n  decay?: DecayApi,\n  layerIsPainted?: (layerId: string) => boolean,\n): ViewApi {\n  // Every method reads through this, so the latest onViewChange / recenter /\n  // runner is captured without the API object itself changing identity.\n  const wiring = useLatest<Wiring>({\n    currentViewRef, onViewChange, recenter, hostSize, animation, decay, layerIsPainted,\n  });\n\n  // An unwired optional member must read falsy — `viewportZoomAction` branches\n  // on `view.recenter`, and a forwarder is truthy — so the identity-stable API\n  // is rebuilt whenever that presence set changes.\n  const hasRecenter = !!recenter;\n  const hasHostSize = !!hostSize;\n  const hasAnimation = !!animation;\n  const hasDecay = !!decay;\n  const hasLayerIsPainted = !!layerIsPainted;\n  return useMemo((): ViewApi => ({\n    get: () => wiring.current.currentViewRef.current,\n    // Not the canvas's only cancel feed (`onViewChange` is), but a `view` dep\n    // wired to something other than a `<SceneCanvas>` has only this one.\n    set: (v: View) => {\n      wiring.current.animation?.stopIfExternal();\n      wiring.current.onViewChange(v);\n    },\n    ...(hasRecenter ? { recenter: () => wiring.current.recenter!() } : {}),\n    ...(hasHostSize ? { hostSize: () => wiring.current.hostSize!() } : {}),\n    ...(hasAnimation\n      ? {\n          animate: (to: View, opts?: Parameters<ViewAnimationApi['animate']>[1]) =>\n            wiring.current.animation!.animate(to, opts),\n          stopAnimation: () => wiring.current.animation!.stop(),\n          animationTarget: () => wiring.current.animation!.target(),\n        }\n      : {}),\n    ...(hasDecay\n      ? {\n          decay: (config: DecayLoopConfig) => wiring.current.decay!.start(config),\n          stopDecay: () => wiring.current.decay!.cancel(),\n        }\n      : {}),\n    ...(hasLayerIsPainted\n      ? { layerIsPainted: (layerId: string) => wiring.current.layerIsPainted!(layerId) }\n      : {}),\n  }), [wiring, hasRecenter, hasHostSize, hasAnimation, hasDecay, hasLayerIsPainted]);\n}\n"],"mappings":";;;;;;;;;AA6BA,SAAgB,iBACd,gBACA,cACA,UACA,UACA,WACA,OACA,gBACS;CAGT,MAAM,SAAS,UAAkB;EAC/B;EAAgB;EAAc;EAAU;EAAU;EAAW;EAAO;CACtE,CAAC;CAKD,MAAM,cAAc,CAAC,CAAC;CACtB,MAAM,cAAc,CAAC,CAAC;CACtB,MAAM,eAAe,CAAC,CAAC;CACvB,MAAM,WAAW,CAAC,CAAC;CACnB,MAAM,oBAAoB,CAAC,CAAC;CAC5B,OAAO,eAAwB;EAC7B,WAAW,OAAO,QAAQ,eAAe;EAGzC,MAAM,MAAY;GAChB,OAAO,QAAQ,WAAW,eAAe;GACzC,OAAO,QAAQ,aAAa,CAAC;EAC/B;EACA,GAAI,cAAc,EAAE,gBAAgB,OAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAI,cAAc,EAAE,gBAAgB,OAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAI,eACA;GACE,UAAU,IAAU,SAClB,OAAO,QAAQ,UAAW,QAAQ,IAAI,IAAI;GAC5C,qBAAqB,OAAO,QAAQ,UAAW,KAAK;GACpD,uBAAuB,OAAO,QAAQ,UAAW,OAAO;EAC1D,IACA,CAAC;EACL,GAAI,WACA;GACE,QAAQ,WAA4B,OAAO,QAAQ,MAAO,MAAM,MAAM;GACtE,iBAAiB,OAAO,QAAQ,MAAO,OAAO;EAChD,IACA,CAAC;EACL,GAAI,oBACA,EAAE,iBAAiB,YAAoB,OAAO,QAAQ,eAAgB,OAAO,EAAE,IAC/E,CAAC;CACP,IAAI;EAAC;EAAQ;EAAa;EAAa;EAAc;EAAU;CAAiB,CAAC;AACnF"}

package/dist/canvas/derivedPath.js

@@ -1,96 +1,180 @@
-import { composeWorldPose as e, composesFrames as t } from "../core/scene/composeFrame.js";
-import { createNodeMemoScope as n } from "../core/scene/nodeMemo.js";
-import { resolveDerivedPath as r } from "../core/scene/derivedPath.js";
-import { definesFrame as i, derivedDepOf as a, effectivePose as o } from "../core/scene/effectivePose.js";
-import { isRectPose as s } from "../core/geometry/autoPoseDescriptor.js";
-import { asNodeId as c } from "../core/scene/types.js";
-import { boxToBox as l, transformPath as u } from "@weasel-js/geom";
+import { composeWorldPose, composesFrames } from "../core/scene/composeFrame.js";
+import { carryBoxPath, carryPathBy, pathAsPainted } from "../core/scene/depFrame.js";
+import { createNodeMemoScope } from "../core/scene/nodeMemo.js";
+import { resolveDerivedPath } from "../core/scene/derivedPath.js";
+import { definesFrame, derivedDepOf, effectivePose } from "../core/scene/effectivePose.js";
+import { asNodeId } from "../core/scene/types.js";
+import { multiply, poseFrameInverseOf, poseFrameOf } from "@weasel-js/geom";
+
 //#region src/canvas/derivedPath.ts
-function d(e, t) {
-	let n = o(e, t);
-	return n === t.pose ? t : {
-		...t,
-		pose: n
+/** `node` as the scene shows it, its `pose` an override's or a derived one: the stored node
+*  itself where the two agree. */
+function shownNode(scene, node) {
+	const pose = effectivePose(scene, node);
+	return pose === node.pose ? node : {
+		...node,
+		pose
 	};
 }
-function f(e, t) {
-	return (n) => t(d(e, n));
-}
-function p(e, t, n) {
-	return !s(t) || !s(n) || t.x === n.x && t.y === n.y && t.width === n.width && t.height === n.height ? e : u(e, l(t.x, t.y, t.width, t.height, n.x, n.y, n.width, n.height));
+/** A slot's `toPose`, handed each node as the scene shows it, so a view drawn through one
+*  shows a drag in flight and a rig's motion as every other view does. */
+function sceneShownToPose(scene, toPose) {
+	return (node) => toPose(shownNode(scene, node));
 }
-function m(e, t) {
-	return t === void 0 ? (t) => e.overrides.read(t.id)?.path : (n) => {
-		let r = e.overrides.read(n.id)?.path;
-		if (r === void 0) return;
-		let i = d(e, n);
-		return p(r, i.pose, t(i));
+/**
+* `(node) => the path its pose override shows it by`, in the frame the reader paints in: as
+* the override has it, or under a `toPose` carried from the box the scene shows the node at
+* to the box `toPose` answers.
+*/
+function sceneOverridePathOf(scene, toPose) {
+	if (toPose === void 0) return (node) => scene.overrides.read(node.id)?.path;
+	return (node) => {
+		const path = scene.overrides.read(node.id)?.path;
+		if (path === void 0) return void 0;
+		const shown = shownNode(scene, node);
+		return carryBoxPath(path, shown.pose, toPose(shown));
 	};
 }
-function h(n, r) {
-	let a = r ? f(n, r) : (e) => o(n, e);
-	if (!t(n.composition)) return a;
-	let s = {
-		getPose: (e) => {
-			let t = n.get(c(e));
-			return t ? a(t) : void 0;
+/**
+* `(node) => the pose it is painted at`: the slot's `toPose` of the node as the scene shows
+* it if it has one, else the scene's effective pose, folded through the parent chain when
+* the scene's composition makes a stored pose local to its container.
+*/
+function scenePaintedPoseOf(scene, toPose) {
+	const local = toPose ? sceneShownToPose(scene, toPose) : (node) => effectivePose(scene, node);
+	if (!composesFrames(scene.composition)) return local;
+	const chain = {
+		getPose: (id) => {
+			const n = scene.get(asNodeId(id));
+			return n ? local(n) : void 0;
 		},
-		getParent: (e) => n.get(c(e))?.parent ?? null,
-		definesFrame: (e) => {
-			let t = n.get(c(e));
-			return t === void 0 || i(t);
+		getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
+		definesFrame: (id) => {
+			const n = scene.get(asNodeId(id));
+			return n === void 0 || definesFrame(n);
 		}
 	};
-	return (t) => e(s, t.id, n.composition.compose);
+	return (node) => composeWorldPose(chain, node.id, scene.composition.compose);
 }
-function g(e, n) {
-	let r = x(n, t(e.composition));
-	if (r === void 0) return (t) => a(e, t);
-	let i = {
-		at: h(e, n),
-		slot: r,
-		shown: m(e, n),
-		childrenOf: (t) => e.childrenOf(t),
-		lookup: (t) => {
-			let n = e.get(t);
-			return n === void 0 ? void 0 : new _(n, i);
+/**
+* `(id) => that node, the pose it is painted at, and the path it derives` —
+* resolved against the scene, so a dependency that is itself derived resolves
+* before it is read.
+*
+* A derived edge is drawn from these coordinates and must meet the nodes it
+* connects, so this reads the pose each one is painted at: see
+* {@link scenePaintedPoseOf}.
+*/
+function sceneDepLookup(scene, toPose) {
+	const slot = memoSlotFor(toPose, composesFrames(scene.composition));
+	if (slot === void 0) return (id) => derivedDepOf(scene, id);
+	const ctx = {
+		at: scenePaintedPoseOf(scene, toPose),
+		local: toPose ? sceneShownToPose(scene, toPose) : (node) => effectivePose(scene, node),
+		slot,
+		shown: sceneOverridePathOf(scene, toPose),
+		childrenOf: (id) => scene.childrenOf(id),
+		lookup: (id) => {
+			const node = scene.get(id);
+			return node === void 0 ? void 0 : new SlotDep(node, ctx);
 		}
 	};
-	return i.lookup;
+	return ctx.lookup;
 }
-var _ = class {
+/** A class, not an object literal with a `get path()` — see `SceneDep` in
+*  `core/scene/effectivePose.ts` for why. */
+var SlotDep = class {
 	ctx;
 	node;
 	pose;
-	constructor(e, t) {
-		this.ctx = t, this.node = e, this.pose = t.at(e);
+	constructor(posed, ctx) {
+		this.ctx = ctx;
+		this.node = posed;
+		this.pose = ctx.at(posed);
 	}
 	get path() {
-		return this.ctx.shown(this.node) ?? r(this.node, this.ctx.lookup, this.ctx.childrenOf, this.ctx.slot);
+		const shown = this.ctx.shown(this.node);
+		if (shown !== void 0) return pathAsPainted(shown, this.ctx.local(this.node), this.pose);
+		return resolveDerivedPath(this.node, this.ctx.lookup, this.ctx.childrenOf, this.ctx.slot);
 	}
 };
-function v(e, t) {
-	return t.dependsOn !== void 0 || e.overrides.read(t.id)?.path !== void 0;
+/** Whether something outside `node`'s data says what path it shows: it derives one, or a
+*  pose override carries one. The gate both scene walks check before resolving a path. */
+function showsComputedPath(scene, node) {
+	return node.dependsOn !== void 0 || scene.overrides.read(node.id)?.path !== void 0;
 }
-function y(e, n) {
-	let i = g(e, n), a = x(n, t(e.composition)), o = (t) => e.childrenOf(t), s = (e) => r(e, i, o, a), c = m(e, n);
-	return (e) => c(e) ?? s(e);
+/**
+* `(node) => the path it shows in place of its data's`: a pose override's `path`, else the
+* one it derives, read through {@link sceneDepLookup}. A reader painting through a `toPose`
+* is answered the override's path carried into the box its `toPose` answers.
+*/
+function sceneDerivedPathOf(scene, toPose) {
+	const depOf = sceneDepLookup(scene, toPose);
+	const slot = memoSlotFor(toPose, composesFrames(scene.composition));
+	const childrenOf = (id) => scene.childrenOf(id);
+	const derived = (node) => resolveDerivedPath(node, depOf, childrenOf, slot);
+	const overridePathOf = sceneOverridePathOf(scene, toPose);
+	return (node) => overridePathOf(node) ?? derived(node);
 }
-var b = /* @__PURE__ */ new WeakMap();
-function x(e, t) {
-	let r = t ? "world" : "local";
-	if (e === void 0) return r === "world" ? "kit:derivedPath:world" : void 0;
-	let i = b.get(e);
-	return i === void 0 && (i = {}, b.set(e, i)), i[r] ??= n();
+var toPoseScopes = /* @__PURE__ */ new WeakMap();
+/** Where one way of reading poses memoizes its paths, or `undefined` for the
+*  scene's own slot: two readers painting one scene at different poses must
+*  not serve each other's paths. Every reader composing stored poses shares a
+*  slot; a `toPose` gets a scope that is collected with the function. */
+function memoSlotFor(toPose, composes) {
+	const frame = composes ? "world" : "local";
+	if (toPose === void 0) return frame === "world" ? "kit:derivedPath:world" : void 0;
+	let scopes = toPoseScopes.get(toPose);
+	if (scopes === void 0) {
+		scopes = {};
+		toPoseScopes.set(toPose, scopes);
+	}
+	return scopes[frame] ??= createNodeMemoScope();
 }
-function S(e, t, n) {
-	let r = y(e, n);
-	return (n, i, a, o) => v(e, n) ? t(n, i, a, {
-		...o,
-		derivedPath: r(n)
-	}) : t(n, i, a, o);
+/**
+* Wrap a `drawOne` so a node that derives its geometry, or whose pose override
+* carries a path, arrives at the painter with the resolved path. The painter has no scene handle and so cannot read
+* the dependencies' poses itself; both scene walks wrap here instead.
+*
+* A node that derives nothing passes the caller's `ctx` through untouched —
+* this runs per node per frame, and an added `{ derivedPath: null }` would be
+* an allocation per node for a field no painter reads.
+*/
+function withDerivedPaths(scene, drawOne, toPose) {
+	const derivedPathOf = sceneDerivedPathOf(scene, toPose);
+	const ownPoseOf = composesFrames(scene.composition) ? toPose ? sceneShownToPose(scene, toPose) : (node) => effectivePose(scene, node) : null;
+	return (node, pose, view, ctx) => {
+		if (!showsComputedPath(scene, node)) return drawOne(node, pose, view, ctx);
+		let path = derivedPathOf(node);
+		if (path !== null && ownPoseOf !== null && scene.overrides.read(node.id)?.path === void 0) path = withoutInheritedFrame(path, pose, ownPoseOf(node));
+		return drawOne(node, pose, view, {
+			...ctx,
+			derivedPath: path
+		});
+	};
+}
+/**
+* A derived path is drawn from its dependencies' painted poses, so it is already where it
+* shows; but the pose rotation the walk wraps every node in is `painted`'s, which carries its
+* containers' turns as well as its own. Carried back through what the containers add, the
+* wrap turns it by its own frame alone, as it does a root's.
+*/
+function withoutInheritedFrame(path, painted, own) {
+	const undo = poseFrameInverseOf(painted);
+	if (undo === null) return path;
+	const box = painted;
+	const o = own;
+	const redo = poseFrameOf({
+		x: box.x,
+		y: box.y,
+		width: box.width,
+		height: box.height,
+		rotation: o?.rotation,
+		transform: o?.transform
+	});
+	return carryPathBy(path, redo === null ? undo : multiply(undo, redo));
 }
-//#endregion
-export { r as resolveDerivedPath, g as sceneDepLookup, y as sceneDerivedPathOf, h as scenePaintedPoseOf, f as sceneShownToPose, v as showsComputedPath, S as withDerivedPaths };
 
+//#endregion
+export { resolveDerivedPath, sceneDepLookup, sceneDerivedPathOf, scenePaintedPoseOf, sceneShownToPose, showsComputedPath, withDerivedPaths };
 //# sourceMappingURL=derivedPath.js.map