@weasel-js/core 1.6.1 → 1.7.1

package/dist/canvas/affordanceAt.js

@@ -0,0 +1,63 @@
+import { targetSizesPx as e } from "../core/device/targets.js";
+import { hitAffordanceRegions as t } from "../affordances/hitAffordanceRegions.js";
+import { createCornerResizeAffordance as n } from "../affordances/cornerResize.js";
+import { createRotationAffordance as r } from "../affordances/rotationHandle.js";
+import { createPathAnchorAffordances as i } from "../affordances/pathAnchors.js";
+//#region src/canvas/affordanceAt.ts
+function a(t = {}) {
+	let a = e(t.targetScale), { handleHitRadius: o = a.handle, anchorHitRadius: s = a.anchor, rotateBandPx: c = a.rotationDistance, getAnchorState: l, rotationBadge: u } = t;
+	return [
+		r({
+			bandPx: c,
+			paint: null,
+			...u ? { handle: {
+				distancePx: u.distancePx,
+				hitRadiusPx: u.sizePx
+			} } : {}
+		}),
+		n({ handleHitRadius: o }),
+		...l ? i(l, { hitRadius: s }) : []
+	];
+}
+function o(e, t) {
+	return () => {
+		let n = e()?.get("editAnchors");
+		return n ? {
+			editingId: n.editingId ?? null,
+			getPose: (e) => t ? t(e, n.getEditablePath(e)) : n.getEditablePath(e)
+		} : null;
+	};
+}
+function s(e) {
+	let { getChromeState: n, getView: r, getIsVisible: i } = e, o = e.affordances ?? a(e);
+	return function({ x: e, y: a }) {
+		let s = t(o, e, a, n(), r(), i?.());
+		return s ? c(s) : null;
+	};
+}
+function c(e) {
+	let t = e.binding.initialScratch ?? {};
+	return {
+		kind: e.region.hitKind ?? `${e.affordanceId}:${e.regionId}`,
+		owner: e.affordanceId,
+		strength: "shared",
+		...t.targetId === void 0 ? {} : { targetIds: [t.targetId] },
+		...t.anchor === void 0 ? {} : { anchor: t.anchor },
+		...t.fixedPoint === void 0 ? {} : { fixedPoint: t.fixedPoint },
+		...e.region.cursor === void 0 ? {} : { cursor: e.region.cursor },
+		...e.binding.initialScratch === void 0 ? {} : { payload: e.binding.initialScratch }
+	};
+}
+function l(e, t, n) {
+	return function({ x: r, y: i }) {
+		let a = t(r, i);
+		return a ? {
+			body: e().includes(a) ? "selected-body" : "unselected-body",
+			kind: n?.(a)
+		} : { body: "empty" };
+	};
+}
+//#endregion
+export { o as anchorStateFrom, s as buildAffordanceAt, l as buildClassifyTarget, a as chromeAffordances };
+
+//# sourceMappingURL=affordanceAt.js.map

