@weasel-js/core 1.9.3 → 1.9.4

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":";;;AAoBA,IAAMA,oBAA2D,IAAI,QAAQ,GAyEvEC,KAAe,MACnBC,GAAS,KAAK,MAAMC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,KAAK;AAEzC,SAASC,EAAgB,GAA0B,GAA2D;CAC5G,IAAKF,GACL,KAAK,IAAMG,KAAUH,GACnB,IAAI;EACF,EAAS,gBAAgBG,CAAM;CACjC,SAAS,GAAG;EACV,QAAQ,KAAK,sCAAsCA,EAAO,GAAG,KAAK,CAAC;CACrE;AAEJ;AAEA,SAASC,EAAK,GAAkB;CAC9B,IAAMC,IAAMP,EAAQ,IAAIQ,EAAK,MAAM;CAGnC,AAFAD,GAAK,OAAOC,EAAK,QAAQ,GACrBD,KAAOA,EAAI,SAAS,KAAGP,EAAQ,OAAOQ,EAAK,MAAM,GACrDA,EAAK,SAAS,QAAQ;AACxB;AAGA,SAAgBC,IAA2C;CACzD,IAAID,IAAoB,MAClBE,KAAQ,GAA2B,GAAuB,IAA8B,CAAC,MAA6B;EAC1H,IAAM,EAAE,UAAO,cAAWC,GACpBC,IAAMD,EAAK,QAAQ,OAAO,SAAW,OAAc,OAAO,oBAAwB,IAClFE,IAAOC,EAAQ,QAAQ,MACvBC,IAASF,MAAS;EAMxB,IAJIL,MAASA,EAAK,WAAWQ,KAAUR,EAAK,WAAWO,OACrDT,EAAKE,CAAI,GACT,IAAO,OAEJA,GA0BH,CANIA,EAAK,UAAUS,KAAST,EAAK,WAAWU,KAAUV,EAAK,QAAQI,OACjEJ,EAAK,SAAS,OAAO;GAAE;GAAO;GAAQ;EAAI,CAAC,GAC3C,EAAK,QAAQS,GACb,EAAK,SAASC,GACd,EAAK,MAAMN,IAETJ,EAAK,qBAAqBM,EAAQ,qBACpCN,EAAK,SAAS,oBAAoBM,EAAQ,gBAAgB,GAC1D,EAAK,mBAAmBA,EAAQ;OA5BzB;GACT,IAAMK,IAAKH,EAAO,WAAW,UAAU;IAAE,uBAAuB;IAAM,SAAS;GAAK,CAAC;GACrF,IAAI,CAACG,KAAM,OAAQA,EAAuC,UAAW,YAAY,OAAO;GACxF,IAAIC;GACJ,IAAI;IACF,IAAW,IAAIC,EAAe;KACxB;KACJ,GAAIN,IAAS,CAAC,IAAI,EAAE,UAAO;KAC3B;KAAO;KAAQ;KACf,kBAAkBD,EAAQ;IAC5B,CAAC;GACH,QAAQ;IACN,OAAO;GACT;GACA,IAAO;IAAE;IAAQ;IAAU;IAAQ;IAAO;IAAQ;IAAK,OAAO;IAAM,OAAO;IACzE,kBAAkBA,EAAQ;IAAkB,WAAW;GAAG;GAC5D,IAAIP,IAAMP,EAAQ,IAAIgB,CAAM;GAE5B,AADKT,MAAO,oBAAM,IAAI,IAAI,GAAGP,EAAQ,IAAIgB,GAAQT,CAAG,IACpDA,EAAI,IAAIa,CAAQ;EAClB;EAaA,IAAM,EAAE,gBAAaZ,GACfc,IAAYrB,EAAYa,EAAQ,OAAO;EAC7C,AAAIQ,MAAcd,EAAK,cACrBJ,EAAgBgB,GAAUN,EAAQ,OAAO,GACzC,EAAK,YAAYQ;EAEnB,IAAMC,IAAQV,GAAM,KAAK,MACnBW,IAAQX,GAAM,KAAK;EAMzB,QALIU,MAAUf,EAAK,SAASgB,MAAUhB,EAAK,WACzCY,EAAS,UAAUP,IAAO,EAAE,QAAQ;GAAE,GAAGA,EAAK;GAAG,GAAGA,EAAK;EAAE,EAAE,IAAI,IAAI,GACrE,EAAK,QAAQU,GACb,EAAK,QAAQC,IAERJ;CACT;CACA,OAAO;EACL;EACA,MAAM,GAAQ,GAAU,GAAM,GAAM,GAAS;GAC3C,IAAMA,IAAWV,EAAKM,GAAQL,GAAMG,CAAO;GAG3C,OAFKM,KACLA,EAAS,OAAOK,GAAUC,EAAWC,CAAI,GAAGb,GAAS,MAAM,GACpD,MAFe;EAGxB;EACA,UAAU;GAER,AADIN,KAAMF,EAAKE,CAAI,GACnB,IAAO;EACT;CACF;AACF;AAGA,IAAMoB,oBAAiE,IAAI,QAAQ;AAOnF,SAAgBC,EACd,GACA,GACA,GACA,GACS;CACT,IAAIC,IAAQF,EAAc,IAAIZ,CAAM;CAKpC,OAJKc,MACH,IAAQrB,EAAoB,GAC5BmB,EAAc,IAAIZ,GAAQc,CAAK,IAE1BA,EAAM,MAAMd,GAAQS,GAAUE,GAAMhB,CAAI;AACjD;AAKA,SAAgBoB,EAAsB,GAAiC;CACrE,IAAMD,IAAQF,EAAc,IAAIZ,CAAM;CACtC,AAAKc,MACLF,EAAc,OAAOZ,CAAM,GAC3Bc,EAAM,QAAQ;AAChB"}
+{"version":3,"file":"canvasRenderer.js","names":["TENANTS","REFUSED","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","restoredSubs","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","mine","fn","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/** 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), so a caller can skip building a frame\n   *  nobody will see. */\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\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  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 restoredSubs = new Set<() => void>();\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          for (const fn of [...restoredSubs]) fn();\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(fn) {\n      restoredSubs.add(fn);\n      return () => { restoredSubs.delete(fn); };\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/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/editAnchors.js

@@ -1,7 +1,7 @@
 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 { isRectPose as t } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { pathInWorld as n, worldEditToStorage as r } from "../../features/paths/pathInWorld.js";
+import { createSetDataOp as i } from "../../core/ops/setData.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";
@@ -10,48 +10,48 @@ import { useDepSource as l } from "@weasel-js/routing/react";
 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) ? {
+	let n = e.data;
+	return n?.path && n.path.kind === "polygon" && t(e.pose) ? {
 		kind: "data",
 		pose: e.pose,
-		data: t
+		data: n
 	} : 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;
+	return t ? t.kind === "pose" ? e.pose : n(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) => {
+function p(t, n, p, m, h) {
+	let g = s(t), _ = s(n), 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();
+		let t = g.current, n = 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 e = t.get(s), n = a.current.includes(s), r = !y.current || y.current();
+			(!e || !n || !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);
+		let l = s ? o?.getSelectedAnchors() ?? f : f, p = s ? o?.getMarquee() ?? null : null, m = (n, a, o) => {
+			let s = a, c = t.get(n);
 			if (!c) return [];
 			let l = u(c);
 			if (!l) return [];
 			if (l.kind === "pose") return [e({
-				id: r,
+				id: n,
 				from: c.pose,
 				to: s,
 				label: o
 			})];
-			let { pose: d, path: f } = i(l.pose, s);
+			let { pose: d, path: f } = r(l.pose, s);
 			return [e({
-				id: r,
+				id: n,
 				from: c.pose,
 				to: d,
 				label: o
-			}), t({
-				id: r,
+			}), i({
+				id: n,
 				from: c.data,
 				to: {
 					...c.data,
@@ -75,21 +75,21 @@ function p(n, r, p, m, h) {
 				s && o?.setMarquee(e);
 			},
 			getEditablePath(e) {
-				return d(n.get(e));
+				return d(t.get(e));
 			},
 			getStorageKind(e) {
-				return u(n.get(e))?.kind ?? null;
+				return u(t.get(e))?.kind ?? null;
 			},
 			getNodeShape(e) {
-				let t = n.get(e);
-				return t ? {
-					pose: t.pose,
-					data: t.data
+				let n = t.get(e);
+				return n ? {
+					pose: n.pose,
+					data: n.data
 				} : null;
 			},
-			applyEdit(e, t, n) {
-				let i = m(e, t, n);
-				i.length > 0 && r.applyOps(i, n);
+			applyEdit(e, t, r) {
+				let i = m(e, t, r);
+				i.length > 0 && n.applyOps(i, r);
 			},
 			editOps: m
 		};

package/dist/canvas/deps/insert.js

@@ -1,116 +1,144 @@
-import { asNodeId as e } from "../../core/scene/types.js";
-import { createInsertOp as t } from "../../core/ops/create.js";
-import { cycleFill as n, solid as r, strokeOf as i } from "../../util/paint.js";
-import { insertPreviewExtent as a } from "../insertPreviewExtent.js";
-import { ellipsePath as o, linePath as s, polygonFromPoints as c, rectPath as l, regularPolygonPath as u, schneiderFit as d, starPath as f } from "@weasel-js/geom";
-import { useRef as p } from "react";
-import { useLatest as m } from "@weasel-js/react";
-import { useDepSource as h } from "@weasel-js/routing/react";
+import { insertPreviewExtent as e } from "../insertPreviewExtent.js";
+import { cycleFill as t, solid as n, strokeOf as r } from "../../util/paint.js";
+import { createInsertOp as i } from "../../core/ops/create.js";
+import { ellipsePath as a, linePath as o, polygonFromPoints as s, rectPath as c, regularPolygonPath as l, schneiderFit as u, starPath as d } from "@weasel-js/geom";
+import { useRef as f } from "react";
+import { useLatest as p } from "@weasel-js/react";
+import { useDepSource as m } from "@weasel-js/routing/react";
 //#region src/canvas/deps/insert.ts
-function g(g, _, v) {
-	let y = m(g), b = m(_), x = m(v), S = p(0);
-	h("insert", () => {
-		let p = y.current, m = b.current, h = p.layers[0]?.id ?? "default";
-		return {
-			layer: () => h,
-			commit(g, _) {
-				let v = _.kind, y = ++S.current, b = e(`kit-${v}-${y}`);
-				for (; p.get(b) !== void 0;) y = ++S.current, b = e(`kit-${v}-${y}`);
-				let C = n(y), w = r(C), T = a({
-					shape: v,
-					bounds: g,
-					extras: _
-				}), E = T.bounds, D = x.current?.[v];
-				if (D) {
-					let e = D(g, _);
-					return e === null ? null : (m.applyOps([t({
+var h = (e, i) => {
+	let a = t(i);
+	return e === "pencil" ? { stroke: r(a, 2) } : e === "line" || e === "path" ? {
+		fill: n(a),
+		stroke: r(a, 2)
+	} : { fill: n(a) };
+};
+function g(t, n, r, g = h) {
+	let _ = p(t), v = p(n), y = p(r), b = p(g), x = f(0), S = f({ gesture: null });
+	m("insertLive", () => S.current), m("insert", () => {
+		let t = _.current, n = v.current, r = t.layers[0]?.id ?? "default", f = (n, f) => {
+			let p = f.kind, m = ++x.current, h = t.mintId(), g = (e = p) => {
+				let { fill: t, stroke: n } = b.current(e, m);
+				return {
+					...t === void 0 ? {} : { fill: t },
+					...n === void 0 ? {} : { stroke: n }
+				};
+			}, _ = e({
+				shape: p,
+				bounds: n,
+				extras: f
+			}), v = _.bounds, S = y.current?.[p];
+			if (S) {
+				let e = S(n, f);
+				return e === null ? null : {
+					id: h,
+					ops: [i({
 						node: {
-							id: b,
+							id: h,
 							kind: "leaf",
-							layer: h,
-							pose: e.pose ?? E,
+							layer: r,
+							pose: e.pose ?? v,
 							data: e.data
 						},
-						label: `Insert ${v}`
-					})], `Insert ${v}`), b);
+						label: `Insert ${p}`
+					})]
+				};
+			}
+			let C = _.geometry, w;
+			switch (C.kind) {
+				case "line":
+					w = {
+						path: o(C.a, C.b),
+						...g()
+					};
+					break;
+				case "polygon":
+					w = {
+						path: l(C.center, C.radius, C.sides, C.rotation),
+						...g()
+					};
+					break;
+				case "star":
+					w = {
+						path: d(C.center, C.outerRadius, C.points, C.innerRadius, C.rotation),
+						...g()
+					};
+					break;
+				case "pencil": {
+					let e = C.samples;
+					w = e.length >= 4 ? {
+						path: u(e, 2),
+						...g()
+					} : e.length >= 2 ? {
+						path: s(e),
+						...g()
+					} : {
+						path: c(0, 0, _.bounds.width, _.bounds.height),
+						...g("rect")
+					};
+					break;
 				}
-				let O = T.geometry, k;
-				switch (O.kind) {
-					case "line":
-						k = {
-							path: s(O.a, O.b),
-							fill: w,
-							stroke: i(C, 2)
+				case "box": switch (p) {
+					case "rect":
+						w = {
+							path: c(0, 0, _.bounds.width, _.bounds.height),
+							...g()
 						};
 						break;
-					case "polygon":
-						k = {
-							path: u(O.center, O.radius, O.sides, O.rotation),
-							fill: w
+					case "ellipse":
+						w = {
+							path: a(_.bounds),
+							...g()
 						};
 						break;
-					case "star":
-						k = {
-							path: f(O.center, O.outerRadius, O.points, O.innerRadius, O.rotation),
-							fill: w
-						};
-						break;
-					case "pencil": {
-						let e = O.samples;
-						k = e.length >= 4 ? {
-							path: d(e, 2),
-							stroke: i(C, 2)
-						} : e.length >= 2 ? {
-							path: c(e),
-							stroke: i(C, 2)
-						} : {
-							path: l(0, 0, T.bounds.width, T.bounds.height),
-							fill: w
+					case "path": {
+						let e = f;
+						w = {
+							path: e.path,
+							...g(),
+							...e.closed ? {} : { fill: null }
 						};
 						break;
 					}
-					case "box": switch (v) {
-						case "rect":
-							k = {
-								path: l(0, 0, T.bounds.width, T.bounds.height),
-								fill: w
-							};
-							break;
-						case "ellipse":
-							k = {
-								path: o(T.bounds),
-								fill: w
-							};
-							break;
-						case "text":
-							k = { text: _.text ?? "" };
-							break;
-						case "image": {
-							let e = _;
-							k = { image: {
-								src: e.src ?? "",
-								...e.opacity === void 0 ? {} : { opacity: e.opacity }
-							} };
-							break;
-						}
-						default: return console.warn(`weasel insertDep: no factory for kind="${v}". Skipping insert.`), null;
+					case "text":
+						w = { text: f.text ?? "" };
+						break;
+					case "image": {
+						let e = f;
+						w = { image: {
+							src: e.src ?? "",
+							...e.opacity === void 0 ? {} : { opacity: e.opacity }
+						} };
+						break;
 					}
+					default: return console.warn(`weasel insertDep: no factory for kind="${p}". Skipping insert.`), null;
 				}
-				return m.applyOps([t({
+			}
+			return {
+				id: h,
+				ops: [i({
 					node: {
-						id: b,
+						id: h,
 						kind: "leaf",
-						layer: h,
-						pose: E,
-						data: k
+						layer: r,
+						pose: v,
+						data: w
 					},
-					label: `Insert ${v}`
-				})], `Insert ${v}`), b;
+					label: `Insert ${p}`
+				})]
+			};
+		};
+		return {
+			layer: () => r,
+			build: f,
+			commit(e, t) {
+				let r = f(e, t);
+				return r === null ? null : (n.applyOps(r.ops, `Insert ${t.kind}`), r.id);
 			}
 		};
 	});
 }
 //#endregion
-export { g as useInsertDepSource };
+export { h as paletteInsertPaint, g as useInsertDepSource };
 
 //# sourceMappingURL=insert.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"insert.js","names":["e","useInsertDepSource","sceneRef","useLatest","scene","adapterRef","adapter","factoriesRef","factories","insertSeqRef","useRef","sc","ad","layer","kind","extras","seq","id","asNodeId","color","cycleFill","fill","solid","extent","insertPreviewExtent","pose","factory","built","bounds","createInsertOp","geom","data","linePath","strokeOf","regularPolygonPath","starPath","samples","schneiderFit","polygonFromPoints","rectPath","ellipsePath"],"sources":["../../../src/canvas/deps/insert.ts"],"sourcesContent":["/**\n * `useInsertDepSource` — wires the `insert` dep consumed by `insertAction`.\n *\n * Provides kit-side kind→data factories for the 6 builtin shape kinds\n * (`rect`, `ellipse`, `line`, `polygon`, `star`, `pencil`). Acceptable because\n * these kinds are kit-shipped tools; a future phase can expose a\n * `nodeFactories` prop for consumer-defined kinds.\n *\n * `line`, `polygon`, `star` and `pencil` receive the drag AABB from the\n * insertAction invoker, but `extras` may carry richer geometry (endpoints,\n * center+radius+rotation, point trail). `insertPreviewExtent` resolves the\n * two into the node's real extent — the same resolution the live preview\n * and the reported gesture bounds use.\n */\nimport { useRef } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { InsertDep, InsertExtras } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport {\n  rectPath,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  polygonFromPoints,\n  schneiderFit,\n} from '@weasel-js/geom';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * Consumer-supplied node factory for one insert `kind`. Given the drag AABB\n * and the tool's `extras`, returns the node's `data` (in the consumer's own\n * data shape) plus an optional `pose` override — the dep supplies id, layer,\n * and the undoable insert op. Return `null` to reject the insert.\n *\n * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the\n * kit's default `{ path, fill }` factory for that kind; a factory for a novel\n * kind adds support the kit doesn't ship (e.g. `text`). See\n * `SceneCanvas`'s `insertNodeFactories` prop.\n */\nexport type InsertNodeFactory = (\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n) => { data: unknown; pose?: unknown } | null;\n\nexport function useInsertDepSource(\n  scene: Scene<unknown, string, unknown>,\n  adapter: OpsApplier,\n  factories?: Record<string, InsertNodeFactory>,\n): void {\n  const sceneRef = useLatest(scene);\n  const adapterRef = useLatest(adapter);\n  const factoriesRef = useLatest(factories);\n  const insertSeqRef = useRef(0);\n\n  useDepSource('insert', (): InsertDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n\n    const layer = (sc.layers[0]?.id ?? 'default') as string;\n    return {\n      layer: () => layer,\n      commit(bounds, extras): NodeId | null {\n        const kind = extras.kind;\n        // Walk the seq counter forward until we land on an id that doesn't\n        // already exist in the scene. Handles two cases:\n        //   1. Fresh mount after localStorage rehydration — the scene starts\n        //      with `kit-${kind}-1` etc. already populated; bare ++seq would\n        //      collide on the first insert.\n        //   2. Hot-reload re-mounts the hook with a reset counter.\n        let seq = ++insertSeqRef.current;\n        let id = asNodeId(`kit-${kind}-${seq}`);\n        while (sc.get(id) !== undefined) {\n          seq = ++insertSeqRef.current;\n          id = asNodeId(`kit-${kind}-${seq}`);\n        }\n        const color = cycleFill(seq);\n        const fill = solid(color);\n\n        // The nascent node's extent — drag AABB reconciled with whatever\n        // richer geometry `extras` carries.\n        const extent = insertPreviewExtent({ shape: kind, bounds, extras });\n        const pose: unknown = extent.bounds;\n\n        // Consumer factory wins over the kit default for this kind (and is the\n        // only way to insert consumer-defined kinds like `text`). It owns the\n        // node's data + optional pose; the dep still supplies id/layer/op.\n        const factory = factoriesRef.current?.[kind];\n        if (factory) {\n          const built = factory(bounds, extras);\n          if (built === null) return null;\n          ad.applyOps(\n            [createInsertOp({ node: { id, kind: 'leaf', layer, pose: built.pose ?? pose, data: built.data } as unknown as { id: string }, label: `Insert ${kind}` })],\n            `Insert ${kind}`,\n          );\n          return id;\n        }\n\n        const geom = extent.geometry;\n        let data: unknown;\n\n        switch (geom.kind) {\n          case 'line':\n            data = { path: linePath(geom.a, geom.b), fill, stroke: strokeOf(color, 2) };\n            break;\n          case 'polygon':\n            data = {\n              path: regularPolygonPath(geom.center, geom.radius, geom.sides, geom.rotation),\n              fill,\n            };\n            break;\n          case 'star':\n            data = {\n              path: starPath(geom.center, geom.outerRadius, geom.points, geom.innerRadius, geom.rotation),\n              fill,\n            };\n            break;\n          case 'pencil': {\n            const samples = geom.samples as { x: number; y: number }[];\n            if (samples.length >= 4) {\n              data = { path: schneiderFit(samples, 2.0), stroke: strokeOf(color, 2) };\n            } else if (samples.length >= 2) {\n              data = { path: polygonFromPoints(samples), stroke: strokeOf(color, 2) };\n            } else {\n              data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), fill };\n            }\n            break;\n          }\n          case 'box':\n            switch (kind) {\n              case 'rect':\n                // Geometry-in-local-frame: the rect path lives at the origin and\n                // the pose carries position. `pathInPoseFrame` rebases a rect path\n                // onto the pose box regardless of the stored coords, so origin vs.\n                // duplicated-pose-coords render identically — don't double-count\n                // the position. (#13)\n                data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), fill };\n                break;\n              case 'ellipse':\n                data = { path: ellipsePath(extent.bounds), fill };\n                break;\n              case 'text': {\n                // The built-in `useTextTool` drags an empty text box you then type\n                // into (edit is entered via `enterTextEdit`), so `extras` carries\n                // no content and `text` defaults to `''`. The kit:text painter\n                // matches on `data.text != null` and applies style defaults at\n                // render time, so a bare `{ text }` is a complete, editable node.\n                const e = extras as Partial<{ text: string }>;\n                data = { text: e.text ?? '' };\n                break;\n              }\n              case 'image': {\n                // The bitmap is loaded + cached by `imageCache` keyed on `src`;\n                // only the (serializable) `src` lives on the node.\n                const e = extras as Partial<{ src: string; opacity: number }>;\n                data = {\n                  image: {\n                    src: e.src ?? '',\n                    ...(e.opacity !== undefined ? { opacity: e.opacity } : {}),\n                  },\n                };\n                break;\n              }\n              default:\n                console.warn(`weasel insertDep: no factory for kind=\"${kind}\". Skipping insert.`);\n                return null;\n            }\n            break;\n        }\n\n        ad.applyOps(\n          [createInsertOp({ node: { id, kind: 'leaf', layer, pose, data } as unknown as { id: string }, label: `Insert ${kind}` })],\n          `Insert ${kind}`,\n        );\n        return id;\n      },\n    };\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"insert.js","names":["e","paletteInsertPaint","color","cycleFill","seq","kind","strokeOf","solid","useInsertDepSource","sceneRef","useLatest","scene","adapterRef","adapter","factoriesRef","factories","paintRef","paint","insertSeqRef","useRef","liveRef","useDepSource","sc","ad","layer","build","extras","id","painted","as","fill","stroke","extent","insertPreviewExtent","pose","factory","built","bounds","createInsertOp","geom","data","linePath","regularPolygonPath","starPath","samples","schneiderFit","polygonFromPoints","rectPath","ellipsePath"],"sources":["../../../src/canvas/deps/insert.ts"],"sourcesContent":["/**\n * `useInsertDepSource` — wires the `insert` dep consumed by `insertAction`.\n *\n * Provides kit-side kind→data factories for the 6 builtin shape kinds\n * (`rect`, `ellipse`, `line`, `polygon`, `star`, `pencil`). Acceptable because\n * these kinds are kit-shipped tools; a future phase can expose a\n * `nodeFactories` prop for consumer-defined kinds.\n *\n * `line`, `polygon`, `star` and `pencil` receive the drag AABB from the\n * insertAction invoker, but `extras` may carry richer geometry (endpoints,\n * center+radius+rotation, point trail). `insertPreviewExtent` resolves the\n * two into the node's real extent — the same resolution the live preview\n * and the reported gesture bounds use.\n */\nimport { useRef } from 'react';\nimport { useDepSource } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { InsertDep, InsertExtras, InsertLive } from 'interactions/actions/depSchema';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport {\n  rectPath,\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  linePath,\n  polygonFromPoints,\n  schneiderFit,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport { insertPreviewExtent } from '../insertPreviewExtent';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { cycleFill, solid, strokeOf } from '../../util/paint';\n\ninterface OpsApplier {\n  applyOps(ops: Op[], label?: string): void;\n}\n\n/**\n * Consumer-supplied node factory for one insert `kind`. Given the drag AABB\n * and the tool's `extras`, returns the node's `data` (in the consumer's own\n * data shape) plus an optional `pose` override — the dep supplies id, layer,\n * and the undoable insert op. Return `null` to reject the insert.\n *\n * A factory registered for a kit kind (`rect`, `line`, …) fully replaces the\n * kit's default `{ path, fill }` factory for that kind; a factory for a novel\n * kind adds support the kit doesn't ship (e.g. `text`). To change only the\n * paint of a kit shape, pass an {@link InsertPaint}. See\n * `SceneCanvas`'s `insertNodeFactories` prop.\n */\nexport type InsertNodeFactory = (\n  bounds: { x: number; y: number; width: number; height: number },\n  extras: InsertExtras,\n) => { data: unknown; pose?: unknown } | null;\n\n/**\n * The paint a kit-built shape is inserted with. `kind` is the shape being\n * built and `seq` counts this canvas's inserts from 1. A key left out stays\n * off the node, so its painter's default applies; `null` is \"none\". A pencil\n * trail too short to fit is built as a rect and asks as one.\n *\n * It paints only the shapes the kit builds: an `InsertNodeFactory` owns its\n * node's whole `data`. See `SceneCanvas`'s `insertPaint` prop.\n */\nexport type InsertPaint = (kind: string, seq: number) => { fill?: FillStyle | null; stroke?: Stroke | null };\n\n/** The default {@link InsertPaint}: the next color of the kit palette, as a\n *  fill on a closed shape, a fill and a stroke on a line or a pen path, and a\n *  stroke alone on a pencil trail. */\nexport const paletteInsertPaint: InsertPaint = (kind, seq) => {\n  const color = cycleFill(seq);\n  if (kind === 'pencil') return { stroke: strokeOf(color, 2) };\n  if (kind === 'line' || kind === 'path') return { fill: solid(color), stroke: strokeOf(color, 2) };\n  return { fill: solid(color) };\n};\n\nexport function useInsertDepSource(\n  scene: Scene<unknown, string, unknown>,\n  adapter: OpsApplier,\n  factories?: Record<string, InsertNodeFactory>,\n  paint: InsertPaint = paletteInsertPaint,\n): void {\n  const sceneRef = useLatest(scene);\n  const adapterRef = useLatest(adapter);\n  const factoriesRef = useLatest(factories);\n  const paintRef = useLatest(paint);\n  const insertSeqRef = useRef(0);\n  const liveRef = useRef<InsertLive>({ gesture: null });\n  useDepSource('insertLive', () => liveRef.current);\n\n  useDepSource('insert', (): InsertDep => {\n    const sc = sceneRef.current;\n    const ad = adapterRef.current;\n\n    const layer = (sc.layers[0]?.id ?? 'default') as string;\n    const build = (\n      bounds: { x: number; y: number; width: number; height: number },\n      extras: InsertExtras,\n    ): { id: NodeId; ops: Op[] } | null => {\n        const kind = extras.kind;\n        const seq = ++insertSeqRef.current;\n        const id = sc.mintId();\n        const painted = (as: string = kind): { fill?: FillStyle | null; stroke?: Stroke | null } => {\n          const { fill, stroke } = paintRef.current(as, seq);\n          return { ...(fill !== undefined ? { fill } : {}), ...(stroke !== undefined ? { stroke } : {}) };\n        };\n\n        // The nascent node's extent — drag AABB reconciled with whatever\n        // richer geometry `extras` carries.\n        const extent = insertPreviewExtent({ shape: kind, bounds, extras });\n        const pose: unknown = extent.bounds;\n\n        // Consumer factory wins over the kit default for this kind (and is the\n        // only way to insert consumer-defined kinds like `text`). It owns the\n        // node's data + optional pose; the dep still supplies id/layer/op.\n        const factory = factoriesRef.current?.[kind];\n        if (factory) {\n          const built = factory(bounds, extras);\n          if (built === null) return null;\n          return {\n            id,\n            ops: [createInsertOp({ node: { id, kind: 'leaf', layer, pose: built.pose ?? pose, data: built.data } as unknown as { id: string }, label: `Insert ${kind}` })],\n          };\n        }\n\n        const geom = extent.geometry;\n        let data: unknown;\n\n        switch (geom.kind) {\n          case 'line':\n            data = { path: linePath(geom.a, geom.b), ...painted() };\n            break;\n          case 'polygon':\n            data = {\n              path: regularPolygonPath(geom.center, geom.radius, geom.sides, geom.rotation),\n              ...painted(),\n            };\n            break;\n          case 'star':\n            data = {\n              path: starPath(geom.center, geom.outerRadius, geom.points, geom.innerRadius, geom.rotation),\n              ...painted(),\n            };\n            break;\n          case 'pencil': {\n            const samples = geom.samples as { x: number; y: number }[];\n            if (samples.length >= 4) {\n              data = { path: schneiderFit(samples, 2.0), ...painted() };\n            } else if (samples.length >= 2) {\n              data = { path: polygonFromPoints(samples), ...painted() };\n            } else {\n              data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), ...painted('rect') };\n            }\n            break;\n          }\n          case 'box':\n            switch (kind) {\n              case 'rect':\n                // Geometry-in-local-frame: the rect path lives at the origin and\n                // the pose carries position. `pathInPoseFrame` rebases a rect path\n                // onto the pose box regardless of the stored coords, so origin vs.\n                // duplicated-pose-coords render identically — don't double-count\n                // the position. (#13)\n                data = { path: rectPath(0, 0, extent.bounds.width, extent.bounds.height), ...painted() };\n                break;\n              case 'ellipse':\n                data = { path: ellipsePath(extent.bounds), ...painted() };\n                break;\n              case 'path': {\n                const e = extras as { path: PolygonPath; closed: boolean };\n                data = { path: e.path, ...painted(), ...(e.closed ? {} : { fill: null }) };\n                break;\n              }\n              case 'text': {\n                // The built-in `useTextTool` drags an empty text box you then type\n                // into (edit is entered via `enterTextEdit`), so `extras` carries\n                // no content and `text` defaults to `''`. The kit:text painter\n                // matches on `data.text != null` and applies style defaults at\n                // render time, so a bare `{ text }` is a complete, editable node.\n                const e = extras as Partial<{ text: string }>;\n                data = { text: e.text ?? '' };\n                break;\n              }\n              case 'image': {\n                // The bitmap is loaded + cached by `imageCache` keyed on `src`;\n                // only the (serializable) `src` lives on the node.\n                const e = extras as Partial<{ src: string; opacity: number }>;\n                data = {\n                  image: {\n                    src: e.src ?? '',\n                    ...(e.opacity !== undefined ? { opacity: e.opacity } : {}),\n                  },\n                };\n                break;\n              }\n              default:\n                console.warn(`weasel insertDep: no factory for kind=\"${kind}\". Skipping insert.`);\n                return null;\n            }\n            break;\n        }\n\n        return {\n          id,\n          ops: [createInsertOp({ node: { id, kind: 'leaf', layer, pose, data } as unknown as { id: string }, label: `Insert ${kind}` })],\n        };\n    };\n    return {\n      layer: () => layer,\n      build,\n      commit(bounds, extras): NodeId | null {\n        const built = build(bounds, extras);\n        if (built === null) return null;\n        ad.applyOps(built.ops, `Insert ${extras.kind}`);\n        return built.id;\n      },\n    };\n  });\n}\n"],"mappings":";;;;;;;;AAsEA,IAAaC,KAAmC,GAAM,MAAQ;CAC5D,IAAMC,IAAQC,EAAUC,CAAG;CAG3B,OAFIC,MAAS,WAAiB,EAAE,QAAQC,EAASJ,GAAO,CAAC,EAAE,IACvDG,MAAS,UAAUA,MAAS,SAAe;EAAE,MAAME,EAAML,CAAK;EAAG,QAAQI,EAASJ,GAAO,CAAC;CAAE,IACzF,EAAE,MAAMK,EAAML,CAAK,EAAE;AAC9B;AAEA,SAAgBM,EACd,GACA,GACA,GACA,IAAqBP,GACf;CACN,IAAMQ,IAAWC,EAAUC,CAAK,GAC1BC,IAAaF,EAAUG,CAAO,GAC9BC,IAAeJ,EAAUK,CAAS,GAClCC,IAAWN,EAAUO,CAAK,GAC1BC,IAAeC,EAAO,CAAC,GACvBC,IAAUD,EAAmB,EAAE,SAAS,KAAK,CAAC;CAGpD,AAFAE,EAAa,oBAAoBD,EAAQ,OAAO,GAEhDC,EAAa,gBAA2B;EACtC,IAAMC,IAAKb,EAAS,SACdc,IAAKX,EAAW,SAEhBY,IAASF,EAAG,OAAO,EAAE,EAAE,MAAM,WAC7BG,KACJ,GACA,MACqC;GACnC,IAAMpB,IAAOqB,EAAO,MACdtB,IAAM,EAAEc,EAAa,SACrBS,IAAKL,EAAG,OAAO,GACfM,KAAW,IAAavB,MAA8D;IAC1F,IAAM,EAAE,SAAM,cAAWW,EAAS,QAAQa,GAAIzB,CAAG;IACjD,OAAO;KAAE,GAAI0B,MAAS,KAAA,IAAuB,CAAC,IAAZ,EAAE,QAAK;KAAS,GAAIC,MAAW,KAAA,IAAyB,CAAC,IAAd,EAAE,UAAO;IAAQ;GAChG,GAIMC,IAASC,EAAoB;IAAE,OAAO5B;IAAM;IAAQ;GAAO,CAAC,GAC5D6B,IAAgBF,EAAO,QAKvBG,IAAUrB,EAAa,UAAUT;GACvC,IAAI8B,GAAS;IACX,IAAMC,IAAQD,EAAQE,GAAQX,CAAM;IAEpC,OADIU,MAAU,OAAa,OACpB;KACL;KACA,KAAK,CAACE,EAAe;MAAE,MAAM;OAAE;OAAI,MAAM;OAAQ;OAAO,MAAMF,EAAM,QAAQF;OAAM,MAAME,EAAM;MAAK;MAAgC,OAAO,UAAU/B;KAAO,CAAC,CAAC;IAC/J;GACF;GAEA,IAAMkC,IAAOP,EAAO,UAChBQ;GAEJ,QAAQD,EAAK,MAAb;IACE,KAAK;KACH,IAAO;MAAE,MAAME,EAASF,EAAK,GAAGA,EAAK,CAAC;MAAG,GAAGX,EAAQ;KAAE;KACtD;IACF,KAAK;KACH,IAAO;MACL,MAAMc,EAAmBH,EAAK,QAAQA,EAAK,QAAQA,EAAK,OAAOA,EAAK,QAAQ;MAC5E,GAAGX,EAAQ;KACb;KACA;IACF,KAAK;KACH,IAAO;MACL,MAAMe,EAASJ,EAAK,QAAQA,EAAK,aAAaA,EAAK,QAAQA,EAAK,aAAaA,EAAK,QAAQ;MAC1F,GAAGX,EAAQ;KACb;KACA;IACF,KAAK,UAAU;KACb,IAAMgB,IAAUL,EAAK;KACrB,AAKEC,IALEI,EAAQ,UAAU,IACb;MAAE,MAAMC,EAAaD,GAAS,CAAG;MAAG,GAAGhB,EAAQ;KAAE,IAC/CgB,EAAQ,UAAU,IACpB;MAAE,MAAME,EAAkBF,CAAO;MAAG,GAAGhB,EAAQ;KAAE,IAEjD;MAAE,MAAMmB,EAAS,GAAG,GAAGf,EAAO,OAAO,OAAOA,EAAO,OAAO,MAAM;MAAG,GAAGJ,EAAQ,MAAM;KAAE;KAE/F;IACF;IACA,KAAK,OACH,QAAQvB,GAAR;KACE,KAAK;MAMH,IAAO;OAAE,MAAM0C,EAAS,GAAG,GAAGf,EAAO,OAAO,OAAOA,EAAO,OAAO,MAAM;OAAG,GAAGJ,EAAQ;MAAE;MACvF;KACF,KAAK;MACH,IAAO;OAAE,MAAMoB,EAAYhB,EAAO,MAAM;OAAG,GAAGJ,EAAQ;MAAE;MACxD;KACF,KAAK,QAAQ;MACX,IAAM,IAAIF;MACV,IAAO;OAAE,MAAM,EAAE;OAAM,GAAGE,EAAQ;OAAG,GAAI,EAAE,SAAS,CAAC,IAAI,EAAE,MAAM,KAAK;MAAG;MACzE;KACF;KACA,KAAK;MAOH,IAAO,EAAE,MAAM5B,EAAE,QAAQ,GAAG;MAC5B;KAEF,KAAK,SAAS;MAGZ,IAAM,IAAI0B;MACV,IAAO,EACL,OAAO;OACL,KAAK,EAAE,OAAO;OACd,GAAI,EAAE,YAAY,KAAA,IAAqC,CAAC,IAA1B,EAAE,SAAS,EAAE,QAAQ;MACrD,EACF;MACA;KACF;KACA,SAEE,OADA,QAAQ,KAAK,0CAA0CrB,EAAK,oBAAoB,GACzE;IACX;GAEJ;GAEA,OAAO;IACL;IACA,KAAK,CAACiC,EAAe;KAAE,MAAM;MAAE;MAAI,MAAM;MAAQ;MAAO;MAAM;KAAK;KAAgC,OAAO,UAAUjC;IAAO,CAAC,CAAC;GAC/H;EACJ;EACA,OAAO;GACL,aAAamB;GACb;GACA,OAAO,GAAQ,GAAuB;IACpC,IAAMY,IAAQX,EAAMY,GAAQX,CAAM;IAGlC,OAFIU,MAAU,OAAa,QAC3Bb,EAAG,SAASa,EAAM,KAAK,UAAUV,EAAO,MAAM,GACvCU,EAAM;GACf;EACF;CACF,CAAC;AACH"}

package/dist/canvas/deps/slice.js

@@ -1,8 +1,8 @@
-import { poseDescriptorForNode as e } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as t } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { scenePoseFrame as n } from "../../interactions/actions/poseFrame.js";
-import { freshNodeId as r } from "../../interactions/actions/defaults/freshNodeId.js";
-import { pathInWorld as i, worldEditToStorage as a } from "../../features/paths/pathInWorld.js";
+import { poseLinearOf as e } from "../../core/geometry/poseFrame.js";
+import { poseDescriptorForNode as t } from "../../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { pathInWorld as r, worldEditToStorage as i } from "../../features/paths/pathInWorld.js";
+import { scenePoseFrame as a } from "../../interactions/actions/poseFrame.js";
 import { computeSliceOps as o } from "../../interactions/actions/defaults/sliceOps.js";
 import { useLatest as s } from "@weasel-js/react";
 import { useDepSource as c } from "@weasel-js/routing/react";
@@ -11,70 +11,71 @@ function l(e) {
 	let t = s(e);
 	c("slice", () => t.current);
 }
-function u(a, l, u, h, g) {
-	let _ = s(a), v = s(l), y = s(u), b = s(h), x = s(g);
-	c("slice", () => ({ commit(a) {
-		let s = _.current, c = n(s, b.current), l = x.current ?? t, u = [], h = /* @__PURE__ */ new Map();
-		for (let t of s.renderOrderNodes()) {
-			let n = p(s, t);
+function u(e, i, l, u, h) {
+	let g = s(e), _ = s(i), v = s(l), y = s(u), b = s(h);
+	c("slice", () => ({ commit(e) {
+		let i = g.current, s = a(i, y.current), c = b.current ?? n, l = [], u = /* @__PURE__ */ new Map();
+		for (let e of i.renderOrderNodes()) {
+			let n = p(i, e);
 			if (!n) continue;
-			let r = d(e(l, t), c.world(t.id));
-			r && (h.set(t.id, r), u.push({
-				node: t,
-				index: m(s, t),
-				worldPath: i(n, r.box)
+			let a = d(t(c, e), s.world(e.id));
+			a && (u.set(e.id, a), l.push({
+				node: e,
+				index: m(i, e),
+				worldPath: r(n, a.box)
 			}));
 		}
-		let g = v.current, { ops: S, nextSelection: C } = o({
-			leaves: u,
-			cut: a,
-			nextId: r,
-			selection: g.get(),
+		let h = _.current, { ops: x, nextSelection: S } = o({
+			leaves: l,
+			cut: e,
+			nextId: () => i.mintId(),
+			selection: h.get(),
 			placePiece: (e, t) => {
-				let n = f(h.get(e.node.id), t);
+				let n = f(u.get(e.node.id), t);
 				return {
-					pose: c.local(e.node.id, n.pose),
+					pose: s.local(e.node.id, n.pose),
 					path: n.path
 				};
 			}
 		});
-		S.length !== 0 && (y.current.applyOps(S, "Slice"), C && g.set(C));
+		x.length !== 0 && (v.current.applyOps(x, "Slice"), S && h.set(S));
 	} }));
 }
-function d(e, t) {
-	let n = e.getBounds(t);
-	if (!n || ![
-		n.x,
-		n.y,
-		n.width,
-		n.height
+function d(t, n) {
+	let r = t.getBounds(n);
+	if (!r || ![
+		r.x,
+		r.y,
+		r.width,
+		r.height
 	].every(Number.isFinite)) return null;
-	let r = e.getRotation?.(t) ?? 0;
+	let i = t.getRotation?.(n) ?? 0, a = e(n) ?? void 0;
 	return {
-		world: t,
-		g: e,
+		world: n,
+		g: t,
 		box: {
-			x: n.x,
-			y: n.y,
-			width: n.width,
-			height: n.height,
-			rotation: r
+			x: r.x,
+			y: r.y,
+			width: r.width,
+			height: r.height,
+			rotation: i,
+			transform: a
 		}
 	};
 }
 function f({ world: e, g: t, box: n }, r) {
-	let i = !!t.withRotation && t.supportsRotation?.(e) !== !1, o = n.rotation ?? 0;
-	if (o !== 0 && !i) {
-		let i = a({
+	let a = !!t.withRotation && t.supportsRotation?.(e) !== !1, o = n.rotation ?? 0;
+	if (o !== 0 && !a) {
+		let a = i({
 			...n,
 			rotation: 0
 		}, r);
 		return {
-			pose: t.fromBounds(i.pose, e),
-			path: i.path
+			pose: t.fromBounds(a.pose, e),
+			path: a.path
 		};
 	}
-	let { pose: s, path: c } = a(n, r), l = {
+	let { pose: s, path: c } = i(n, r), l = {
 		x: s.x,
 		y: s.y,
 		width: s.width,