@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/canvasRenderer.js

@@ -1,89 +1,101 @@
-import { WeaselRenderer as e } from "../renderer/WeaselRenderer.js";
-import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
+import { WeaselRenderer as e } from "@weasel-js/renderer";
+import { viewToMat3 as t } from "@weasel-js/geom";
+import { createEmitter as n } from "@weasel-js/registry";
 //#region src/canvas/canvasRenderer.ts
-var n = /* @__PURE__ */ new WeakMap(), r = (e) => e?.map((e) => e.id).join("|") ?? "";
-function i(e, t) {
+var r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakSet(), a = (e) => e?.map((e) => e.id).join("|") ?? "";
+function o(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 s(e) {
+	let t = r.get(e.canvas);
+	t?.delete(e.renderer), e.canvas.removeEventListener("webglcontextlost", e.onLost), e.canvas.removeEventListener("webglcontextrestored", e.onRestored), t && t.size === 0 && r.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);
+function c() {
+	let c = null, l = n(), u = (t, n, u = {}) => {
+		let { width: d, height: f } = n, p = n.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), m = u.tile ?? null, h = m !== null;
+		if (c && (c.canvas !== t || c.shared !== h) && (s(c), c = null), c) (!h && (t.width !== Math.round(d * p) || t.height !== Math.round(f * p)) || c.width !== d || c.height !== f || c.dpr !== p) && (c.renderer.resize({
+			width: d,
+			height: f,
+			dpr: p
+		}), c.width = d, c.height = f, c.dpr = p), c.flattenTolerance !== u.flattenTolerance && (c.renderer.setFlattenTolerance(u.flattenTolerance), c.flattenTolerance = u.flattenTolerance);
 		else {
-			let r = t.getContext("webgl2", {
+			if (i.has(t)) return null;
+			let n = t.getContext("webgl2", {
 				preserveDrawingBuffer: !0,
 				stencil: !0
 			});
-			if (!r || typeof r.enable != "function") return null;
-			let i;
+			if (!n || typeof n.enable != "function") return null;
+			let a;
 			try {
-				i = new e({
-					gl: r,
-					...p ? {} : { canvas: t },
-					width: l,
-					height: u,
-					dpr: d,
-					flattenTolerance: c.flattenTolerance
+				a = new e({
+					gl: n,
+					...h ? {} : { canvas: t },
+					width: d,
+					height: f,
+					dpr: p,
+					flattenTolerance: u.flattenTolerance
 				});
-			} catch {
-				return null;
+			} catch (e) {
+				return n.isContextLost?.() || (i.add(t), console.warn("weasel: this canvas cannot be painted:", e)), null;
 			}
-			o = {
+			let o = c = {
 				canvas: t,
-				renderer: i,
-				shared: p,
-				width: l,
-				height: u,
-				dpr: d,
+				renderer: a,
+				shared: h,
+				width: d,
+				height: f,
+				dpr: p,
 				tileX: null,
 				tileY: null,
-				flattenTolerance: c.flattenTolerance,
-				shaderKey: ""
+				flattenTolerance: u.flattenTolerance,
+				shaderKey: "",
+				lost: !1,
+				onLost: () => {
+					o.lost = !0;
+				},
+				onRestored: () => {
+					o.lost = !1, l.emit();
+				}
 			};
-			let a = n.get(t);
-			a || (a = /* @__PURE__ */ new Set(), n.set(t, a)), a.add(i);
+			t.addEventListener("webglcontextlost", c.onLost), t.addEventListener("webglcontextrestored", c.onRestored);
+			let s = r.get(t);
+			s || (s = /* @__PURE__ */ new Set(), r.set(t, s)), s.add(a);
 		}
-		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;
+		if (c.lost) return null;
+		let { renderer: g } = c, _ = a(u.shaders);
+		_ !== c.shaderKey && (o(g, u.shaders), c.shaderKey = _);
+		let v = m?.x ?? null, y = m?.y ?? null;
+		return (v !== c.tileX || y !== c.tileY) && (g.setTarget(m ? { origin: {
+			x: m.x,
+			y: m.y
+		} } : null), c.tileX = v, c.tileY = y), g;
 	};
 	return {
-		bind: s,
+		bind: u,
 		paint(e, n, r, i, a) {
-			let o = s(e, i, a);
+			let o = u(e, i, a);
 			return o ? (o.render(n, t(r), a?.render), !0) : !1;
 		},
+		subscribeRestored: l.subscribe,
 		release() {
-			o && a(o), o = null;
+			c && s(c), c = 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);
+var l = /* @__PURE__ */ new WeakMap();
+function u(e, t, n, r) {
+	let i = l.get(e);
+	return i || (i = c(), l.set(e, i)), i.paint(e, t, n, r);
 }
-function l(e) {
-	let t = s.get(e);
-	t && (s.delete(e), t.release());
+function d(e) {
+	let t = l.get(e);
+	t && (l.delete(e), t.release());
 }
 //#endregion
-export { o as leaseCanvasRenderer, c as paintCanvas, l as releaseCanvasRenderer };
+export { c as leaseCanvasRenderer, u as paintCanvas, d as releaseCanvasRenderer, a as shaderKeyOf };
 
 //# sourceMappingURL=canvasRenderer.js.map

package/dist/canvas/canvasRenderer.js.map

@@ -1 +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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"}
+{"version":3,"file":"canvasRenderer.js","names":["viewToMat3","viewToMat3$1","TENANTS","REFUSED","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","restored","createEmitter","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","mine","shaderKey","tileX","tileY","commands","view","CANVAS_LEASES","paintCanvas","lease","releaseCanvasRenderer"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease.\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 '@weasel-js/renderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport { createEmitter } from '@weasel-js/registry';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** Canvases whose context the renderer refused, so a redraw does not rebuild\n *  and fail again, and the reason is reported once. */\nconst REFUSED: WeakSet<HTMLCanvasElement> = new WeakSet();\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, a failed context creation,\n   *  or a context that is lost for now). */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Run `fn` when the canvas gets a lost context back, after the renderer\n   *  has rebuilt itself on it. Nothing repaints a restored buffer on its own.\n   *  Returns an unsubscribe. */\n  subscribeRestored(fn: () => void): () => void;\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  lost: boolean;\n  onLost: () => void;\n  onRestored: () => void;\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\n/** Identifies a set of custom programs by their ids, in order. */\nexport const 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  held.canvas.removeEventListener('webglcontextlost', held.onLost);\n  held.canvas.removeEventListener('webglcontextrestored', held.onRestored);\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 restored = createEmitter();\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      if (REFUSED.has(canvas)) return null;\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 (e) {\n        // A lost context fails to compile and may yet come back; anything\n        // else fails the same way next time.\n        if (!(gl as Partial<WebGL2RenderingContext>).isContextLost?.()) {\n          REFUSED.add(canvas);\n          console.warn('weasel: this canvas cannot be painted:', e);\n        }\n        return null;\n      }\n      // Added after the renderer's own listeners, so a subscriber runs against\n      // a renderer that has already recompiled.\n      const mine: Held = held = {\n        canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, shaderKey: '',\n        lost: false,\n        onLost: () => { mine.lost = true; },\n        onRestored: () => {\n          mine.lost = false;\n          restored.emit();\n        },\n      };\n      canvas.addEventListener('webglcontextlost', held.onLost);\n      canvas.addEventListener('webglcontextrestored', held.onRestored);\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      // React writes the element's `width` and `height` attributes in CSS\n      // pixels on every size change, so a size that went away and came back\n      // matches the record while the buffer does not.\n      const stale = !shared\n        && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr));\n      if (stale || 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    if (held.lost) return null;\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    subscribeRestored: restored.subscribe,\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. The renderer lives until\n * `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.map

@@ -1 +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"}
+{"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 '@weasel-js/animator';\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

@@ -1,5 +1,5 @@
-import { textCommandFromRuns as e } from "../features/text/textCommand.js";
-import { findNodeShape as t, findShapeBounds as n } from "./NodeShape.js";
+import { findNodeShape as e, findShapeBounds as t } from "./NodeShape.js";
+import { textCommandFromRuns as n } from "@weasel-js/renderer";
 //#region src/canvas/defaultDrawOne.ts
 function r(e) {
 	let t = typeof window < "u" && window.devicePixelRatio || 1;
@@ -10,19 +10,19 @@ 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 ? {
+function s(t, i, a, s) {
+	let c = e(t), l = !a || s?.pixelScale !== void 0 ? s : s ? {
 		...s,
 		pixelScale: r(a)
-	} : o(a), u = c ? c.paint(n, i, l) : [], d = n.data;
+	} : o(a), u = c ? c.paint(t, i, l) : [], d = t.data;
 	if (d?.label && d.text == null) {
-		let t = i;
-		return [...u, e(t.x + 6, t.y + 14, [{
+		let e = i;
+		return [...u, n(e.x + 6, e.y + 14, [{
 			text: d.label,
-			fill: {
-				fill: "solid",
+			fill: { paint: {
+				kind: "solid",
 				color: "rgba(0,0,0,0.7)"
-			}
+			} }
 		}], {
 			fontFamily: "sans-serif",
 			fontSize: 11
@@ -30,11 +30,11 @@ function s(n, i, a, s) {
 	}
 	return u;
 }
-function c(e, t, r) {
+function c(e, n, r) {
 	let i = e.data;
 	if (i?.label && i.text == null) return null;
 	let a = Math.abs(r.scale.x), o = Math.abs(r.scale.y);
-	return n(e, t, {
+	return t(e, n, {
 		scale: Math.sqrt(a * o),
 		leastScale: Math.min(a, o)
 	});

package/dist/canvas/defaultDrawOne.js.map

@@ -1 +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","sx","sy","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  const sx = Math.abs(view.scale.x), sy = Math.abs(view.scale.y);\n  return findShapeBounds(node, pose, { scale: Math.sqrt(sx * sy), leastScale: Math.min(sx, sy) });\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;CAClB,IAAIK,GAAM,SAASA,EAAK,QAAQ,MAAM,OAAO;CAC7C,IAAMI,IAAK,KAAK,IAAIjB,EAAK,MAAM,CAAC,GAAGkB,IAAK,KAAK,IAAIlB,EAAK,MAAM,CAAC;CAC7D,OAAOmB,EAAgBX,GAAMI,GAAM;EAAE,OAAO,KAAK,KAAKK,IAAKC,CAAE;EAAG,YAAY,KAAK,IAAID,GAAIC,CAAE;CAAE,CAAC;AAChG;AAOA,SAAgBE,EACd,GAC6D;CAC7D,OAAOC,MAAYhB,IAAiBW,IAAqB,KAAA;AAC3D"}
+{"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","sx","sy","findShapeBounds","paintBoundsFor","drawOne"],"sources":["../../src/canvas/defaultDrawOne.ts"],"sourcesContent":["/**\n * The kit's default per-node draw function, kept apart from `SceneCanvas.tsx` so non-React\n * callers (headless rasterization via `renderSceneToPixels`) can use it without importing the\n * React component tree.\n *\n * To teach the kit about a new kind of shape, register a painter (`registerNodeShape`) — do not\n * override `drawOne`. Override `drawOne` only for cross-cutting decoration.\n */\nimport type { Node } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { textCommandFromRuns } from '@weasel-js/renderer';\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: { paint: { kind: '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 `wrapNodeOutput` in\n  // the scene walks and the preview-ghost layer, so that consumer-supplied painters get\n  // them too.\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  const sx = Math.abs(view.scale.x), sy = Math.abs(view.scale.y);\n  return findShapeBounds(node, pose, { scale: Math.sqrt(sx * sy), leastScale: Math.min(sx, sy) });\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":";;;AAeA,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,EAAE,OAAO;IAAE,MAAM;IAAS,OAAO;GAAkB,EAAE;EAAE,CAAC,GACnF;GAAE,YAAY;GAAc,UAAU;EAAG,CAC3C,CAAC;CACH;CAKA,OAAOF;AACT;AAQA,SAAgBK,EACd,GACA,GACA,GACe;CACf,IAAMH,IAAOL,EAAK;CAClB,IAAIK,GAAM,SAASA,EAAK,QAAQ,MAAM,OAAO;CAC7C,IAAMI,IAAK,KAAK,IAAIjB,EAAK,MAAM,CAAC,GAAGkB,IAAK,KAAK,IAAIlB,EAAK,MAAM,CAAC;CAC7D,OAAOmB,EAAgBX,GAAMI,GAAM;EAAE,OAAO,KAAK,KAAKK,IAAKC,CAAE;EAAG,YAAY,KAAK,IAAID,GAAIC,CAAE;CAAE,CAAC;AAChG;AAOA,SAAgBE,EACd,GAC6D;CAC7D,OAAOC,MAAYhB,IAAiBW,IAAqB,KAAA;AAC3D"}

package/dist/canvas/deps/areaSelect.js

@@ -2,12 +2,12 @@ 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);
+function i(i, a, o, s) {
+	let c = n(i), l = n(a), u = n(o), d = n(s);
 	r("areaSelect", () => {
-		let n = l.current, r = u.current, i = d.current, a = f.current;
+		let n = c.current, r = l.current, i = u.current, a = d.current;
 		return {
-			hitTestArea: (r, o) => e(n, r, t(o, a, s), i),
+			hitTestArea: (r, o) => e(n, r, t(o, a), i),
 			getSelection: () => r.current,
 			setSelection: (e) => r.set(e)
 		};

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

@@ -1 +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"}
+{"version":3,"file":"areaSelect.js","names":["hitTestAreaShared","useAreaSelectDepSource","sceneRef","useLatest","scene","selectionRef","selection","descriptorRef","descriptor","alphaOfRef","alphaOf","sc","s","d","hitTestArea","bounds","regionPickOptions","view","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';\n\nexport function useAreaSelectDepSource(\n  scene: Scene<unknown, string, unknown>,\n  selection: SelectionApi,\n  descriptor?: PoseDescriptor<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), d),\n      getSelection: () => s.current as NodeId[],\n      setSelection: (ids) => s.set(ids),\n    };\n  });\n}\n"],"mappings":";;;;AAmBA,SAAgBC,EACd,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,CAAC,GAAGJ,CAAC;GAC7D,oBAAoBD,EAAE;GACtB,eAAe,MAAQA,EAAE,IAAIM,CAAG;EAClC;CACF,CAAC;AACH"}

package/dist/canvas/deps/changes.js

@@ -0,0 +1,13 @@
+import { useEffect as e } from "react";
+import { useDepRegistry as t } from "@weasel-js/routing/react";
+//#region src/canvas/deps/changes.ts
+function n(n, r) {
+	let i = t();
+	e(() => n.subscribe(() => i.changed?.()), [n, i]), e(() => {
+		i.changed?.();
+	}, [i, r]);
+}
+//#endregion
+export { n as useDepChangeNotices };
+
+//# sourceMappingURL=changes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"changes.js","names":["useDepChangeNotices","registry","useDepRegistry","useEffect","scene","selected"],"sources":["../../../src/canvas/deps/changes.ts"],"sourcesContent":["/**\n * `useDepChangeNotices` — tells the dep registry when the scene or the\n * selection changed. Sources are thunks, so nothing else lets chrome showing\n * an action's `enabled` or `active` state know to read them again.\n */\nimport { useEffect } from 'react';\nimport { useDepRegistry } from '@weasel-js/routing/react';\n\nexport function useDepChangeNotices(\n  scene: { subscribe(listener: () => void): () => void },\n  selected: readonly unknown[],\n): void {\n  const registry = useDepRegistry();\n  useEffect(() => scene.subscribe(() => registry.changed?.()), [scene, registry]);\n  useEffect(() => { registry.changed?.(); }, [registry, selected]);\n}\n"],"mappings":";;;AAQA,SAAgBA,EACd,GACA,GACM;CACN,IAAMC,IAAWC,EAAe;CAEhC,AADAC,QAAgBC,EAAM,gBAAgBH,EAAS,UAAU,CAAC,GAAG,CAACG,GAAOH,CAAQ,CAAC,GAC9EE,QAAgB;EAAE,EAAS,UAAU;CAAG,GAAG,CAACF,GAAUI,CAAQ,CAAC;AACjE"}

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

@@ -1 +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"}
+{"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 debug overlay that canvas\n * draws. Resolved at invocation, because the canvas creates its sink after\n * 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/editAnchors.js

@@ -1,84 +1,65 @@
 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";
+import { createPathEditState as n, isSelectedNode as r } from "../../features/paths/pathEditState.js";
+import { classifyPathStorage as i, resolveEditablePathOf as a } from "../../features/paths/editablePath.js";
+import { worldEditToStorage as o } from "@weasel-js/geom";
+import { useState as s } from "react";
+import { useLatest as c } from "@weasel-js/react";
+import { recordModeSwitch as l } from "@weasel-js/routing";
+import { useDepSource as u } 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);
+var d = /* @__PURE__ */ new Set();
+function f(f, p, m, h) {
+	let g = c(f), _ = c(p), v = c(m), [y] = s(() => n({ isSelectedNode: (e) => r(g.current, _.current, e) })), b = c(h ?? y);
+	u("editAnchors", () => {
+		let n = g.current, r = v.current, s = b.current, c = s.getEditingId(), u = c ? s.getSelectedAnchors() : d, f = c ? s.getMarquee() : null, p = (r, a, s) => {
+			let c = a, l = n.get(r);
 			if (!l) return [];
-			if (l.kind === "pose") return [e({
+			let u = i(l);
+			if (!u) return [];
+			if (u.kind === "pose") return [e({
 				id: r,
-				from: c.pose,
-				to: s,
-				label: o
+				from: l.pose,
+				to: c,
+				label: s
 			})];
-			let { pose: d, path: f } = i(l.pose, s);
+			let { pose: d, path: f } = o(u.pose, c);
 			return [e({
 				id: r,
-				from: c.pose,
+				from: l.pose,
 				to: d,
-				label: o
+				label: s
 			}), t({
 				id: r,
-				from: c.data,
+				from: l.data,
 				to: {
-					...c.data,
+					...l.data,
 					path: f
 				},
-				label: o
+				label: s
 			})];
 		};
 		return {
-			editingId: s,
+			editingId: c,
 			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);
+				c !== t && (l("editAnchors.editingId", c || null, t || null, t ? "enter" : "exit"), s.setSelectedAnchors(d), s.setMarquee(null)), b.current.setEditingId(e);
 			},
-			selectedAnchors: l,
+			selectedAnchors: u,
 			setSelectedAnchors(e) {
-				s && o?.setSelectedAnchors(new Set(e));
+				c && s.setSelectedAnchors(new Set(e));
 			},
-			marquee: p,
+			marquee: f,
 			setMarquee(e) {
-				s && o?.setMarquee(e);
+				c && s.setMarquee(e);
 			},
 			getEditablePath(e) {
-				return d(n.get(e));
+				let t = n.get(e);
+				return a(t);
 			},
 			getStorageKind(e) {
-				return u(n.get(e))?.kind ?? null;
+				let t = n.get(e);
+				return i(t)?.kind ?? null;
 			},
 			getNodeShape(e) {
 				let t = n.get(e);
@@ -88,14 +69,14 @@ function p(n, r, p, m, h) {
 				} : null;
 			},
 			applyEdit(e, t, n) {
-				let i = m(e, t, n);
+				let i = p(e, t, n);
 				i.length > 0 && r.applyOps(i, n);
 			},
-			editOps: m
+			editOps: p
 		};
 	});
 }
 //#endregion
-export { d as resolveEditablePathOf, p as useEditAnchorsDepSource };
+export { a as resolveEditablePathOf, f as useEditAnchorsDepSource };
 
 //# sourceMappingURL=editAnchors.js.map

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

@@ -1 +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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"}
+{"version":3,"file":"editAnchors.js","names":["EMPTY_ANCHOR_SELECTION","useEditAnchorsDepSource","sceneRef","useLatest","scene","selectionRef","selection","adapterRef","adapter","ownState","useState","createPathEditState","isSelectedNode","id","stateRef","externalState","sc","ad","state","effectiveId","selectedAnchors","marquee","editOps","wp","worldPath","node","storage","classifyPathStorage","createTransformOp","newPose","aligned","worldEditToStorage","createSetDataOp","next","recordModeSwitch","rect","resolveEditablePathOf","ops","label"],"sources":["../../../src/canvas/deps/editAnchors.ts"],"sourcesContent":["/**\n * `useEditAnchorsDepSource` — wires the `editAnchors` dep.\n *\n * A node's editable polygon lives in one of two places: the pose itself\n * (`pose.kind === 'polygon'`), or `data.path` with a rect pose, stored pose-local.\n * `getEditablePath` returns it in **world coords** either way, and `applyEdit` commits in the\n * correct storage shape as one undoable batch, preserving the render invariant\n * `pathInWorld(stored, pose) === world`. Live previews ride the standard\n * `OngoingHandle.previewIds/Pose/Data` triple — this dep doesn't own preview state.\n */\nimport { 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 } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { worldEditToStorage } from '@weasel-js/geom';\nimport { classifyPathStorage, resolveEditablePathOf } from 'features/paths/editablePath';\nimport { createPathEditState, isSelectedNode, type PathEditState } from 'features/paths/pathEditState';\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/** The part of a `PathEditState` the dep reads and writes. */\nexport type EditAnchorsStateRef = Omit<PathEditState, 'subscribe' | 'getEditingIds'>;\n\nexport { resolveEditablePathOf };\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): void {\n  const sceneRef = useLatest(scene);\n  const selectionRef = useLatest(selection);\n  const adapterRef = useLatest(adapter);\n\n  // A caller that shares the state with nothing else gets one of its own.\n  const [ownState] = useState(() => createPathEditState({\n    isSelectedNode: (id) => isSelectedNode(sceneRef.current, selectionRef.current, id),\n  }));\n  const stateRef = useLatest(externalState ?? ownState);\n\n  useDepSource('editAnchors', (): EditAnchorsDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n    const state = stateRef.current;\n    const effectiveId = state.getEditingId();\n    // Anchor selection and the marquee belong to one specific edited node, so never\n    // hand them out alongside an empty id.\n    const selectedAnchors = effectiveId ? state.getSelectedAnchors() : EMPTY_ANCHOR_SELECTION;\n    const marquee = effectiveId ? state.getMarquee() : 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 = classifyPathStorage(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      // The edited path arrives in world coords; 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          state.setSelectedAnchors(EMPTY_ANCHOR_SELECTION);\n          state.setMarquee(null);\n        }\n        stateRef.current.setEditingId(id);\n      },\n      selectedAnchors,\n      setSelectedAnchors(next: Iterable<number>) {\n        if (!effectiveId) return;\n        state.setSelectedAnchors(new Set(next));\n      },\n      marquee,\n      setMarquee(rect) {\n        if (!effectiveId) return;\n        state.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 = classifyPathStorage(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":";;;;;;;;;;AAkCA,IAAMA,oBAA8C,IAAI,IAAY;AAEpE,SAAgBC,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAUC,CAAK,GAC1BC,IAAeF,EAAUG,CAAS,GAClCC,IAAaJ,EAAUK,CAAO,GAG9B,CAACC,KAAYC,QAAeC,EAAoB,EACpD,iBAAiB,MAAOC,EAAeV,EAAS,SAASG,EAAa,SAASQ,CAAE,EACnF,CAAC,CAAC,GACIC,IAAWX,EAAUY,KAAiBN,CAAQ;CAEpD,EAAa,qBAAqC;EAChD,IAAMO,IAAKd,EAAS,SACde,IAAKV,EAAW,SAChBW,IAAQJ,EAAS,SACjBK,IAAcD,EAAM,aAAa,GAGjCE,IAAkBD,IAAcD,EAAM,mBAAmB,IAAIlB,GAC7DqB,IAAUF,IAAcD,EAAM,WAAW,IAAI,MAC7CI,KAAW,GAAY,GAAoB,MAAwB;GACvE,IAAMC,IAAKC,GACLC,IAAOT,EAAG,IAAIH,CAAY;GAChC,IAAI,CAACY,GAAM,OAAO,CAAC;GACnB,IAAMC,IAAUC,EAAoBF,CAAwC;GAC5E,IAAI,CAACC,GAAS,OAAO,CAAC;GACtB,IAAIA,EAAQ,SAAS,QAAQ,OAAO,CAACE,EAAkB;IAAE;IAAI,MAAMH,EAAK;IAAM,IAAIF;IAAI;GAAM,CAAC,CAAC;GAG9F,IAAM,EAAE,MAAMM,GAAS,MAAMC,MAAYC,EAAmBL,EAAQ,MAAMH,CAAE;GAC5E,OAAO,CACLK,EAAkB;IAAE;IAAI,MAAMH,EAAK;IAAM,IAAII;IAAS;GAAM,CAAC,GAC7DG,EAAgB;IAAE;IAAI,MAAMP,EAAK;IAAM,IAAI;KAAE,GAAIA,EAAK;KAAiB,MAAMK;IAAQ;IAAG;GAAM,CAAC,CACjG;EACF;EACA,OAAO;GACL,WAAWX;GACX,aAAa,GAAmB;IAC9B,IAAMc,IAAOpB,KAAM;IAYnB,AAXIM,MAAgBc,MAClBC,EACE,yBACAf,KAAe,MACfc,KAAQ,MACRA,IAAO,UAAU,MACnB,GAEAf,EAAM,mBAAmBlB,CAAsB,GAC/CkB,EAAM,WAAW,IAAI,IAEvBJ,EAAS,QAAQ,aAAaD,CAAE;GAClC;GACA;GACA,mBAAmB,GAAwB;IACzC,AAAKM,KACLD,EAAM,mBAAmB,IAAI,IAAIe,CAAI,CAAC;GACxC;GACA;GACA,WAAW,GAAM;IACf,AAAKd,KACLD,EAAM,WAAWiB,CAAI;GACvB;GACA,gBAAgB,GAAgC;IAC9C,IAAMV,IAAOT,EAAG,IAAIH,CAAY;IAChC,OAAOuB,EAAsBX,CAAwC;GACvE;GACA,eAAe,GAAoC;IACjD,IAAMA,IAAOT,EAAG,IAAIH,CAAY;IAEhC,OADgBc,EAAoBF,CAC7B,CAAA,EAAS,QAAQ;GAC1B;GACA,aAAa,GAAqD;IAChE,IAAMA,IAAOT,EAAG,IAAIH,CAAY;IAEhC,OADKY,IACE;KAAE,MAAMA,EAAK;KAAM,MAAMA,EAAK;IAAK,IADxB;GAEpB;GACA,UAAU,GAAY,GAAoB,GAAe;IACvD,IAAMY,IAAMf,EAAQT,GAAIW,GAAWc,CAAK;IACxC,AAAID,EAAI,SAAS,KAAGpB,EAAG,SAASoB,GAAKC,CAAK;GAC5C;GACA;EACF;CACF,CAAC;AACH"}

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

@@ -1 +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"}
+{"version":3,"file":"geometryProjection.js","names":["useGeometryProjection","ref","useLatest","projection"],"sources":["../../../src/canvas/deps/geometryProjection.ts"],"sourcesContent":["/**\n * Wires the `geometryProjection` dep consumed by pose-transform actions.\n * A source that returns `undefined` is indistinguishable from no registration:\n * actions treat a missing dep as \"no geometry rewrite\".\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":";;;AASA,SAAgBA,EACd,GACM;CACN,IAAMC,IAAMC,EAAUC,CAAU;CAChC,EAAa,4BAA4BF,EAAI,OAAO;AACtD"}