package/dist/canvas/affordanceAt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"affordanceAt.js","names":["chromeAffordances","sizes","targetSizesPx","opts","createRotationAffordance","rotateBandPx","rotationBadge","createCornerResizeAffordance","getAnchorState","createPathAnchorAffordances","anchorHitRadius","anchorStateFrom","dep","getRegistry","toCamera","id","buildAffordanceAt","affordances","wx","wy","hit","hitAffordanceRegions","getChromeState","getView","getIsVisible","toAffordanceHit","scratch","buildClassifyTarget","hitId","pickBest","getSelection","kindOfNode"],"sources":["../../src/canvas/affordanceAt.ts"],"sourcesContent":["/**\n * affordanceAt — the dispatcher-side affordance classifier.\n *\n * Answers \"what piece of selection chrome is under this world point?\" and\n * returns an `AffordanceHit`, which `GestureDispatcherMounter` packs onto\n * `InputEvent.pointerdown.affordance` so `resizeAction` / `rotateAction` /\n * `editAnchorsAction` can guard on affordance kind, and which the hover-cursor\n * pump reads `cursor` off of.\n *\n * It used to answer that question with its own geometry: its own corner\n * table, its own rotate-ring ellipse, its own anchor walk — all duplicating\n * the `Affordance` region declarations in `src/affordances/`, which had a\n * hit-tester of their own that nothing reached for kit chrome. Two\n * implementations of one question, and the declarative one was the dead\n * branch, which is why `AffordanceRegion.cursor` could be declared and set\n * and never consumed.\n *\n * Now this assembles the kit's affordances and runs the one shared walk\n * (`hitAffordanceRegions`). What remains here is the assembly and the\n * region-hit → `AffordanceHit` mapping.\n */\n\nimport type { BodyClassification } from '@weasel-js/gestures';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { View } from 'core/viewport/view';\nimport type { AffordanceHit } from '@weasel-js/routing';\nimport type { Affordance, CommonAffordanceScratch } from 'affordances/types';\nimport { hitAffordanceRegions, type AffordanceRegionHit } from 'affordances/hitAffordanceRegions';\nimport { createCornerResizeAffordance } from 'affordances/cornerResize';\nimport { createRotationAffordance } from 'affordances/rotationHandle';\nimport { createPathAnchorAffordances, type AnchorState } from 'affordances/pathAnchors';\nimport { targetSizesPx } from 'core/device/targets';\n\nexport type { AnchorState };\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/** What decides the kit's chrome affordances — their sizes and which ones\n *  exist. Shared by the hit-test and the slops overlay, which draws them. */\nexport interface ChromeAffordanceOptions {\n  /** Pointer-size multiplier from the live `DeviceProfile`. Every default\n   *  below is resolved through {@link targetSizesPx} at this scale, so the\n   *  grab zone tracks the painted chrome on a coarse pointer. Default 1. */\n  targetScale?: number;\n  /** Corner-handle hit radius in screen px. Overrides the device-scaled default. */\n  handleHitRadius?: number;\n  /** Anchor / control hit radius in screen px. Overrides the device-scaled default. */\n  anchorHitRadius?: number;\n  /** Minimum rotate-band thickness outside the selection AABB, in screen px.\n   *  Overrides the device-scaled default. */\n  rotateBandPx?: number;\n  /** The rotate badge the selection overlay paints (`rotationBadgeOf`), so\n   *  it can be grabbed where it is drawn. Omitted or null, only the rotate\n   *  ring is hit-tested. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Anchor-editing state. When omitted, anchors aren't hit-tested. */\n  getAnchorState?: () => AnchorState | null;\n}\n\nexport interface BuildAffordanceAtOptions extends ChromeAffordanceOptions {\n  /** Live ChromeState at call time — current selection plus effective bounds,\n   *  including in-flight move/resize ghost poses. */\n  getChromeState: () => ChromeState;\n  /** Live view. Needed because region hit radii and the rotate band are\n   *  declared in screen pixels and resolved against the current scale. */\n  getView: () => View;\n  /** The affordances to walk, when the caller built them itself to share\n   *  them (`chromeAffordances`). Otherwise built from these options. */\n  affordances?: readonly Affordance[];\n  /** Chrome-caps resolver. Keeps the hit-test and the renderer agreeing on\n   *  which chrome is live (resize handles gated by\n   *  `'selection.resize-handles'`, rotation by `'selection.rotation-handle'`,\n   *  anchors by `'path-edit.anchors'`). Omitting defaults to always-visible. */\n  getIsVisible?: () => (id: string) => boolean;\n}\n\n/**\n * The kit's selection chrome as affordances, bottom → top: rotate ring (and\n * badge), corner handles, then anchors and their controls — a corner handle\n * beats the rotate band it sits inside, and a control handle beats everything.\n */\nexport function chromeAffordances(opts: ChromeAffordanceOptions = {}): Affordance[] {\n  const sizes = targetSizesPx(opts.targetScale);\n  const {\n    handleHitRadius = sizes.handle,\n    anchorHitRadius = sizes.anchor,\n    rotateBandPx = sizes.rotationDistance,\n    getAnchorState,\n    rotationBadge,\n  } = opts;\n  return [\n    createRotationAffordance({\n      bandPx: rotateBandPx,\n      paint: null,\n      ...(rotationBadge\n        ? { handle: { distancePx: rotationBadge.distancePx, hitRadiusPx: rotationBadge.sizePx } }\n        : {}),\n    }),\n    createCornerResizeAffordance({ handleHitRadius }),\n    ...(getAnchorState\n      ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius })\n      : []),\n  ];\n}\n\n/**\n * Read anchor-editing state off a dep registry, for\n * {@link BuildAffordanceAtOpts.getAnchorState}. Returns `null` while no\n * `editAnchors` dep is registered — nothing is in anchor-edit mode, so\n * anchors are not hit-tested.\n */\nexport function anchorStateFrom(\n  getRegistry: () => { get(name: 'editAnchors'): EditAnchorsDep | undefined } | null,\n  /** The editable path in the world the hit-test is asked in. A node on a\n   *  parallax plane stores its path in the plane's world; the surface carries\n   *  it into the asking camera's. Default: unchanged. */\n  toCamera?: (id: string, path: unknown) => unknown,\n): () => AnchorState | null {\n  return () => {\n    const dep = getRegistry()?.get('editAnchors');\n    if (!dep) return null;\n    return {\n      editingId: dep.editingId ?? null,\n      // The hit-test reads world-coord anchor positions, so route through\n      // `getEditablePath`: both pose-as-polygon and `data.path` consumers\n      // resolve correctly.\n      getPose: (id) => (toCamera ? toCamera(id, dep.getEditablePath(id)) : dep.getEditablePath(id)),\n    };\n  };\n}\n\n/**\n * Build the `affordanceAt` thunk for `GestureDispatcherMounter`.\n *\n * Returns `(worldPoint) => AffordanceHit | null`. The point is **world-space**;\n * callers convert from client coords first.\n *\n * Priority runs anchors → controls → resize handles → rotate ring, top to\n * bottom, matching how the chrome paints: a corner handle beats the rotate\n * band it sits inside, and a control handle beats everything.\n */\nexport function buildAffordanceAt(\n  opts: BuildAffordanceAtOptions,\n): (worldPoint: { x: number; y: number }) => AffordanceHit | null {\n  const { getChromeState, getView, getIsVisible } = opts;\n  const affordances = opts.affordances ?? chromeAffordances(opts);\n\n  return function affordanceAt({ x: wx, y: wy }) {\n    const hit = hitAffordanceRegions(\n      affordances,\n      wx,\n      wy,\n      getChromeState(),\n      getView(),\n      getIsVisible?.(),\n    );\n    return hit ? toAffordanceHit(hit) : null;\n  };\n}\n\n/**\n * Region hit → `AffordanceHit`.\n *\n * `hitKind` is the routing discriminator; the handful of scratch fields named\n * by {@link CommonAffordanceScratch} are lifted onto the hit because the\n * actions that consume them read them there. Everything else in scratch rides\n * along untouched as `payload`.\n */\nfunction toAffordanceHit(hit: AffordanceRegionHit): AffordanceHit {\n  const scratch = (hit.binding.initialScratch ?? {}) as CommonAffordanceScratch;\n  return {\n    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,\n    owner: hit.affordanceId,\n    strength: 'shared',\n    ...(scratch.targetId !== undefined ? { targetIds: [scratch.targetId] } : {}),\n    ...(scratch.anchor !== undefined ? { anchor: scratch.anchor } : {}),\n    ...(scratch.fixedPoint !== undefined ? { fixedPoint: scratch.fixedPoint } : {}),\n    ...(hit.region.cursor !== undefined ? { cursor: hit.region.cursor } : {}),\n    ...(hit.binding.initialScratch !== undefined ? { payload: hit.binding.initialScratch } : {}),\n  } as AffordanceHit;\n}\n\n// ---------------------------------------------------------------------------\n// classifyTarget helper\n// ---------------------------------------------------------------------------\n\n/**\n * Classify a world-space point against the current selection:\n * - `'empty'`: no scene body hit.\n * - `'selected-body'`: hit a node that is currently selected.\n * - `'unselected-body'`: hit a node that is NOT selected.\n *\n * The caller supplies the hit-test function (already wired from\n * `useSceneSelectTool.pickEvery`).\n *\n * @param kindOfNode - Optional resolver from a hit node id to its semantic\n *   kind. `<SceneCanvas>` defaults it to the `data.kind` convention the kit\n *   already reads in `deps/textEdit` and the shape-tool inserts; consumers\n *   whose nodes name their kind elsewhere override it. Omitting it leaves\n *   `kind` undefined, which makes every `kind:` TargetSpec form no-match.\n */\nexport function buildClassifyTarget(\n  getSelection: () => readonly string[],\n  pickBest: (wx: number, wy: number) => string | null,\n  kindOfNode?: (id: string) => string | undefined,\n): (worldPoint: { x: number; y: number }) => BodyClassification {\n  return function classifyTarget({ x: wx, y: wy }) {\n    const hitId = pickBest(wx, wy);\n    if (!hitId) return { body: 'empty' };\n    const sel = getSelection();\n    return {\n      body: sel.includes(hitId) ? 'selected-body' : 'unselected-body',\n      kind: kindOfNode?.(hitId),\n    };\n  };\n}\n"],"mappings":";;;;;;AAoFA,SAAgBA,EAAkB,IAAgC,CAAC,GAAiB;CAClF,IAAMC,IAAQC,EAAcC,EAAK,WAAW,GACtC,EACJ,qBAAkBF,EAAM,QACxB,qBAAkBA,EAAM,QACxB,kBAAeA,EAAM,kBACrB,mBACA,qBACEE;CACJ,OAAO;EACLC,EAAyB;GACvB,QAAQC;GACR,OAAO;GACP,GAAIC,IACA,EAAE,QAAQ;IAAE,YAAYA,EAAc;IAAY,aAAaA,EAAc;GAAO,EAAE,IACtF,CAAC;EACP,CAAC;EACDC,EAA6B,EAAE,mBAAgB,CAAC;EAChD,GAAIC,IACAC,EAA4BD,GAAgB,EAAE,WAAWE,EAAgB,CAAC,IAC1E,CAAC;CACP;AACF;AAQA,SAAgBC,EACd,GAIA,GAC0B;CAC1B,aAAa;EACX,IAAMC,IAAMC,EAAY,CAAC,EAAE,IAAI,aAAa;EAE5C,OADKD,IACE;GACL,WAAWA,EAAI,aAAa;GAI5B,UAAU,MAAQE,IAAWA,EAASC,GAAIH,EAAI,gBAAgBG,CAAE,CAAC,IAAIH,EAAI,gBAAgBG,CAAE;EAC7F,IAPiB;CAQnB;AACF;AAYA,SAAgBC,EACd,GACgE;CAChE,IAAM,EAAE,mBAAgB,YAAS,oBAAiBb,GAC5Cc,IAAcd,EAAK,eAAeH,EAAkBG,CAAI;CAE9D,OAAO,SAAsB,EAAE,GAAGe,GAAI,GAAGC,KAAM;EAC7C,IAAMC,IAAMC,EACVJ,GACAC,GACAC,GACAG,EAAe,GACfC,EAAQ,GACRC,IAAe,CACjB;EACA,OAAOJ,IAAMK,EAAgBL,CAAG,IAAI;CACtC;AACF;AAUA,SAASK,EAAgB,GAAyC;CAChE,IAAMC,IAAWN,EAAI,QAAQ,kBAAkB,CAAC;CAChD,OAAO;EACL,MAAMA,EAAI,OAAO,WAAW,GAAGA,EAAI,aAAa,GAAGA,EAAI;EACvD,OAAOA,EAAI;EACX,UAAU;EACV,GAAIM,EAAQ,aAAa,KAAA,IAAgD,CAAC,IAArC,EAAE,WAAW,CAACA,EAAQ,QAAQ,EAAE;EACrE,GAAIA,EAAQ,WAAW,KAAA,IAAyC,CAAC,IAA9B,EAAE,QAAQA,EAAQ,OAAO;EAC5D,GAAIA,EAAQ,eAAe,KAAA,IAAiD,CAAC,IAAtC,EAAE,YAAYA,EAAQ,WAAW;EACxE,GAAIN,EAAI,OAAO,WAAW,KAAA,IAA4C,CAAC,IAAjC,EAAE,QAAQA,EAAI,OAAO,OAAO;EAClE,GAAIA,EAAI,QAAQ,mBAAmB,KAAA,IAAsD,CAAC,IAA3C,EAAE,SAASA,EAAI,QAAQ,eAAe;CACvF;AACF;AAqBA,SAAgBO,EACd,GACA,GACA,GAC8D;CAC9D,OAAO,SAAwB,EAAE,GAAGT,GAAI,GAAGC,KAAM;EAC/C,IAAMS,IAAQC,EAASX,GAAIC,CAAE;EAG7B,OAFKS,IAEE;GACL,MAFUE,EAEJ,CAAA,CAAI,SAASF,CAAK,IAAI,kBAAkB;GAC9C,MAAMG,IAAaH,CAAK;EAC1B,IALmB,EAAE,MAAM,QAAQ;CAMrC;AACF"}

package/dist/canvas/buildSceneTree.js

@@ -0,0 +1,65 @@
+import { deriveParallaxView as e, planeMap as t } from "../core/viewport/parallax.js";
+import { definesFrame as n } from "../core/scene/effectivePose.js";
+import { findShapeSilhouette as r } from "./NodeShape.js";
+import { clipCarrier as i, planeTransform as a } from "./planeClips.js";
+import { scenePlaneOf as o } from "./pickWalk.js";
+//#region src/canvas/buildSceneTree.ts
+function s(e, t, n, r) {
+	let i = {
+		kind: "group",
+		children: e
+	};
+	for (let e = t.length - 1; e >= 0; e--) i = {
+		kind: "group",
+		children: [i],
+		clip: r(t[e].path, t[e].layer, n)
+	};
+	return i;
+}
+function c(c, l, u, d, f, p) {
+	let m = c.getLayers(), h = /* @__PURE__ */ new Map();
+	for (let e of m) h.set(e.id, []);
+	let g = null;
+	for (let t of m) t.parallax && (g ??= /* @__PURE__ */ new Map()).set(t.id, e(u, t.parallax));
+	let _ = c.composePose?.bind(c), v = i(g ? o(m, u) : null);
+	function y(e, t, i) {
+		let a = c.getNode(e);
+		if (!a) return;
+		let o = c.getPose(e), m = _ && i !== null ? _(i, o) : o, b = d === void 0 || a.layer === d, x = g?.get(a.layer) ?? u, S = b && !p?.(a, m, x) ? l(a, m, x) : [], C = t, w = a;
+		if (w.kind === "container") {
+			let e;
+			e = typeof w.clipFromPose == "function" ? w.clipFromPose(m) : r(a, m, { derivedPath: f?.(a, m) }), e && (C = [...t, {
+				path: e,
+				layer: a.layer
+			}]);
+		}
+		if (b) {
+			let e = h.get(a.layer);
+			e && e.push(C.length > 0 ? s(S, C, a.layer, v) : {
+				kind: "group",
+				children: S
+			});
+		}
+		let T = n(a) ? m : i;
+		for (let t of c.getChildren(e)) y(t, C, T);
+	}
+	for (let e of c.getChildren(null)) y(e, [], null);
+	let b = [];
+	for (let e of m) {
+		if (!e.visible || d !== void 0 && e.id !== d) continue;
+		let n = h.get(e.id) ?? [], r = e.parallax ? a(t(u, e.parallax), null) : void 0;
+		b.push(r ? {
+			kind: "group",
+			transform: r,
+			children: n
+		} : {
+			kind: "group",
+			children: n
+		});
+	}
+	return b;
+}
+//#endregion
+export { c as buildSceneTree };
+
+//# sourceMappingURL=buildSceneTree.js.map

package/dist/canvas/buildSceneTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSceneTree.js","names":["wrapInClips","node","cmds","i","clips","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","paints","forLayer","v","self","culled","drawOne","ownClips","ancestorClips","maybeContainer","clip","findShapeSilhouette","derivedPathOf","bucket","childFrame","definesFrame","cid","rootId","out","layer","children","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '../renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport type { Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\n\n/**\n * The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter`\n * satisfies this; flat (non-hierarchical) adapters don't. Canvas exposes these\n * as *optional* methods on `CanvasProps.adapter` (see `OptionalSceneHierarchy`)\n * and feature-detects them at draw time.\n */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in. */\ninterface ChainClip { path: Path; layer: string }\n\n/** Wrap `cmds` in one nested group per clip so the renderer intersects them.\n *  Outermost group carries the ancestor-most clip; innermost holds `cmds`. */\nfunction wrapInClips(\n  cmds: DrawCommand[],\n  clips: readonly ChainClip[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = clips.length - 1; i >= 0; i--) {\n    node = { kind: 'group', children: [node], clip: carry(clips[i].path, clips[i].layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the\n * bucket for **that node's own `layer`** — not its parent's. So a child whose\n * `layer` differs from its parent (e.g. a planting tagged into a top-most\n * `plantings` layer while remaining a scene child of its container) draws in\n * its own layer's pass, on top of every container body, while staying a tree\n * child for hit-testing / move / reparent.\n *\n * Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * **Positioning** is world-space: `drawOne` returns world-coord commands (the\n * caller wraps the whole thing in the view transform). Because a node may be\n * drawn outside its parent's group, the tree nesting cannot carry geometry as\n * renderer state; instead the walk folds each node's pose into its parent's\n * frame on the way down and hands the painter a **world** pose. Clips are\n * accumulated the same way and are world-space for the same reason — each in\n * its container's plane, carried into the plane of the node it clips.\n *\n * With no `composePose` on the adapter the fold is the identity, every node\n * paints at its stored pose, and this is the absolute-pose behavior the kit\n * shipped before frames existed.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the\n * view derived for it, and its group carries the transform from its world to\n * the camera's, so the caller's single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. Used to render\n   *  scene layers as separate, individually-orderable canvas slots. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses. Only a\n   *  scene-backed caller can answer — deriving needs the dependencies' poses —\n   *  so the bare-adapter path omits it and a derived container contributes no\n   *  clip there, exactly as before. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainClip[],\n    parentFrame: TPose | null,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const paints = forLayer === undefined || node.layer === forLayer;\n    const v = planeViews?.get(node.layer) ?? view;\n    const self = paints && !culled?.(node, pose, v) ? drawOne(node, pose, v) : [];\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    const maybeContainer = node as { kind?: string; clipFromPose?: (pose: TPose) => unknown };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → fall back to the painter silhouette for the\n        // container's shape kind. Built-ins give rect-fallback containers\n        // their own AABB as a clip; consumer painters can provide arbitrary\n        // closed shapes (ellipse, polygon, …) without per-node wiring.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) ownClips = [...ancestorClips, { path: clip as Path, layer: node.layer }];\n    }\n\n    // Emit this node's own paint into its own layer's bucket, clipped by the\n    // accumulated chain (ancestors + own). Every node emits a wrapper group\n    // even with empty paint, keeping the per-node tree shape stable.\n    if (paints) {\n      const bucket = buckets.get(node.layer);\n      if (bucket) {\n        bucket.push(ownClips.length > 0 ? wrapInClips(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n      }\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, childFrame);\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":";;;;;;AAgCA,SAASA,EACP,GACA,GACA,GACA,GACa;CACb,IAAIC,IAAyB;EAAE,MAAM;EAAS,UAAUC;CAAK;CAC7D,KAAK,IAAIC,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KACrC,IAAO;EAAE,MAAM;EAAS,UAAU,CAACF,CAAI;EAAG,MAAMI,EAAMD,EAAMD,EAAE,CAAC,MAAMC,EAAMD,EAAE,CAAC,OAAOG,CAAO;CAAE;CAEhG,OAAOL;AACT;AA4BA,SAAgBM,EAId,GACA,GACA,GAIA,GAKA,GAGA,GACe;CACf,IAAMC,IAASC,EAAQ,UAAU,GAC3BC,oBAAU,IAAI,IAA2B;CAC/C,KAAK,IAAMC,KAAKH,GAAQ,EAAQ,IAAIG,EAAE,IAAI,CAAC,CAAC;CAC5C,IAAIC,IAAuC;CAC3C,KAAK,IAAMD,KAAKH,GACd,AAAIG,EAAE,aAAW,sBAAe,IAAI,IAAI,EAAA,CAAG,IAAIA,EAAE,IAAIE,EAAmBC,GAAMH,EAAE,QAAQ,CAAC;CAG3F,IAAMI,IAAUN,EAAQ,aAAa,KAAKA,CAAO,GAC3CJ,IAAQW,EAAYJ,IAAaK,EAAaT,GAAQM,CAAI,IAAI,IAAI;CAExE,SAASI,EACP,GACA,GACA,GACM;EACN,IAAMjB,IAAOQ,EAAQ,QAAQU,CAAE;EAC/B,IAAI,CAAClB,GAAM;EACX,IAAMmB,IAAQX,EAAQ,QAAQU,CAAE,GAG1BE,IAAON,KAAWO,MAAgB,OAAOP,EAAQO,GAAaF,CAAK,IAAIA,GAGvEG,IAASC,MAAa,KAAA,KAAavB,EAAK,UAAUuB,GAClDC,IAAIb,GAAY,IAAIX,EAAK,KAAK,KAAKa,GACnCY,IAAOH,KAAU,CAACI,IAAS1B,GAAMoB,GAAMI,CAAC,IAAIG,EAAQ3B,GAAMoB,GAAMI,CAAC,IAAI,CAAC,GAGxEI,IAAWC,GACTC,IAAiB9B;EACvB,IAAI8B,EAAe,SAAS,aAAa;GACvC,IAAIC;GAeJ,AAdA,AAQEA,IARE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAaV,CAAI,IAMhCY,EACLhC,GACAoB,GACA,EAAE,aAAaa,IAAgBjC,GAAMoB,CAAI,EAAE,CAC7C,GAEEW,MAAM,IAAW,CAAC,GAAGF,GAAe;IAAE,MAAME;IAAc,OAAO/B,EAAK;GAAM,CAAC;EACnF;EAKA,IAAIsB,GAAQ;GACV,IAAMY,IAASzB,EAAQ,IAAIT,EAAK,KAAK;GACrC,AAAIkC,KACFA,EAAO,KAAKN,EAAS,SAAS,IAAI7B,EAAY0B,GAAMG,GAAU5B,EAAK,OAAOI,CAAK,IAAI;IAAE,MAAM;IAAS,UAAUqB;GAAK,CAAC;EAExH;EAGA,IAAMU,IAAaC,EAAapC,CAAa,IAAIoB,IAAOC;EACxD,KAAK,IAAMgB,KAAO7B,EAAQ,YAAYU,CAAE,GAAG,EAAMmB,GAAKT,GAAUO,CAAU;CAC5E;CAEA,KAAK,IAAMG,KAAU9B,EAAQ,YAAY,IAAI,GAAG,EAAM8B,GAAQ,CAAC,GAAG,IAAI;CAEtE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAASjC,GAAQ;EAE1B,IADI,CAACiC,EAAM,WACPjB,MAAa,KAAA,KAAaiB,EAAM,OAAOjB,GAAU;EACrD,IAAMkB,IAAWhC,EAAQ,IAAI+B,EAAM,EAAE,KAAK,CAAC,GACrCE,IAAYF,EAAM,WAAWG,EAAeC,EAAS/B,GAAM2B,EAAM,QAAQ,GAAG,IAAI,IAAI,KAAA;EAC1F,EAAI,KAAKE,IAAY;GAAE,MAAM;GAAS;GAAW;EAAS,IAAI;GAAE,MAAM;GAAS;EAAS,CAAC;CAC3F;CACA,OAAOH;AACT"}

package/dist/canvas/canvasRenderer.js

@@ -0,0 +1,89 @@
+import { WeaselRenderer as e } from "../renderer/WeaselRenderer.js";
+import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
+//#region src/canvas/canvasRenderer.ts
+var n = /* @__PURE__ */ new WeakMap(), r = (e) => e?.map((e) => e.id).join("|") ?? "";
+function i(e, t) {
+	if (t) for (let n of t) try {
+		e.registerProgram(n);
+	} catch (e) {
+		console.warn(`weasel: failed to register shader "${n.id}":`, e);
+	}
+}
+function a(e) {
+	let t = n.get(e.canvas);
+	t?.delete(e.renderer), t && t.size === 0 && n.delete(e.canvas), e.renderer.dispose();
+}
+function o() {
+	let o = null, s = (t, s, c = {}) => {
+		let { width: l, height: u } = s, d = s.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), f = c.tile ?? null, p = f !== null;
+		if (o && (o.canvas !== t || o.shared !== p) && (a(o), o = null), o) (o.width !== l || o.height !== u || o.dpr !== d) && (o.renderer.resize({
+			width: l,
+			height: u,
+			dpr: d
+		}), o.width = l, o.height = u, o.dpr = d), o.flattenTolerance !== c.flattenTolerance && (o.renderer.setFlattenTolerance(c.flattenTolerance), o.flattenTolerance = c.flattenTolerance);
+		else {
+			let r = t.getContext("webgl2", {
+				preserveDrawingBuffer: !0,
+				stencil: !0
+			});
+			if (!r || typeof r.enable != "function") return null;
+			let i;
+			try {
+				i = new e({
+					gl: r,
+					...p ? {} : { canvas: t },
+					width: l,
+					height: u,
+					dpr: d,
+					flattenTolerance: c.flattenTolerance
+				});
+			} catch {
+				return null;
+			}
+			o = {
+				canvas: t,
+				renderer: i,
+				shared: p,
+				width: l,
+				height: u,
+				dpr: d,
+				tileX: null,
+				tileY: null,
+				flattenTolerance: c.flattenTolerance,
+				shaderKey: ""
+			};
+			let a = n.get(t);
+			a || (a = /* @__PURE__ */ new Set(), n.set(t, a)), a.add(i);
+		}
+		let { renderer: m } = o, h = r(c.shaders);
+		h !== o.shaderKey && (i(m, c.shaders), o.shaderKey = h);
+		let g = f?.x ?? null, _ = f?.y ?? null;
+		return (g !== o.tileX || _ !== o.tileY) && (m.setTarget(f ? { origin: {
+			x: f.x,
+			y: f.y
+		} } : null), o.tileX = g, o.tileY = _), m;
+	};
+	return {
+		bind: s,
+		paint(e, n, r, i, a) {
+			let o = s(e, i, a);
+			return o ? (o.render(n, t(r), a?.render), !0) : !1;
+		},
+		release() {
+			o && a(o), o = null;
+		}
+	};
+}
+var s = /* @__PURE__ */ new WeakMap();
+function c(e, t, n, r) {
+	let i = s.get(e);
+	return i || (i = o(), s.set(e, i)), i.paint(e, t, n, r);
+}
+function l(e) {
+	let t = s.get(e);
+	t && (s.delete(e), t.release());
+}
+//#endregion
+export { o as leaseCanvasRenderer, c as paintCanvas, l as releaseCanvasRenderer };
+
+//# sourceMappingURL=canvasRenderer.js.map

package/dist/canvas/canvasRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasRenderer.js","names":["TENANTS","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","shaderKey","tileX","tileY","commands","viewToMat3","view","CANVAS_LEASES","paintCanvas","lease","releaseCanvasRenderer"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface — `<Canvas>`,\n * `<SceneViewCanvas>`, `<MinimapCanvas>`, `<DrawCanvas>` — holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease (the detached ones via\n * `useCanvasRenderer`): created on first paint, resized when the surface's\n * size or density changes, rebuilt when the surface moves to another element,\n * and freed on release.\n *\n * A lease holds its own renderer, so several can share one element: each\n * tenant painting a `tile` of a shared buffer gets a renderer of its own on\n * the element's one context. Release frees only what that renderer created;\n * the context itself is never lost.\n */\nimport { WeaselRenderer, type RenderOptions } from '../renderer/WeaselRenderer';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { ShaderProgramHandle } from '../renderer/shaders/registerProgram';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** A renderer painting into the canvas, if any lease holds one. Test seam. */\nexport function cachedCanvasRenderer(canvas: HTMLCanvasElement): WeaselRenderer | undefined {\n  const set = TENANTS.get(canvas);\n  return set ? set.values().next().value : undefined;\n}\n\n/** The size and density to paint a canvas at. `dpr` defaults to\n *  `window.devicePixelRatio`, read per paint. */\nexport interface CanvasPaintSize {\n  width: number;\n  height: number;\n  dpr?: number;\n}\n\n/** How one paint reaches the canvas, beyond its size. */\nexport interface CanvasPaintOptions {\n  /** Paint a `width × height` tile of a buffer other surfaces share, at this\n   *  origin in CSS pixels. The buffer is then the caller's to size: the\n   *  renderer never resizes the element, which would have every co-tenant\n   *  resize it to its own pane. Omit to own the whole element. */\n  tile?: { x: number; y: number } | null;\n  /** `WeaselRendererOptions.flattenTolerance`, applied from this paint on. */\n  flattenTolerance?: number;\n  /** Custom programs to compile on the renderer. Compiled when the renderer\n   *  is created, and again when the set of ids changes. */\n  shaders?: readonly ShaderProgramHandle[];\n}\n\n/** A paint's options, plus what `paint` hands `WeaselRenderer.render`. */\nexport interface CanvasRenderOptions extends CanvasPaintOptions {\n  render?: RenderOptions;\n}\n\n/** A canvas renderer held for a surface's lifetime. */\nexport interface CanvasRendererLease {\n  /** Draw `commands` into `canvas` — screen-space, one unit per CSS pixel,\n   *  with `view` passed on as the frame's world→screen transform. `bind`,\n   *  then render. Returns `false` without painting where `bind` finds no\n   *  renderer. */\n  paint(\n    canvas: HTMLCanvasElement,\n    commands: DrawCommand[],\n    view: View,\n    size: CanvasPaintSize,\n    options?: CanvasRenderOptions,\n  ): boolean;\n  /** The renderer that paints `canvas` at `size`, ready to render: created on\n   *  first use, resized, and given this paint's tile, tolerance and shaders.\n   *  Frees the previous renderer first if the surface moved to another\n   *  element, or between owning it whole and painting a tile of it. `null`\n   *  where no WebGL2 context is available (jsdom, or a failed context\n   *  creation), so a caller can skip building a frame nobody will see. */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Free the held renderer and every GL object it owns. A later `paint`\n   *  creates a fresh one. */\n  release(): void;\n}\n\ninterface Held {\n  canvas: HTMLCanvasElement;\n  renderer: WeaselRenderer;\n  shared: boolean;\n  width: number;\n  height: number;\n  dpr: number;\n  tileX: number | null;\n  tileY: number | null;\n  flattenTolerance: number | undefined;\n  shaderKey: string;\n}\n\nconst shaderKeyOf = (shaders: readonly ShaderProgramHandle[] | undefined): string =>\n  shaders?.map((h) => h.id).join('|') ?? '';\n\nfunction registerShaders(renderer: WeaselRenderer, shaders: readonly ShaderProgramHandle[] | undefined): void {\n  if (!shaders) return;\n  for (const handle of shaders) {\n    try {\n      renderer.registerProgram(handle);\n    } catch (e) {\n      console.warn(`weasel: failed to register shader \"${handle.id}\":`, e);\n    }\n  }\n}\n\nfunction free(held: Held): void {\n  const set = TENANTS.get(held.canvas);\n  set?.delete(held.renderer);\n  if (set && set.size === 0) TENANTS.delete(held.canvas);\n  held.renderer.dispose();\n}\n\n/** Hold the renderer of the canvas a surface paints into, until released. */\nexport function leaseCanvasRenderer(): CanvasRendererLease {\n  let held: Held | null = null;\n  const bind = (canvas: HTMLCanvasElement, size: CanvasPaintSize, options: CanvasPaintOptions = {}): WeaselRenderer | null => {\n    const { width, height } = size;\n    const dpr = size.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1);\n    const tile = options.tile ?? null;\n    const shared = tile !== null;\n\n    if (held && (held.canvas !== canvas || held.shared !== shared)) {\n      free(held);\n      held = null;\n    }\n    if (!held) {\n      const gl = canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true });\n      if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') return null;\n      let renderer: WeaselRenderer;\n      try {\n        renderer = new WeaselRenderer({\n          gl: gl as WebGL2RenderingContext,\n          ...(shared ? {} : { canvas }),\n          width, height, dpr,\n          flattenTolerance: options.flattenTolerance,\n        });\n      } catch {\n        return null;\n      }\n      held = { canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, shaderKey: '' };\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      if (held.width !== width || held.height !== height || held.dpr !== dpr) {\n        held.renderer.resize({ width, height, dpr });\n        held.width = width;\n        held.height = height;\n        held.dpr = dpr;\n      }\n      if (held.flattenTolerance !== options.flattenTolerance) {\n        held.renderer.setFlattenTolerance(options.flattenTolerance);\n        held.flattenTolerance = options.flattenTolerance;\n      }\n    }\n\n    const { renderer } = held;\n    const shaderKey = shaderKeyOf(options.shaders);\n    if (shaderKey !== held.shaderKey) {\n      registerShaders(renderer, options.shaders);\n      held.shaderKey = shaderKey;\n    }\n    const tileX = tile?.x ?? null;\n    const tileY = tile?.y ?? null;\n    if (tileX !== held.tileX || tileY !== held.tileY) {\n      renderer.setTarget(tile ? { origin: { x: tile.x, y: tile.y } } : null);\n      held.tileX = tileX;\n      held.tileY = tileY;\n    }\n    return renderer;\n  };\n  return {\n    bind,\n    paint(canvas, commands, view, size, options) {\n      const renderer = bind(canvas, size, options);\n      if (!renderer) return false;\n      renderer.render(commands, viewToMat3(view), options?.render);\n      return true;\n    },\n    release() {\n      if (held) free(held);\n      held = null;\n    },\n  };\n}\n\n/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */\nconst CANVAS_LEASES: WeakMap<HTMLCanvasElement, CanvasRendererLease> = new WeakMap();\n\n/**\n * Paint `canvas` through a lease held for the element itself, for callers\n * with no component lifetime of their own (`renderSceneToCanvas`). The\n * renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function paintCanvas(\n  canvas: HTMLCanvasElement,\n  commands: DrawCommand[],\n  view: View,\n  size: CanvasPaintSize,\n): boolean {\n  let lease = CANVAS_LEASES.get(canvas);\n  if (!lease) {\n    lease = leaseCanvasRenderer();\n    CANVAS_LEASES.set(canvas, lease);\n  }\n  return lease.paint(canvas, commands, view, size);\n}\n\n/** Free the renderer `paintCanvas` holds for the canvas, and every GL object\n *  it owns. The next paint creates a fresh one. Renderers a surface component\n *  holds are that component's to free, on unmount. */\nexport function releaseCanvasRenderer(canvas: HTMLCanvasElement): void {\n  const lease = CANVAS_LEASES.get(canvas);\n  if (!lease) return;\n  CANVAS_LEASES.delete(canvas);\n  lease.release();\n}\n"],"mappings":"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"}

package/dist/canvas/colorOverrides.js

@@ -0,0 +1,16 @@
+//#region src/canvas/colorOverrides.ts
+var e = () => typeof performance < "u" ? performance.now() : Date.now();
+function t(t, n, r = e) {
+	return (e, i, a, o) => {
+		if (!t.has(e.id)) return n(e, i, a, o);
+		let s = r();
+		return n(e, i, a, {
+			...o,
+			vertexColors: (n, r) => t.resolve(e.id, n, r, s)
+		});
+	};
+}
+//#endregion
+export { t as withColorOverrides };
+
+//# sourceMappingURL=colorOverrides.js.map

package/dist/canvas/colorOverrides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorOverrides.js","names":["clock","withColorOverrides","registry","node","drawOne","pose","view","ctx","tMs","now","channel","base"],"sources":["../../src/canvas/colorOverrides.ts"],"sourcesContent":["/**\n * The render walk's half of animated vertex colors: handing a node's live\n * color overrides to its painter. The overrides live in an animator's\n * `ColorOverrideRegistry`, which `tweenVertexColors` and its siblings write.\n */\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\n\nconst clock = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now());\n\n/**\n * Wrap a `drawOne` so a node with a live color override reaches its painter\n * with {@link NodePaintCtx.vertexColors}. Both scene walks wrap here, and\n * `createPathLayer` resolves through the same `ColorOverrideRegistry.resolve`.\n *\n * A node nothing overrides passes the caller's `ctx` through untouched, so\n * the common case allocates nothing.\n */\nexport function withColorOverrides<TData, TLayer extends string, TPose>(\n  registry: ColorOverrideRegistry,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  now: () => number = clock,\n): SceneViewDrawOne<TData, TLayer, TPose> {\n  return (node, pose, view, ctx) => {\n    if (!registry.has(node.id)) return drawOne(node, pose, view, ctx);\n    const tMs = now();\n    return drawOne(node, pose, view, {\n      ...ctx,\n      vertexColors: (channel, base) => registry.resolve(node.id, channel, base, tMs),\n    });\n  };\n}\n"],"mappings":";AAQA,IAAMA,UAAuB,OAAO,cAAgB,MAAc,YAAY,IAAI,IAAI,KAAK,IAAI;AAU/F,SAAgBC,EACd,GACA,GACA,IAAoBD,GACoB;CACxC,QAAQ,GAAM,GAAM,GAAM,MAAQ;EAChC,IAAI,CAACE,EAAS,IAAIC,EAAK,EAAE,GAAG,OAAOC,EAAQD,GAAME,GAAMC,GAAMC,CAAG;EAChE,IAAMC,IAAMC,EAAI;EAChB,OAAOL,EAAQD,GAAME,GAAMC,GAAM;GAC/B,GAAGC;GACH,eAAe,GAAS,MAASL,EAAS,QAAQC,EAAK,IAAIO,GAASC,GAAMH,CAAG;EAC/E,CAAC;CACH;AACF"}

package/dist/canvas/defaultDrawOne.js

@@ -0,0 +1,43 @@
+import { textCommandFromRuns as e } from "../features/text/textCommand.js";
+import { findNodeShape as t, findShapeBounds as n } from "./NodeShape.js";
+//#region src/canvas/defaultDrawOne.ts
+function r(e) {
+	let t = typeof window < "u" && window.devicePixelRatio || 1;
+	return Math.max(Math.abs(e.scale.x), Math.abs(e.scale.y)) * t;
+}
+var i, a = {};
+function o(e) {
+	let t = r(e);
+	return (e !== i || a.pixelScale !== t) && (i = e, a = { pixelScale: t }), a;
+}
+function s(n, i, a, s) {
+	let c = t(n), l = !a || s?.pixelScale !== void 0 ? s : s ? {
+		...s,
+		pixelScale: r(a)
+	} : o(a), u = c ? c.paint(n, i, l) : [], d = n.data;
+	if (d?.label && d.text == null) {
+		let t = i;
+		return [...u, e(t.x + 6, t.y + 14, [{
+			text: d.label,
+			fill: {
+				fill: "solid",
+				color: "rgba(0,0,0,0.7)"
+			}
+		}], {
+			fontFamily: "sans-serif",
+			fontSize: 11
+		})];
+	}
+	return u;
+}
+function c(e, t, r) {
+	let i = e.data;
+	return i?.label && i.text == null ? null : n(e, t, { scale: Math.sqrt(Math.abs(r.scale.x * r.scale.y)) });
+}
+function l(e) {
+	return e === s ? c : void 0;
+}
+//#endregion
+export { s as defaultDrawOne, c as defaultPaintBounds, l as paintBoundsFor };
+
+//# sourceMappingURL=defaultDrawOne.js.map

package/dist/canvas/defaultDrawOne.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultDrawOne.js","names":["pixelScaleOf","dpr","view","lastView","lastViewCtx","viewOnlyCtx","pixelScale","defaultDrawOne","painter","findNodeShape","node","paintCtx","ctx","primary","pose","data","p","textCommandFromRuns","defaultPaintBounds","findShapeBounds","paintBoundsFor","drawOne"],"sources":["../../src/canvas/defaultDrawOne.ts"],"sourcesContent":["/**\n * `defaultDrawOne` — the kit's default per-node draw function.\n *\n * Extracted from `SceneCanvas.tsx` so non-React callers (headless\n * rasterization via `renderSceneToPixels`) can use it without importing\n * the React component tree.\n *\n * Default scene-slot `drawOne` — dispatches through the shape-painter\n * registry (`./NodeShape`). The kit registers built-in painters for\n * text (`kit:text`), paths (`kit:path`), and a rect-from-pose fallback\n * (`kit:rect-fallback`) at module load, so every shape it ships out of\n * the box (rect, ellipse, polygon, star, line, pen, pencil, text) paints\n * without consumer intervention.\n *\n * To teach the kit about a new kind of shape, register a painter — do\n * not override `drawOne`. See `registerNodeShape` for the API and\n * priority semantics. Override `drawOne` only for cross-cutting\n * decoration (post-process every node, mix in overlays from outside\n * the per-node data, etc.).\n *\n * This function also emits an optional `data.label` overlay (sans-serif\n * 11px, top-left) on every non-text painter's output — a convenience\n * for naming zones in demos. Nodes whose painter is `kit:text` skip the\n * overlay since their content already shows.\n */\nimport type { Node } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '../renderer';\nimport { textCommandFromRuns } from 'features/text/textCommand';\nimport { findNodeShape, findShapeBounds, type NodePaintCtx } from './NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nfunction pixelScaleOf(view: View): number {\n  const dpr = (typeof window !== 'undefined' && window.devicePixelRatio) || 1;\n  return Math.max(Math.abs(view.scale.x), Math.abs(view.scale.y)) * dpr;\n}\n\n// Shared across a frame's nodes, which all arrive with the same view.\nlet lastView: View | undefined;\nlet lastViewCtx: NodePaintCtx = {};\nfunction viewOnlyCtx(view: View): NodePaintCtx {\n  const pixelScale = pixelScaleOf(view);\n  if (view !== lastView || lastViewCtx.pixelScale !== pixelScale) {\n    lastView = view;\n    lastViewCtx = { pixelScale };\n  }\n  return lastViewCtx;\n}\n\n/** Paint one node the way the kit does by default: dispatch to the first\n *  registered node-shape painter that matches, then draw its `data.label` on\n *  top when it has one. Consumers replace or wrap this via `drawOne`. */\nexport function defaultDrawOne<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view?: View,\n  ctx?: NodePaintCtx,\n): DrawCommand[] {\n  const painter = findNodeShape(node);\n  const paintCtx = !view || ctx?.pixelScale !== undefined\n    ? ctx\n    : ctx ? { ...ctx, pixelScale: pixelScaleOf(view) } : viewOnlyCtx(view);\n  const primary = painter ? painter.paint(node, pose, paintCtx) : [];\n\n  // Label overlay — skipped for text nodes (their content is the label).\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) {\n    const p = pose as unknown as { x: number; y: number };\n    // Copy rather than `push`. A painter's return value is not ours to grow:\n    // one that memoizes its command list — which is the point of caching\n    // `paint` — would gain another label command on every frame, forever.\n    return [...primary, textCommandFromRuns(\n      p.x + 6,\n      p.y + 14,\n      [{ text: data.label, fill: { fill: 'solid', color: 'rgba(0,0,0,0.7)' } }],\n      { fontFamily: 'sans-serif', fontSize: 11 },\n    )];\n  }\n\n  // Rotation and per-node alpha are applied OUTSIDE this function, by\n  // `wrapNodeOutput` in the scene walks (`buildSceneLayer`,\n  // `buildSceneViewCommands`) and the preview-ghost layer, so that\n  // consumer-supplied painters get them too. Doing it here would double-wrap.\n  return primary;\n}\n\n/**\n * The box {@link defaultDrawOne}'s output for `node` fits in — the matched\n * painter's `bounds` — or `null` when it has none, or when a `data.label`\n * overlay adds text nothing bounds cheaply. The scene slot's `cull` reads it\n * to skip painting nodes the view cannot see.\n */\nexport function defaultPaintBounds<TData, TLayer extends string, TPose>(\n  node: Node<TData, TLayer, TPose>,\n  pose: TPose,\n  view: View,\n): Bounds | null {\n  const data = node.data as { label?: string; text?: string } | null;\n  if (data?.label && data.text == null) return null;\n  return findShapeBounds(node, pose, { scale: Math.sqrt(Math.abs(view.scale.x * view.scale.y)) });\n}\n\n/**\n * `defaultPaintBounds` when `drawOne` is `defaultDrawOne`, and nothing\n * otherwise: a painter's box says nothing about what a replacement\n * `drawOne` paints.\n */\nexport function paintBoundsFor<TData, TLayer extends string, TPose>(\n  drawOne: unknown,\n): typeof defaultPaintBounds<TData, TLayer, TPose> | undefined {\n  return drawOne === defaultDrawOne ? defaultPaintBounds : undefined;\n}\n"],"mappings":";;;AAgCA,SAASA,EAAa,GAAoB;CACxC,IAAMC,IAAO,OAAO,SAAW,OAAe,OAAO,oBAAqB;CAC1E,OAAO,KAAK,IAAI,KAAK,IAAIC,EAAK,MAAM,CAAC,GAAG,KAAK,IAAIA,EAAK,MAAM,CAAC,CAAC,IAAID;AACpE;AAGA,IAAIE,GACAC,IAA4B,CAAC;AACjC,SAASC,EAAY,GAA0B;CAC7C,IAAMC,IAAaN,EAAaE,CAAI;CAKpC,QAJIA,MAASC,KAAYC,EAAY,eAAeE,OAClD,IAAWJ,GACX,IAAc,EAAE,cAAW,IAEtBE;AACT;AAKA,SAAgBG,EACd,GACA,GACA,GACA,GACe;CACf,IAAMC,IAAUC,EAAcC,CAAI,GAC5BC,IAAW,CAACT,KAAQU,GAAK,eAAe,KAAA,IAC1CA,IACAA,IAAM;EAAE,GAAGA;EAAK,YAAYZ,EAAaE,CAAI;CAAE,IAAIG,EAAYH,CAAI,GACjEW,IAAUL,IAAUA,EAAQ,MAAME,GAAMI,GAAMH,CAAQ,IAAI,CAAC,GAG3DI,IAAOL,EAAK;CAClB,IAAIK,GAAM,SAASA,EAAK,QAAQ,MAAM;EACpC,IAAMC,IAAIF;EAIV,OAAO,CAAC,GAAGD,GAASI,EAClBD,EAAE,IAAI,GACNA,EAAE,IAAI,IACN,CAAC;GAAE,MAAMD,EAAK;GAAO,MAAM;IAAE,MAAM;IAAS,OAAO;GAAkB;EAAE,CAAC,GACxE;GAAE,YAAY;GAAc,UAAU;EAAG,CAC3C,CAAC;CACH;CAMA,OAAOF;AACT;AAQA,SAAgBK,EACd,GACA,GACA,GACe;CACf,IAAMH,IAAOL,EAAK;CAElB,OADIK,GAAM,SAASA,EAAK,QAAQ,OAAa,OACtCI,EAAgBT,GAAMI,GAAM,EAAE,OAAO,KAAK,KAAK,KAAK,IAAIZ,EAAK,MAAM,IAAIA,EAAK,MAAM,CAAC,CAAC,EAAE,CAAC;AAChG;AAOA,SAAgBkB,EACd,GAC6D;CAC7D,OAAOC,MAAYd,IAAiBW,IAAqB,KAAA;AAC3D"}

package/dist/canvas/deps/areaSelect.js

@@ -0,0 +1,19 @@
+import { hitTestArea as e, regionPickOptions as t } from "./hitTestArea.js";
+import { useLatest as n } from "@weasel-js/react";
+import { useDepSource as r } from "@weasel-js/routing/react";
+//#region src/canvas/deps/areaSelect.ts
+function i(i, a, o, s, c) {
+	let l = n(i), u = n(a), d = n(o), f = n(c);
+	r("areaSelect", () => {
+		let n = l.current, r = u.current, i = d.current, a = f.current;
+		return {
+			hitTestArea: (r, o) => e(n, r, t(o, a, s), i),
+			getSelection: () => r.current,
+			setSelection: (e) => r.set(e)
+		};
+	});
+}
+//#endregion
+export { i as useAreaSelectDepSource };
+
+//# sourceMappingURL=areaSelect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"areaSelect.js","names":["hitTestAreaShared","useAreaSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","hitTestArea","bounds","regionPickOptions","view","poseComposition","ids"],"sources":["../../../src/canvas/deps/areaSelect.ts"],"sourcesContent":["/**\n * `useAreaSelectDepSource` — wires the `areaSelect` dep consumed by\n * `areaSelectAction`. The dep exposes:\n *   - `hitTestArea(bounds)` — silhouette-aware scan over `scene.renderOrderNodes()`\n *     (rect poses by AABB; polygon poses by the kernel polygon-overlap test).\n *   - `getSelection` / `setSelection` — passthrough to the kit selection api.\n *\n * Built once per render and stabilised by `useDepSource` (which reads via a\n * ref internally), so callers can pass fresh selection/scene refs without\n * triggering re-registration.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { AreaSelectDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { hitTestArea as hitTestAreaShared, regionPickOptions } from './hitTestArea';\nimport type { PoseComposition } from 'features/groups/composePose';\n\nexport function useAreaSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<unknown>,\n  poseComposition?: PoseComposition<unknown>,\n  /** The painted alpha the surface's layers apply, which every view shares. */\n  alphaOf?: (id: string) => number,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const descriptorRef = useLatest(descriptor);\n  const alphaOfRef = useLatest(alphaOf);\n\n  useDepSource('areaSelect', (): AreaSelectDep => {\n    const sc = sceneRef.current;\n    const s = selectionRef.current;\n    const d = descriptorRef.current;\n    const a = alphaOfRef.current;\n    return {\n      hitTestArea: (bounds, view) =>\n        hitTestAreaShared(sc, bounds, regionPickOptions(view, a, poseComposition), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids),\n    };\n  });\n}\n"],"mappings":";;;;AAoBA,SAAgBC,EACd,GACA,GACA,GACA,GAEA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAgBJ,EAAUK,CAAU,GACpCC,IAAaN,EAAUO,CAAO;CAEpC,EAAa,oBAAmC;EAC9C,IAAMC,IAAKT,EAAS,SACdU,IAAIP,EAAa,SACjBQ,IAAIN,EAAc,SAClB,IAAIE,EAAW;EACrB,OAAO;GACL,cAAc,GAAQ,MACpBT,EAAkBW,GAAII,GAAQC,EAAkBC,GAAM,GAAGC,CAAe,GAAGL,CAAC;GAC9E,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIO,CAAG;EAClC;CACF,CAAC;AACH"}

package/dist/canvas/deps/debug.js

@@ -0,0 +1,9 @@
+import { useDepSource as e } from "@weasel-js/routing/react";
+//#region src/canvas/deps/debug.ts
+function t(t) {
+	e("debug", () => t.current?.getDebug() ?? void 0);
+}
+//#endregion
+export { t as useDebugDepSource };
+
+//# sourceMappingURL=debug.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","names":["useDebugDepSource","canvasApiRef"],"sources":["../../../src/canvas/deps/debug.ts"],"sourcesContent":["/**\n * `useDebugDepSource` — wires the `debug` dep: the sink of the canvas this\n * registrar belongs to, so actions report to the same debug overlay tools do\n * through `ToolCtx.debug`. Resolved at invocation, because the canvas creates\n * its sink after this registers and swaps it whenever `debug` changes.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport type { CanvasExtensionApi } from '../canvasExtension';\n\nexport function useDebugDepSource(canvasApiRef: React.RefObject<CanvasExtensionApi | null>): void {\n  useDepSource('debug', () => canvasApiRef.current?.getDebug() ?? undefined);\n}\n"],"mappings":";;AASA,SAAgBA,EAAkB,GAAgE;CAChG,EAAa,eAAeC,EAAa,SAAS,SAAS,KAAK,KAAA,CAAS;AAC3E"}

package/dist/canvas/deps/dispatcher.js

@@ -0,0 +1,11 @@
+import { useLatest as e } from "@weasel-js/react";
+import { useDepSource as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/dispatcher.ts
+function n(n) {
+	let r = e(n);
+	t("dispatcher", () => ({ cancelAll: (e) => r.current.cancelAll(e) }));
+}
+//#endregion
+export { n as useDispatcherDepSource };
+
+//# sourceMappingURL=dispatcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatcher.js","names":["useDispatcherDepSource","ref","useLatest","dispatcher","reason"],"sources":["../../../src/canvas/deps/dispatcher.ts"],"sourcesContent":["/**\n * `useDispatcherDepSource` — wires the `dispatcher` dep so actions can\n * abort in-flight handles (`cancelGestureAction` is the kit's only\n * built-in consumer today; consumer-app actions wanting drag-cancel\n * semantics use the same surface).\n *\n * Exposes only the control methods actions might legitimately need —\n * `cancelAll(reason)` — not the full dispatcher API. Keeps the dep's\n * blast radius narrow.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dispatcher } from '@weasel-js/routing';\n\nexport function useDispatcherDepSource(dispatcher: Dispatcher): void {\n  const ref = useLatest(dispatcher);\n\n  useDepSource('dispatcher', () => ({\n    cancelAll: (reason) => ref.current.cancelAll(reason),\n  }));\n}\n"],"mappings":";;;AAcA,SAAgBA,EAAuB,GAA8B;CACnE,IAAMC,IAAMC,EAAUC,CAAU;CAEhC,EAAa,qBAAqB,EAChC,YAAY,MAAWF,EAAI,QAAQ,UAAUG,CAAM,EACrD,EAAE;AACJ"}

package/dist/canvas/deps/editAnchors.js

@@ -0,0 +1,101 @@
+import { createTransformOp as e } from "../../core/ops/transform.js";
+import { createSetDataOp as t } from "../../core/ops/setData.js";
+import { isRectPose as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { pathInWorld as r, worldEditToStorage as i } from "../../features/paths/pathInWorld.js";
+import { useCallback as a, useState as o } from "react";
+import { useLatest as s } from "@weasel-js/react";
+import { recordModeSwitch as c } from "@weasel-js/routing";
+import { useDepSource as l } from "@weasel-js/routing/react";
+//#region src/canvas/deps/editAnchors.ts
+function u(e) {
+	if (!e) return null;
+	if (e.pose?.kind === "polygon") return { kind: "pose" };
+	let t = e.data;
+	return t?.path && t.path.kind === "polygon" && n(e.pose) ? {
+		kind: "data",
+		pose: e.pose,
+		data: t
+	} : null;
+}
+function d(e) {
+	if (!e) return null;
+	let t = u(e);
+	return t ? t.kind === "pose" ? e.pose : r(t.data.path, t.pose) : null;
+}
+var f = /* @__PURE__ */ new Set();
+function p(n, r, p, m, h) {
+	let g = s(n), _ = s(r), v = s(p), y = s(h?.anchorEditingAllowed), [b, x] = o(""), S = a((e) => {
+		x(e ?? "");
+	}, []), C = s(m), w = s(S), T = () => C.current ? C.current.getEditingId() : b;
+	l("editAnchors", () => {
+		let n = g.current, r = v.current, a = _.current, o = C.current, s = T();
+		if (s) {
+			let e = n.get(s), t = a.current.includes(s), r = !y.current || y.current();
+			(!e || !t || !r) && (s = "");
+		}
+		let l = s ? o?.getSelectedAnchors() ?? f : f, p = s ? o?.getMarquee() ?? null : null, m = (r, a, o) => {
+			let s = a, c = n.get(r);
+			if (!c) return [];
+			let l = u(c);
+			if (!l) return [];
+			if (l.kind === "pose") return [e({
+				id: r,
+				from: c.pose,
+				to: s,
+				label: o
+			})];
+			let { pose: d, path: f } = i(l.pose, s);
+			return [e({
+				id: r,
+				from: c.pose,
+				to: d,
+				label: o
+			}), t({
+				id: r,
+				from: c.data,
+				to: {
+					...c.data,
+					path: f
+				},
+				label: o
+			})];
+		};
+		return {
+			editingId: s,
+			setEditingId(e) {
+				let t = e ?? "";
+				s !== t && (c("editAnchors.editingId", s || null, t || null, t ? "enter" : "exit"), o?.setSelectedAnchors(f), o?.setMarquee(null)), C.current ? C.current.setEditingId(e) : w.current(e);
+			},
+			selectedAnchors: l,
+			setSelectedAnchors(e) {
+				s && o?.setSelectedAnchors(new Set(e));
+			},
+			marquee: p,
+			setMarquee(e) {
+				s && o?.setMarquee(e);
+			},
+			getEditablePath(e) {
+				return d(n.get(e));
+			},
+			getStorageKind(e) {
+				return u(n.get(e))?.kind ?? null;
+			},
+			getNodeShape(e) {
+				let t = n.get(e);
+				return t ? {
+					pose: t.pose,
+					data: t.data
+				} : null;
+			},
+			applyEdit(e, t, n) {
+				let i = m(e, t, n);
+				i.length > 0 && r.applyOps(i, n);
+			},
+			editOps: m
+		};
+	});
+}
+//#endregion
+export { d as resolveEditablePathOf, p as useEditAnchorsDepSource };
+
+//# sourceMappingURL=editAnchors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editAnchors.js","names":["classifyStorage","node","data","isRectPose","resolveEditablePathOf","storage","pathInWorld","EMPTY_ANCHOR_SELECTION","useEditAnchorsDepSource","sceneRef","useLatest","scene","selectionRef","selection","adapterRef","adapter","allowedRef","options","localEditingId","setLocalEditingIdState","useState","setLocalEditingId","useCallback","id","externalRef","externalState","setLocalEditingIdRef","readEditingId","sc","ad","s","ext","effectiveId","inSelection","permitted","selectedAnchors","marquee","editOps","wp","worldPath","createTransformOp","newPose","aligned","worldEditToStorage","createSetDataOp","next","recordModeSwitch","rect","ops","label"],"sources":["../../../src/canvas/deps/editAnchors.ts"],"sourcesContent":["/**\n * `useEditAnchorsDepSource` — wires the `editAnchors` dep consumed by\n * `editAnchorsAction`, `enterPathEditAction`, `exitPathEditAction`, and\n * `insertPathAnchorAction`.\n *\n * `editingId` is explicit, set by `enterPathEditAction` (double-click)\n * and cleared by `exitPathEditAction` (Escape, or when the target leaves\n * the selection / is deleted).\n *\n * `getEditablePath(id)` returns the COMMITTED polygon in **world coords**,\n * regardless of where it's stored:\n *   - `node.pose.kind === 'polygon'` → pose IS the polygon.\n *   - `node.data.path` is a polygon → kit pen-tool default. Polygon's\n *     stored coords are pose-local (aligned to pose origin); we project\n *     to world via `pathInWorld` (translate + bake `pose.rotation`).\n *\n * `getStorageKind(id)` returns where the polygon lives (`'pose'` /\n * `'data'` / `null`). Actions use this to emit the right preview-ghost\n * axes: `previewPose` only for pose-as-polygon, `previewPose +\n * previewData` for data.path.\n *\n * `applyEdit(id, worldPath, label)` commits in the correct storage shape,\n * as one undoable batch. Pose-as-polygon is a `transform` op; data.path is\n * a `transform` (new bounds) plus a `setData` (re-aligned local path), so\n * the kit's render invariant (`pathInWorld(stored, pose) === world`) is\n * preserved. `editOps` returns those same ops unapplied, for a caller\n * folding the edit into a larger batch.\n *\n * Live previews ride the standard `OngoingHandle.previewIds/Pose/Data`\n * triple — this dep doesn't own preview state.\n */\nimport { useCallback, useState } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId, RectPose } from 'core/scene/types';\nimport { isRectPose } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport { pathInWorld, worldEditToStorage } from 'features/paths/pathInWorld';\nimport { recordModeSwitch } from '@weasel-js/routing';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { createSetDataOp } from 'core/ops/setData';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/** Optional shared state for the edit-mode `editingId`. Pass when the\n *  consumer needs to read the current editingId from a sibling component\n *  (e.g. the path-editing overlay layer rendered above the SceneCanvas\n *  subtree where the dep is published). When omitted, the hook owns\n *  local state. */\nexport interface EditAnchorsStateRef {\n  getEditingId(): string;\n  setEditingId(id: string | null): void;\n  /** Selected anchors (flat indices) for the node in `editingId`. */\n  getSelectedAnchors(): ReadonlySet<number>;\n  setSelectedAnchors(next: ReadonlySet<number>): void;\n  /** In-flight anchor-marquee rect in world coords. */\n  getMarquee(): { x: number; y: number; width: number; height: number } | null;\n  setMarquee(rect: { x: number; y: number; width: number; height: number } | null): void;\n}\n\n/** Extra wiring for {@link useEditAnchorsDepSource}. */\nexport interface EditAnchorsDepOptions {\n  /**\n   * Whether the host currently permits anchor editing — i.e. whether the\n   * active mode allows the `edits-anchors` capability.\n   *\n   * **Omit this when no mode registry is wired.** Absent means \"no\n   * modality, so nothing revokes edit mode\", which is the correct\n   * behavior for the many consumers that never opt into modes; passing a\n   * predicate built from an empty capability set would revoke edit mode\n   * instantly. Same trap as `DEFAULT_ALLOWED_CAPABILITIES` guards against\n   * on the chrome side.\n   *\n   * When supplied and it returns false, `editingId` reads as empty — the\n   * overlay stops drawing, the anchors stop being hittable, and the\n   * anchor selection is dropped. This is what makes leaving path-edit\n   * mode by ANY route (Escape, breadcrumb, a consumer calling\n   * `exitMode()` directly) tear down edit state, rather than only the one\n   * route that happens to reach `exitPathEditAction`.\n   */\n  anchorEditingAllowed?: () => boolean;\n}\n\n/** Resolve where a node's editable polygon lives. Returns null when the\n *  node has neither a polygon pose nor a polygon on `data.path`. */\nfunction classifyStorage(\n  node: { pose: unknown; data: unknown } | undefined | null,\n): { kind: 'pose' } | { kind: 'data'; pose: RectPose; data: { path: PolygonPath } } | null {\n  if (!node) return null;\n  const pose = node.pose as { kind?: string } | undefined;\n  if (pose?.kind === 'polygon') return { kind: 'pose' };\n  const data = node.data as { path?: Path } | null;\n  if (data?.path && (data.path as { kind?: string }).kind === 'polygon' && isRectPose(node.pose)) {\n    return {\n      kind: 'data',\n      pose: node.pose,\n      data: data as { path: PolygonPath },\n    };\n  }\n  return null;\n}\n\n/** Resolve a node's editable polygon in world coords. Shared between the\n *  dep source and SceneCanvas's chrome wiring so both apply the same\n *  \"pose IS the polygon vs data.path with rect pose\" routing. Does NOT\n *  consult any preview state — callers that want live state read\n *  in-flight handles themselves. */\nexport function resolveEditablePathOf(\n  node: { pose: unknown; data: unknown } | undefined | null,\n): PolygonPath | null {\n  if (!node) return null;\n  const storage = classifyStorage(node);\n  if (!storage) return null;\n  // Pose-as-polygon: the pose IS the polygon (polygon poses can't carry\n  // rotation), so it's already world.\n  if (storage.kind === 'pose') return (node as { pose: PolygonPath }).pose;\n  // data.path: project to world via the world seam — translate to the pose\n  // origin AND bake `pose.rotation`, so anchors render on the rotated contour\n  // the renderer draws (not the unrotated one).\n  return pathInWorld(storage.data.path, storage.pose) as PolygonPath;\n}\n\nconst EMPTY_ANCHOR_SELECTION: ReadonlySet<number> = new Set<number>();\n\nexport function useEditAnchorsDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  adapter: OpsApplier,\n  externalState?: EditAnchorsStateRef,\n  options?: EditAnchorsDepOptions,\n): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n  const allowedRef = useLatest(options?.anchorEditingAllowed);\n\n  const [localEditingId, setLocalEditingIdState] = useState<string>('');\n  const setLocalEditingId = useCallback((id: string | null) => {\n    setLocalEditingIdState(id ?? '');\n  }, []);\n  const externalRef = useLatest(externalState);\n  const setLocalEditingIdRef = useLatest(setLocalEditingId);\n\n  const readEditingId = (): string => {\n    return externalRef.current ? externalRef.current.getEditingId() : localEditingId;\n  };\n\n  useDepSource('editAnchors', (): EditAnchorsDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n    const s = selectionRef.current;\n    const ext = externalRef.current;\n    let effectiveId = readEditingId();\n    if (effectiveId) {\n      const node = sc.get(effectiveId as NodeId);\n      const inSelection = (s.current as NodeId[]).includes(effectiveId as NodeId);\n      // A mode registry that no longer permits `edits-anchors` revokes\n      // edit mode wholesale — see EditAnchorsDepOptions.anchorEditingAllowed.\n      const permitted = allowedRef.current ? allowedRef.current() : true;\n      if (!node || !inSelection || !permitted) effectiveId = '';\n    }\n    // Anchor selection and the marquee belong to one specific edited\n    // node. The moment `editingId` reads as empty — exited, deselected,\n    // deleted, or revoked by a mode change — they are stale by\n    // definition, so never hand them out alongside an empty id.\n    const selectedAnchors = effectiveId\n      ? (ext?.getSelectedAnchors() ?? EMPTY_ANCHOR_SELECTION)\n      : EMPTY_ANCHOR_SELECTION;\n    const marquee = effectiveId ? (ext?.getMarquee() ?? null) : null;\n  const editOps = (id: string, worldPath: unknown, label: string): Op[] => {\n      const wp = worldPath as PolygonPath;\n      const node = sc.get(id as NodeId);\n      if (!node) return [];\n      const storage = classifyStorage(node as { pose: unknown; data: unknown });\n      if (!storage) return [];\n      if (storage.kind === 'pose') return [createTransformOp({ id, from: node.pose, to: wp, label })];\n      // Edited path arrives in world coords (rotation baked in by\n      // resolveEditablePathOf); invert it back to the unrotated stored\n      // shape so `pose.rotation` is preserved and edits round-trip.\n      const { pose: newPose, path: aligned } = worldEditToStorage(storage.pose, wp);\n      return [\n        createTransformOp({ id, from: node.pose, to: newPose, label }),\n        createSetDataOp({ id, from: node.data, to: { ...(node.data as object), path: aligned }, label }),\n      ];\n    };\n    return {\n      editingId: effectiveId,\n      setEditingId(id: string | null) {\n        const next = id ?? '';\n        if (effectiveId !== next) {\n          recordModeSwitch(\n            'editAnchors.editingId',\n            effectiveId || null,\n            next || null,\n            next ? 'enter' : 'exit',\n          );\n          // Anchor indices only mean something relative to one path.\n          ext?.setSelectedAnchors(EMPTY_ANCHOR_SELECTION);\n          ext?.setMarquee(null);\n        }\n        if (externalRef.current) externalRef.current.setEditingId(id);\n        else setLocalEditingIdRef.current(id);\n      },\n      selectedAnchors,\n      setSelectedAnchors(next: Iterable<number>) {\n        if (!effectiveId) return;\n        ext?.setSelectedAnchors(new Set(next));\n      },\n      marquee,\n      setMarquee(rect) {\n        if (!effectiveId) return;\n        ext?.setMarquee(rect);\n      },\n      getEditablePath(id: string): PolygonPath | null {\n        const node = sc.get(id as NodeId);\n        return resolveEditablePathOf(node as { pose: unknown; data: unknown });\n      },\n      getStorageKind(id: string): 'pose' | 'data' | null {\n        const node = sc.get(id as NodeId);\n        const storage = classifyStorage(node as { pose: unknown; data: unknown });\n        return storage?.kind ?? null;\n      },\n      getNodeShape(id: string): { pose: unknown; data: unknown } | null {\n        const node = sc.get(id as NodeId);\n        if (!node) return null;\n        return { pose: node.pose, data: node.data };\n      },\n      applyEdit(id: string, worldPath: unknown, label: string) {\n        const ops = editOps(id, worldPath, label);\n        if (ops.length > 0) ad.applyOps(ops, label);\n      },\n      editOps,\n    };\n  });\n}\n"],"mappings":"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"}

package/dist/canvas/deps/geometryProjection.js

@@ -0,0 +1,11 @@
+import { useLatest as e } from "@weasel-js/react";
+import { useDepSource as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/geometryProjection.ts
+function n(n) {
+	let r = e(n);
+	t("geometryProjection", () => r.current);
+}
+//#endregion
+export { n as useGeometryProjection };
+
+//# sourceMappingURL=geometryProjection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometryProjection.js","names":["useGeometryProjection","ref","useLatest","projection"],"sources":["../../../src/canvas/deps/geometryProjection.ts"],"sourcesContent":["/**\n * `useGeometryProjection` — wires the `geometryProjection` dep consumed by\n * pose-transform actions (move, resize, nudge, flip).\n *\n * When the prop is absent (`undefined`), calling this hook with `undefined`\n * registers a source that returns `undefined`, which is indistinguishable from\n * no registration — actions treat a missing dep as \"no geometry rewrite\".\n * The canonical usage is to mount a `<GeometryProjectionRegistrar>` only when\n * the consumer has supplied a projection, which avoids registering at all.\n *\n * @see GeometryProjection — the dep schema entry.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\n\nexport function useGeometryProjection(\n  projection: GeometryProjection | undefined,\n): void {\n  const ref = useLatest(projection);\n  useDepSource('geometryProjection', () => ref.current);\n}\n"],"mappings":";;;AAgBA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,4BAA4BF,EAAI,OAAO;AACtD"}