@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/renderSceneToPixels.js

@@ -1,52 +1,48 @@
-import { isPaintKindKnown as e, warmPaintKinds as t } from "../core/paintKinds.js";
-import { WeaselRenderer as n } from "../renderer/WeaselRenderer.js";
-import { viewToMat3 as r } from "../renderer/math/viewToMat3.js";
-import { defaultDrawOne as i } from "./defaultDrawOne.js";
-import { buildSceneViewCommands as a } from "./sceneViewRender.js";
-import { renderNeeds as o } from "./renderNeeds.js";
-import { warmFonts as s } from "@weasel-js/font";
+import { defaultDrawOne as e } from "./defaultDrawOne.js";
+import { buildSceneViewCommands as t } from "./sceneViewRender.js";
+import { renderNeeds as n } from "./renderNeeds.js";
+import { straightTopDown as r } from "./rasterReadback.js";
+import { WeaselRenderer as i, isPaintKindKnown as a, warmPaintKinds as o } from "@weasel-js/renderer";
+import { viewToMat3 as s } from "@weasel-js/geom";
+import { warmFonts as c } from "@weasel-js/font";
 //#region src/canvas/renderSceneToPixels.ts
-function c(e) {
-	let { sourceRect: t, scale: n } = e;
-	for (let [e, r] of [
-		["sourceRect.width", t.width],
-		["sourceRect.height", t.height],
-		["scale.x", n.x],
-		["scale.y", n.y]
-	]) if (!Number.isFinite(r) || r <= 0) throw Error(`renderSceneToPixels: ${e} must be a positive finite number, got ${r}`);
-	for (let [e, n] of [["sourceRect.x", t.x], ["sourceRect.y", t.y]]) if (!Number.isFinite(n)) throw Error(`renderSceneToPixels: ${e} must be a finite number, got ${n}`);
-	let r = Math.max(1, Math.round(t.width * n.x)), o = Math.max(1, Math.round(t.height * n.y)), s = {
-		x: t.x,
-		y: t.y,
+function l(n) {
+	let { sourceRect: r, scale: i } = n;
+	for (let [e, t] of [["sourceRect.width", r.width], ["sourceRect.height", r.height]]) if (!Number.isFinite(t) || t <= 0) throw Error(`renderSceneToPixels: ${e} must be a positive finite number, got ${t}`);
+	for (let [e, t] of [["scale.x", i.x], ["scale.y", i.y]]) if (!Number.isFinite(t) || t === 0) throw Error(`renderSceneToPixels: ${e} must be a nonzero finite number, got ${t}`);
+	for (let [e, t] of [["sourceRect.x", r.x], ["sourceRect.y", r.y]]) if (!Number.isFinite(t)) throw Error(`renderSceneToPixels: ${e} must be a finite number, got ${t}`);
+	let a = Math.max(1, Math.round(r.width * Math.abs(i.x))), o = Math.max(1, Math.round(r.height * Math.abs(i.y))), s = {
+		x: i.x < 0 ? r.x + r.width : r.x,
+		y: i.y < 0 ? r.y + r.height : r.y,
 		scale: {
-			x: n.x,
-			y: n.y
+			x: i.x,
+			y: i.y
 		}
-	}, c = e.resolveImage, l = e.drawOne ?? ((e, t, n, r) => i(e, t, n, {
-		...r,
+	}, c = n.resolveImage, l = n.drawOne ?? ((t, n, r, i) => e(t, n, r, {
+		...i,
 		resolveImage: c
 	})), u = [];
-	return e.background !== void 0 && u.push({
+	return n.background !== void 0 && u.push({
 		kind: "path",
 		path: {
 			kind: "rect",
 			x: 0,
 			y: 0,
-			width: r,
+			width: a,
 			height: o
 		},
-		fill: {
-			fill: "solid",
-			color: e.background
-		}
-	}), u.push(...a(e.scene, s, l, void 0, e.alphaFor, void 0, void 0, e.colorOverrides)), e.overlay && u.push(...e.overlay), {
-		width: r,
+		fill: { paint: {
+			kind: "solid",
+			color: n.background
+		} }
+	}), u.push(...t(n.scene, s, l, void 0, n.alphaFor, void 0, n.colorOverrides)), n.overlay && u.push(...n.overlay), {
+		width: a,
 		height: o,
 		view: s,
 		commands: u
 	};
 }
-function l(e, t) {
+function u(e, t) {
 	if (typeof OffscreenCanvas < "u") return new OffscreenCanvas(e, t);
 	if (typeof document < "u") {
 		let n = document.createElement("canvas");
@@ -54,82 +50,67 @@ function l(e, t) {
 	}
 	throw Error("renderSceneToPixels: no canvas source in this environment — supply `gl` or `createCanvas`");
 }
-function u(e, t, n) {
-	let r = t * 4, i = new Uint8ClampedArray(e.length);
-	for (let t = 0; t < n; t++) i.set(e.subarray((n - 1 - t) * r, (n - t) * r), t * r);
-	return i;
-}
-function d(e) {
-	for (let t = 0; t < e.length; t += 4) {
-		let n = e[t + 3];
-		if (n === 0 || n === 255) continue;
-		let r = 255 / n;
-		e[t] = e[t] * r, e[t + 1] = e[t + 1] * r, e[t + 2] = e[t + 2] * r;
-	}
-}
-function f(e = {}) {
+function d(e = {}) {
 	if (e.gl && e.createCanvas) throw Error("raster session: `gl` and `createCanvas` are mutually exclusive");
-	let t = null, i = e.gl, a = null, o = !1;
-	function s(n, r) {
-		if (e.gl || (t ? (t.width < n && (t.width = n), t.height < r && (t.height = r)) : (t = (e.createCanvas ?? l)(n, r), t.width = n, t.height = r, i = t.getContext("webgl2", {
+	let t = null, n = e.gl, a = null, o = !1;
+	function c(r, i) {
+		if (e.gl || (t ? (t.width < r && (t.width = r), t.height < i && (t.height = i)) : (t = (e.createCanvas ?? u)(r, i), t.width = r, t.height = i, n = t.getContext("webgl2", {
 			preserveDrawingBuffer: !0,
 			stencil: !0
-		}) ?? void 0)), !i || typeof i.enable != "function") throw Error("raster session: WebGL2 is unavailable — supply `gl` or a WebGL2-capable `createCanvas`");
-		if (p(i)) throw Error("raster session: the WebGL2 context is lost — dispose this session and open another");
-		let { drawingBufferWidth: a, drawingBufferHeight: o } = i;
-		if (a < n || o < r) throw Error(`raster session: a ${n} × ${r} render does not fit the context's ${a} × ${o} drawing buffer — lower \`scale\` or render the source rect in tiles`);
-		return i;
+		}) ?? void 0)), !n || typeof n.enable != "function") throw Error("raster session: WebGL2 is unavailable — supply `gl` or a WebGL2-capable `createCanvas`");
+		if (f(n)) throw Error("raster session: the WebGL2 context is lost — dispose this session and open another");
+		let { drawingBufferWidth: a, drawingBufferHeight: o } = n;
+		if (a < r || o < i) throw Error(`raster session: a ${r} × ${i} render does not fit the context's ${a} × ${o} drawing buffer — lower \`scale\` or render the source rect in tiles`);
+		return n;
 	}
 	return {
 		render(e) {
 			if (o) throw Error("raster session: render() on a disposed session");
-			let t = c(e), { width: i, height: l } = t, f = s(i, l), m = (e.flattenTolerancePx ?? .25) / Math.max(e.scale.x, e.scale.y);
+			let t = l(e), { width: n, height: u } = t, d = c(n, u), p = (e.flattenTolerancePx ?? .25) / Math.max(Math.abs(e.scale.x), Math.abs(e.scale.y));
 			if (a ? (a.resize({
-				width: i,
-				height: l,
+				width: n,
+				height: u,
 				dpr: 1
-			}), a.setFlattenTolerance(m)) : a = new n({
-				gl: f,
-				width: i,
-				height: l,
+			}), a.setFlattenTolerance(p)) : a = new i({
+				gl: d,
+				width: n,
+				height: u,
 				dpr: 1,
 				imageMinification: "mipmap",
-				flattenTolerance: m,
+				flattenTolerance: p,
 				bakeBudget: Infinity
-			}), a.render(t.commands, r(t.view)), p(f)) throw Error("raster session: the WebGL2 context was lost during render");
-			let h = new Uint8Array(i * l * 4);
-			f.readPixels(0, 0, i, l, f.RGBA, f.UNSIGNED_BYTE, h);
-			let g = u(h, i, l);
-			return d(g), {
-				width: i,
-				height: l,
-				data: g
+			}), a.render(t.commands, s(t.view)), f(d)) throw Error("raster session: the WebGL2 context was lost during render");
+			let m = new Uint8Array(n * u * 4);
+			return d.readPixels(0, 0, n, u, d.RGBA, d.UNSIGNED_BYTE, m), {
+				width: n,
+				height: u,
+				data: r(m, n, u)
 			};
 		},
 		dispose() {
-			o || (o = !0, a?.dispose(), a = null, t && !e.createCanvas && i?.getExtension("WEBGL_lose_context")?.loseContext(), t = null, i = void 0);
+			o || (o = !0, a?.dispose(), a = null, t && !e.createCanvas && n?.getExtension("WEBGL_lose_context")?.loseContext(), t = null, n = void 0);
 		}
 	};
 }
-function p(e) {
+function f(e) {
 	return typeof e.isContextLost == "function" && e.isContextLost() === !0;
 }
-function m(n = {}) {
-	let { families: r, paintKinds: i } = n;
-	if (n.render || n.commands) {
-		let t;
+function p(e = {}) {
+	let { families: t, paintKinds: r } = e;
+	if (e.render || e.commands) {
+		let i;
 		try {
-			t = n.render ? c(n.render).commands : [];
+			i = e.render ? l(e.render).commands : [];
 		} catch (e) {
 			return Promise.reject(e);
 		}
-		let a = o([...t, ...n.commands ?? []]);
-		r ??= a.fonts, i ??= a.paintKinds.filter(e);
+		let o = n([...i, ...e.commands ?? []]);
+		t ??= o.fonts, r ??= o.paintKinds.filter(a);
 	}
-	return Promise.all([s(r), t(i)]).then(() => void 0);
+	return Promise.all([c(t), o(r)]).then(() => void 0);
 }
-function h(e) {
-	let { gl: t, createCanvas: n, ...r } = e, i = f({
+function m(e) {
+	let { gl: t, createCanvas: n, ...r } = e, i = d({
 		gl: t,
 		createCanvas: n
 	});
@@ -140,6 +121,6 @@ function h(e) {
 	}
 }
 //#endregion
-export { f as createRasterSession, c as planPixelRender, h as renderSceneToPixels, m as warmRender };
+export { d as createRasterSession, l as planPixelRender, m as renderSceneToPixels, p as warmRender };
 
 //# sourceMappingURL=renderSceneToPixels.js.map

package/dist/canvas/renderSceneToPixels.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderSceneToPixels.js","names":["planPixelRender","args","label","v","sourceRect","scale","width","height","view","resolveImage","drawOne","defaultDrawOne","node","pose","ctx","commands","buildSceneViewCommands","defaultCreateCanvas","c","flipRows","rowBytes","out","raw","y","unpremultiply","i","data","a","inv","createRasterSession","options","canvas","gl","renderer","disposed","contextFor","isLost","bufferW","bufferH","plan","flattenTolerance","WeaselRenderer","viewToMat3","warmRender","opts","planned","err","needs","renderNeeds","isPaintKindKnown","warmFonts","families","warmPaintKinds","paintKinds","renderSceneToPixels","renderArgs","session"],"sources":["../../src/canvas/renderSceneToPixels.ts"],"sourcesContent":["/**\n * `renderSceneToPixels` — headless rasterization of a scene-space rect to\n * raw RGBA pixels at an explicit, per-axis scale.\n *\n * One renderer, two callers: this path drives the same WebGL2 pipeline\n * (`WeaselRenderer` + `buildSceneViewCommands`) as the on-screen view — it is\n * NOT a second renderer. Print, thumbnail, and export callers get the same\n * pixels the screen would produce at that scale.\n *\n * Environment contract:\n * - Density arrives exclusively via `scale` (output pixels per scene unit,\n *   per axis — anisotropic values are first-class). This function never\n *   reads `window.devicePixelRatio`.\n * - Rounding policy: output width = max(1, round(sourceRect.width × scale.x)),\n *   height analogously. The scene-space rect is authoritative; the pixel\n *   grid derives from it. When round() lands below rect × scale, the\n *   rightmost/bottom sub-pixel band of scene content is cropped; when it\n *   rounds up, that band is instead padded (the `background` fill, or\n *   transparent, covers the pad).\n * - Context lifetime: each call opens a `RasterSession` — one\n *   `WeaselRenderer` — and disposes it before returning, freeing every GL\n *   object it created, caches included. Rendering in bulk, open one session\n *   with `createRasterSession` and render through it: programs compile once\n *   and bitmaps upload once for the whole batch, and `dispose()` frees them.\n *   With a caller-supplied `gl`, the context itself is caller-owned: it is\n *   never disposed here, and its drawing buffer must be at least\n *   width × height pixels (the render targets the bottom-left region).\n *   Auto-created canvases (`OffscreenCanvas` when available, else a detached\n *   DOM canvas) are discarded with the session; a session grows its own\n *   canvas to the largest render so far.\n * - Context loss: throws — a lost context cannot produce pixels, and the\n *   silent-noop convention of the screen path would return all-zero bytes.\n * - Output: top-down row order, NON-premultiplied (\"straight\") RGBA. The GL\n *   framebuffer is premultiplied (blendFunc ONE, ONE_MINUS_SRC_ALPHA) and\n *   bottom-up; readback flips and unpremultiplies. Over an opaque\n *   `background` both transforms are visually moot but still applied.\n * - Determinism: same context + same inputs → same bytes. Cross-driver /\n *   cross-machine byte equality is NOT guaranteed (GL rasterization varies);\n *   do not build golden-image tests on committed bytes.\n * - Image quality: image textures upload with mipmaps\n *   (`imageMinification: 'mipmap'`) so minified bitmaps don't moiré, and\n *   curve tessellation runs at an output-scale tolerance\n *   (`flattenTolerancePx`, default 0.25 output px). A bitmap node's source\n *   pixels are sampled exactly once, directly to the output grid.\n */\nimport { WeaselRenderer } from '../renderer/WeaselRenderer';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\nimport type { Node, Scene } from 'core/scene/types';\nimport { buildSceneViewCommands, type SceneViewDrawOne } from './sceneViewRender';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport { defaultDrawOne } from './defaultDrawOne';\nimport { warmFonts, type FontRequest } from '@weasel-js/font';\nimport { isPaintKindKnown, warmPaintKinds } from '../core/paintKinds';\nimport { renderNeeds } from './renderNeeds';\n\n/** Plain RGBA raster — structurally `ImageData`-compatible ({ width, height,\n *  data }), deliberately free of printer/dpi/physical-unit concepts. */\nexport interface RasterImage {\n  width: number;\n  height: number;\n  /** Top-down, straight (non-premultiplied) RGBA, 4 bytes per pixel. */\n  data: Uint8ClampedArray;\n}\n\n/** Minimal canvas contract for `createCanvas` injection: `OffscreenCanvas`,\n *  an HTML canvas, or a test fake. */\nexport interface HeadlessCanvasLike {\n  width: number;\n  height: number;\n  getContext(contextId: 'webgl2', options?: WebGLContextAttributes): unknown;\n}\n\n/** What to render, at what resolution, and with which quality settings. */\nexport interface RenderSceneToPixelsArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Scene-space rect to render (origin + size in scene units). Output pixel\n   *  dimensions follow from rect × scale (round, min 1 — see module doc). */\n  sourceRect: { x: number; y: number; width: number; height: number };\n  /** Output pixels per scene unit, per axis. Anisotropic values supported. */\n  scale: { x: number; y: number };\n  /** Per-node draw callback. Default: `defaultDrawOne` with `resolveImage`\n   *  merged into the `NodePaintCtx` the scene walk supplies. Custom `drawOne`\n   *  callers that still want resolver injection should call\n   *  `defaultDrawOne(node, pose, view, { ...ctx, resolveImage })` themselves —\n   *  dropping the walk's `ctx` drops derived geometry with it. */\n  drawOne?: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Bitmap resolver for image nodes — lets consumers reuse their own decode\n   *  caches. `undefined` results paint the deterministic grey placeholder\n   *  outline (see `NodePaintCtx.resolveImage`). */\n  resolveImage?: (node: Node<TData, TLayer, TPose>) => ImageBitmap | undefined;\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the on-screen canvas uses so an\n   *  export matches what the user is looking at. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides`, so an export shows the frame on screen. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Background fill (any CSS color accepted by the renderer). Default:\n   *  fully transparent. Passing a color is always valid. */\n  background?: string;\n  /** Caller-owned WebGL2 context to render with. Mutually exclusive with\n   *  `createCanvas`. Never disposed by this call. */\n  gl?: WebGL2RenderingContext;\n  /** One-shot canvas factory (DOM canvas, OffscreenCanvas, or test fake).\n   *  Mutually exclusive with `gl`. Default: `OffscreenCanvas` when\n   *  available, else `document.createElement('canvas')`. */\n  createCanvas?: (widthPx: number, heightPx: number) => HeadlessCanvasLike;\n  /** Max curve-flattening error in OUTPUT pixels. Default 0.25. Converted to\n   *  world units against the larger scale axis and passed to the renderer's\n   *  `flattenTolerance`. Explicitly passing 0.25 is always valid. */\n  flattenTolerancePx?: number;\n  /** Commands drawn over the scene in output-pixel space — origin at the\n   *  output's top-left, one unit per output pixel. Annotations, watermarks,\n   *  and `renderDebugSnapshot`'s overlay ride here. */\n  overlay?: readonly DrawCommand[];\n}\n\n/** The result of planning a headless render: how big the output is, the view\n *  that maps the source rect onto it, and the commands to draw. */\nexport interface PixelRenderPlan {\n  width: number;\n  height: number;\n  view: View;\n  commands: DrawCommand[];\n}\n\n/** Pure planning half of `renderSceneToPixels`: output dimensions, the\n *  anisotropic `View`, and the full command list (background + view-wrapped\n *  scene). Exported for tests and for callers targeting their own renderer. */\nexport function planPixelRender<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToPixelsArgs<TData, TLayer, TPose>, 'gl' | 'createCanvas' | 'flattenTolerancePx'>,\n): PixelRenderPlan {\n  const { sourceRect, scale } = args;\n  for (const [label, v] of [\n    ['sourceRect.width', sourceRect.width], ['sourceRect.height', sourceRect.height],\n    ['scale.x', scale.x], ['scale.y', scale.y],\n  ] as const) {\n    if (!Number.isFinite(v) || v <= 0) {\n      throw new Error(`renderSceneToPixels: ${label} must be a positive finite number, got ${v}`);\n    }\n  }\n  for (const [label, v] of [\n    ['sourceRect.x', sourceRect.x], ['sourceRect.y', sourceRect.y],\n  ] as const) {\n    if (!Number.isFinite(v)) {\n      throw new Error(`renderSceneToPixels: ${label} must be a finite number, got ${v}`);\n    }\n  }\n  const width = Math.max(1, Math.round(sourceRect.width * scale.x));\n  const height = Math.max(1, Math.round(sourceRect.height * scale.y));\n  const view: View = { x: sourceRect.x, y: sourceRect.y, scale: { x: scale.x, y: scale.y } };\n\n  const resolveImage = args.resolveImage as ((n: Node<unknown, string, unknown>) => ImageBitmap | undefined) | undefined;\n  const drawOne: SceneViewDrawOne<TData, TLayer, TPose> =\n    args.drawOne ?? ((node, pose, view, ctx) => defaultDrawOne(node, pose, view, { ...ctx, resolveImage }));\n\n  const commands: DrawCommand[] = [];\n  if (args.background !== undefined) {\n    // Screen-space (pre-view) fill so rounding can never leave uncovered\n    // edge pixels.\n    commands.push({\n      kind: 'path',\n      path: { kind: 'rect', x: 0, y: 0, width, height },\n      fill: { fill: 'solid', color: args.background },\n    });\n  }\n  commands.push(...buildSceneViewCommands(\n    args.scene, view, drawOne, undefined, args.alphaFor, undefined, undefined, args.colorOverrides,\n  ));\n  if (args.overlay) commands.push(...args.overlay);\n  return { width, height, view, commands };\n}\n\nfunction defaultCreateCanvas(width: number, height: number): HeadlessCanvasLike {\n  if (typeof OffscreenCanvas !== 'undefined') {\n    return new OffscreenCanvas(width, height);\n  }\n  if (typeof document !== 'undefined') {\n    const c = document.createElement('canvas');\n    c.width = width;\n    c.height = height;\n    return c;\n  }\n  throw new Error('renderSceneToPixels: no canvas source in this environment — supply `gl` or `createCanvas`');\n}\n\n/** Flip GL's bottom-up readback rows into top-down image order. */\nfunction flipRows(raw: Uint8Array, width: number, height: number): Uint8ClampedArray {\n  const rowBytes = width * 4;\n  const out = new Uint8ClampedArray(raw.length);\n  for (let y = 0; y < height; y++) {\n    out.set(raw.subarray((height - 1 - y) * rowBytes, (height - y) * rowBytes), y * rowBytes);\n  }\n  return out;\n}\n\n/** Convert premultiplied RGBA to straight RGBA in place. */\nfunction unpremultiply(data: Uint8ClampedArray): void {\n  for (let i = 0; i < data.length; i += 4) {\n    const a = data[i + 3];\n    if (a === 0 || a === 255) continue;\n    const inv = 255 / a;\n    data[i] = data[i] * inv;\n    data[i + 1] = data[i + 1] * inv;\n    data[i + 2] = data[i + 2] * inv;\n  }\n}\n\n/** Where a {@link RasterSession} draws. Pass `gl` or `createCanvas`, or\n *  neither for the default canvas source. */\nexport interface RasterSessionOptions {\n  /** Caller-owned WebGL2 context. The session never disposes it. Its drawing\n   *  buffer must be at least as large as every render the session does. */\n  gl?: WebGL2RenderingContext;\n  /** Canvas factory, called once, at the size of the first render. The\n   *  session grows the canvas when a later render needs more room and never\n   *  shrinks it. Default: `OffscreenCanvas` when available, else a detached\n   *  DOM canvas. */\n  createCanvas?: (widthPx: number, heightPx: number) => HeadlessCanvasLike;\n}\n\n/** One render through a {@link RasterSession}: everything\n *  `renderSceneToPixels` takes except where to draw. */\nexport type RasterRenderArgs<TData, TLayer extends string, TPose> =\n  Omit<RenderSceneToPixelsArgs<TData, TLayer, TPose>, 'gl' | 'createCanvas'>;\n\n/** One renderer and its GPU caches, kept across any number of headless\n *  renders. Scenes, source rects and scales may differ per render. */\nexport interface RasterSession {\n  /** Same contract as `renderSceneToPixels`. Throws once disposed. */\n  render<TData, TLayer extends string, TPose>(args: RasterRenderArgs<TData, TLayer, TPose>): RasterImage;\n  /** Free every GL resource the session created — programs, geometry, and\n   *  the texture and mesh caches — and drop its own canvas. A caller-owned\n   *  context stays open. Idempotent. */\n  dispose(): void;\n}\n\n/**\n * Open a raster session: one `WeaselRenderer` that many headless renders\n * share, for a consumer producing thumbnails or pages in bulk. Programs\n * compile once, and a bitmap or recurring mesh uploads once, rather than per\n * render. `renderSceneToPixels` is a session opened for one render.\n *\n * The renderer is created on the first render, so opening a session costs\n * nothing and fails nothing. Each render draws into the bottom-left\n * `width × height` of the buffer and reads that region back.\n */\nexport function createRasterSession(options: RasterSessionOptions = {}): RasterSession {\n  if (options.gl && options.createCanvas) {\n    throw new Error('raster session: `gl` and `createCanvas` are mutually exclusive');\n  }\n  let canvas: HeadlessCanvasLike | null = null;\n  let gl: WebGL2RenderingContext | undefined = options.gl;\n  let renderer: WeaselRenderer | null = null;\n  let disposed = false;\n\n  function contextFor(width: number, height: number): WebGL2RenderingContext {\n    if (!options.gl) {\n      if (!canvas) {\n        canvas = (options.createCanvas ?? defaultCreateCanvas)(width, height);\n        canvas.width = width;\n        canvas.height = height;\n        // Same context attributes as the screen path (Canvas.tsx).\n        gl = (canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true }) as WebGL2RenderingContext | null) ?? undefined;\n      } else {\n        if (canvas.width < width) canvas.width = width;\n        if (canvas.height < height) canvas.height = height;\n      }\n    }\n    if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') {\n      throw new Error('raster session: WebGL2 is unavailable — supply `gl` or a WebGL2-capable `createCanvas`');\n    }\n    if (isLost(gl)) {\n      throw new Error('raster session: the WebGL2 context is lost — dispose this session and open another');\n    }\n    // A context clamps a drawing buffer it cannot allocate, and reading past\n    // the real one returns transparent pixels rather than failing.\n    const { drawingBufferWidth: bufferW, drawingBufferHeight: bufferH } = gl;\n    if (bufferW < width || bufferH < height) {\n      throw new Error(\n        `raster session: a ${width} × ${height} render does not fit the context's `\n        + `${bufferW} × ${bufferH} drawing buffer — lower \\`scale\\` or render the source rect in tiles`,\n      );\n    }\n    return gl;\n  }\n\n  return {\n    render(args) {\n      if (disposed) throw new Error('raster session: render() on a disposed session');\n      const plan = planPixelRender(args);\n      const { width, height } = plan;\n      const ctx = contextFor(width, height);\n      const flattenTolerance = (args.flattenTolerancePx ?? 0.25) / Math.max(args.scale.x, args.scale.y);\n      if (!renderer) {\n        renderer = new WeaselRenderer({\n          gl: ctx,\n          width,\n          height,\n          dpr: 1,\n          imageMinification: 'mipmap',\n          flattenTolerance,\n          // Dynamic canvas-SDF glyphs must all bake inline — this path is\n          // synchronous with no notify-and-redraw, and print must be complete.\n          bakeBudget: Infinity,\n        });\n      } else {\n        renderer.resize({ width, height, dpr: 1 });\n        renderer.setFlattenTolerance(flattenTolerance);\n      }\n      renderer.render(plan.commands, viewToMat3(plan.view));\n      if (isLost(ctx)) {\n        throw new Error('raster session: the WebGL2 context was lost during render');\n      }\n      const raw = new Uint8Array(width * height * 4);\n      ctx.readPixels(0, 0, width, height, ctx.RGBA, ctx.UNSIGNED_BYTE, raw);\n      const data = flipRows(raw, width, height);\n      unpremultiply(data);\n      return { width, height, data };\n    },\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      renderer?.dispose();\n      renderer = null;\n      // A browser caps live contexts per page and evicts the oldest, which is\n      // a canvas on screen; a dropped reference frees nothing until collected.\n      if (canvas && !options.createCanvas) gl?.getExtension('WEBGL_lose_context')?.loseContext();\n      canvas = null;\n      gl = undefined;\n    },\n  };\n}\n\nfunction isLost(gl: WebGL2RenderingContext): boolean {\n  return typeof gl.isContextLost === 'function' && gl.isContextLost() === true;\n}\n\n/** What {@link warmRender} loads. */\nexport interface WarmRenderOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {\n  /** The render about to happen, as `renderSceneToPixels` or\n   *  `RasterSession.render` will take it. Its commands are built the way the\n   *  render builds them, and only the faces and paint kinds they draw with\n   *  load. */\n  render?: RasterRenderArgs<TData, TLayer, TPose>;\n  /** Commands about to be drawn, read the same way as `render`'s. Both may be\n   *  given; what either needs loads. */\n  commands?: readonly DrawCommand[];\n  /** Fonts to load in place of the ones derived — family names or single\n   *  variants, as `warmFonts` takes them. */\n  families?: readonly (string | FontRequest)[];\n  /** Paint kinds to load in place of the ones derived, as `warmPaintKinds`\n   *  takes them. */\n  paintKinds?: readonly string[];\n}\n\n/**\n * Load everything a synchronous render would otherwise draw as nothing — the\n * lazily registered font atlases and the paint kinds loaded on demand — so\n * that a `renderSceneToPixels` or `RasterSession.render` issued after it\n * resolves is complete.\n *\n * Pass the render (`{ render: args }`) or its commands, and only what they\n * draw with loads: each face their text is set in, through the same\n * resolution the renderer does, and each paint kind they name. A rejection\n * then means something this render needs failed to load. `families` and\n * `paintKinds` replace either derived list.\n *\n * With neither `render` nor `commands`, an omitted list loads everything\n * registered: every font family and every kind that has a loader — which\n * fails when any one of them does, and fetches what nothing draws.\n */\nexport function warmRender<TData, TLayer extends string, TPose>(\n  opts: WarmRenderOptions<TData, TLayer, TPose> = {},\n): Promise<void> {\n  let { families, paintKinds } = opts;\n  if (opts.render || opts.commands) {\n    let planned: DrawCommand[];\n    try {\n      planned = opts.render ? planPixelRender(opts.render).commands : [];\n    } catch (err) {\n      return Promise.reject(err);\n    }\n    const needs = renderNeeds([...planned, ...(opts.commands ?? [])]);\n    families ??= needs.fonts;\n    // A kind nothing registered draws nothing whether or not this waits.\n    paintKinds ??= needs.paintKinds.filter(isPaintKindKnown);\n  }\n  return Promise.all([warmFonts(families), warmPaintKinds(paintKinds)]).then(() => undefined);\n}\n\n/**\n * Render part of a scene to raw pixels, with no canvas mounted and no React\n * involved — for export, thumbnails, print, and pixel-diff tests.\n *\n * Output size follows from the source rect and the requested scale, so\n * rendering the same region at a higher scale is a real resolution increase\n * rather than an upscale: curves are re-flattened and glyphs re-rasterized for\n * the output resolution.\n *\n * Synchronous, so nothing lands mid-render: a paint kind loaded on demand\n * (`mesh-gradient`, or one declared with `registerPaintKindLoader`) that has\n * not loaded yet draws nothing, and neither does text set in a font atlas\n * still fetching — one registered `{ lazy: true }` is not fetched until text\n * first asks for it. `await warmRender({ render: args })` first.\n *\n * Each call opens a {@link RasterSession} and disposes it before returning.\n * Rendering many scenes, open one with `createRasterSession` instead.\n */\nexport function renderSceneToPixels<TData, TLayer extends string, TPose>(\n  args: RenderSceneToPixelsArgs<TData, TLayer, TPose>,\n): RasterImage {\n  const { gl, createCanvas, ...renderArgs } = args;\n  const session = createRasterSession({ gl, createCanvas });\n  try {\n    return session.render(renderArgs);\n  } finally {\n    session.dispose();\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"renderSceneToPixels.js","names":["viewToMat3","viewToMat3$1","planPixelRender","args","label","v","sourceRect","scale","width","height","view","resolveImage","drawOne","defaultDrawOne","node","pose","ctx","commands","buildSceneViewCommands","defaultCreateCanvas","c","createRasterSession","options","canvas","gl","renderer","disposed","contextFor","isLost","bufferW","bufferH","plan","flattenTolerance","WeaselRenderer","raw","straightTopDown","warmRender","opts","planned","err","needs","renderNeeds","isPaintKindKnown","warmFonts","families","warmPaintKinds","paintKinds","renderSceneToPixels","renderArgs","session"],"sources":["../../src/canvas/renderSceneToPixels.ts"],"sourcesContent":["/**\n * `renderSceneToPixels` — headless rasterization of a scene-space rect to raw RGBA pixels at an\n * explicit, per-axis scale. It drives the same WebGL2 pipeline (`WeaselRenderer` +\n * `buildSceneViewCommands`) as the on-screen view, so print, thumbnail, and export callers get\n * the same pixels the screen would produce at that scale.\n *\n * Environment contract:\n * - Density arrives exclusively via `scale`; this function never reads\n *   `window.devicePixelRatio`.\n * - Rounding: output width = max(1, round(sourceRect.width × |scale.x|)), height analogously.\n *   When round() lands below rect × scale, the rightmost/bottom sub-pixel band of scene content\n *   is cropped; when it rounds up, that band is padded (the `background` fill, or transparent).\n * - Context lifetime: a caller-supplied `gl` is caller-owned. It is never disposed here, and\n *   its drawing buffer must be at least width × height pixels (the render targets the\n *   bottom-left region). Auto-created canvases are discarded with the session.\n * - Context loss: throws — a lost context cannot produce pixels, and the silent-noop\n *   convention of the screen path would return all-zero bytes.\n * - Output: top-down row order, NON-premultiplied (\"straight\") RGBA. The GL framebuffer is\n *   premultiplied and bottom-up; readback flips and unpremultiplies.\n * - Determinism: same context + same inputs → same bytes. Cross-driver / cross-machine byte\n *   equality is NOT guaranteed; do not build golden-image tests on committed bytes.\n * - Image quality: image textures upload with mipmaps so minified bitmaps don't moiré, and\n *   curve tessellation runs at an output-scale tolerance (`flattenTolerancePx`, default 0.25\n *   output px).\n */\nimport { WeaselRenderer } from '@weasel-js/renderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport type { Node, Scene } from 'core/scene/types';\nimport { buildSceneViewCommands, type SceneViewDrawOne } from './sceneViewRender';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport { defaultDrawOne } from './defaultDrawOne';\nimport { warmFonts, type FontRequest } from '@weasel-js/font';\nimport { isPaintKindKnown, warmPaintKinds } from '@weasel-js/renderer';\nimport { renderNeeds } from './renderNeeds';\nimport { straightTopDown } from './rasterReadback';\n\n/** Plain RGBA raster — structurally `ImageData`-compatible ({ width, height,\n *  data }), deliberately free of printer/dpi/physical-unit concepts. */\nexport interface RasterImage {\n  width: number;\n  height: number;\n  /** Top-down, straight (non-premultiplied) RGBA, 4 bytes per pixel. */\n  data: Uint8ClampedArray;\n}\n\n/** Minimal canvas contract for `createCanvas` injection: `OffscreenCanvas`,\n *  an HTML canvas, or a test fake. */\nexport interface HeadlessCanvasLike {\n  width: number;\n  height: number;\n  getContext(contextId: 'webgl2', options?: WebGLContextAttributes): unknown;\n}\n\n/** What to render, at what resolution, and with which quality settings. */\nexport interface RenderSceneToPixelsArgs<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Scene-space rect to render (origin + size in scene units). Output pixel\n   *  dimensions follow from rect × scale (round, min 1 — see module doc). */\n  sourceRect: { x: number; y: number; width: number; height: number };\n  /** Output pixels per scene unit, per axis. Anisotropic values supported. A\n   *  negative axis is flipped: the output is sized from its magnitude, and the\n   *  rect's far edge on that axis lands on the output's top or left. */\n  scale: { x: number; y: number };\n  /** Per-node draw callback. Default: `defaultDrawOne` with `resolveImage`\n   *  merged into the `NodePaintCtx` the scene walk supplies. Custom `drawOne`\n   *  callers that still want resolver injection should call\n   *  `defaultDrawOne(node, pose, view, { ...ctx, resolveImage })` themselves —\n   *  dropping the walk's `ctx` drops derived geometry with it. */\n  drawOne?: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Bitmap resolver for image nodes — lets consumers reuse their own decode\n   *  caches. `undefined` results paint the deterministic grey placeholder\n   *  outline (see `NodePaintCtx.resolveImage`). */\n  resolveImage?: (node: Node<TData, TLayer, TPose>) => ImageBitmap | undefined;\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the on-screen canvas uses so an\n   *  export matches what the user is looking at. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides`, so an export shows the frame on screen. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Background fill (any CSS color accepted by the renderer). Default:\n   *  fully transparent. Passing a color is always valid. */\n  background?: string;\n  /** Caller-owned WebGL2 context to render with. Mutually exclusive with\n   *  `createCanvas`. Never disposed by this call. */\n  gl?: WebGL2RenderingContext;\n  /** One-shot canvas factory (DOM canvas, OffscreenCanvas, or test fake).\n   *  Mutually exclusive with `gl`. Default: `OffscreenCanvas` when\n   *  available, else `document.createElement('canvas')`. */\n  createCanvas?: (widthPx: number, heightPx: number) => HeadlessCanvasLike;\n  /** Max curve-flattening error in OUTPUT pixels. Default 0.25. Converted to\n   *  world units against the larger scale axis. */\n  flattenTolerancePx?: number;\n  /** Commands drawn over the scene in output-pixel space — origin at the\n   *  output's top-left, one unit per output pixel. Annotations, watermarks,\n   *  and `renderDebugSnapshot`'s overlay ride here. */\n  overlay?: readonly DrawCommand[];\n}\n\n/** The result of planning a headless render: how big the output is, the view\n *  that maps the source rect onto it, and the commands to draw. */\nexport interface PixelRenderPlan {\n  width: number;\n  height: number;\n  view: View;\n  commands: DrawCommand[];\n}\n\n/** Pure planning half of `renderSceneToPixels`: output dimensions, the\n *  anisotropic `View`, and the full command list (background + view-wrapped\n *  scene). Exported for tests and for callers targeting their own renderer. */\nexport function planPixelRender<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToPixelsArgs<TData, TLayer, TPose>, 'gl' | 'createCanvas' | 'flattenTolerancePx'>,\n): PixelRenderPlan {\n  const { sourceRect, scale } = args;\n  for (const [label, v] of [\n    ['sourceRect.width', sourceRect.width], ['sourceRect.height', sourceRect.height],\n  ] as const) {\n    if (!Number.isFinite(v) || v <= 0) {\n      throw new Error(`renderSceneToPixels: ${label} must be a positive finite number, got ${v}`);\n    }\n  }\n  for (const [label, v] of [['scale.x', scale.x], ['scale.y', scale.y]] as const) {\n    if (!Number.isFinite(v) || v === 0) {\n      throw new Error(`renderSceneToPixels: ${label} must be a nonzero finite number, got ${v}`);\n    }\n  }\n  for (const [label, v] of [\n    ['sourceRect.x', sourceRect.x], ['sourceRect.y', sourceRect.y],\n  ] as const) {\n    if (!Number.isFinite(v)) {\n      throw new Error(`renderSceneToPixels: ${label} must be a finite number, got ${v}`);\n    }\n  }\n  const width = Math.max(1, Math.round(sourceRect.width * Math.abs(scale.x)));\n  const height = Math.max(1, Math.round(sourceRect.height * Math.abs(scale.y)));\n  const view: View = {\n    x: scale.x < 0 ? sourceRect.x + sourceRect.width : sourceRect.x,\n    y: scale.y < 0 ? sourceRect.y + sourceRect.height : sourceRect.y,\n    scale: { x: scale.x, y: scale.y },\n  };\n\n  const resolveImage = args.resolveImage as ((n: Node<unknown, string, unknown>) => ImageBitmap | undefined) | undefined;\n  const drawOne: SceneViewDrawOne<TData, TLayer, TPose> =\n    args.drawOne ?? ((node, pose, view, ctx) => defaultDrawOne(node, pose, view, { ...ctx, resolveImage }));\n\n  const commands: DrawCommand[] = [];\n  if (args.background !== undefined) {\n    // Screen-space (pre-view) fill so rounding can never leave uncovered\n    // edge pixels.\n    commands.push({\n      kind: 'path',\n      path: { kind: 'rect', x: 0, y: 0, width, height },\n      fill: { paint: { kind: 'solid', color: args.background } },\n    });\n  }\n  commands.push(...buildSceneViewCommands(\n    args.scene, view, drawOne, undefined, args.alphaFor, undefined, args.colorOverrides,\n  ));\n  if (args.overlay) commands.push(...args.overlay);\n  return { width, height, view, commands };\n}\n\nfunction defaultCreateCanvas(width: number, height: number): HeadlessCanvasLike {\n  if (typeof OffscreenCanvas !== 'undefined') {\n    return new OffscreenCanvas(width, height);\n  }\n  if (typeof document !== 'undefined') {\n    const c = document.createElement('canvas');\n    c.width = width;\n    c.height = height;\n    return c;\n  }\n  throw new Error('renderSceneToPixels: no canvas source in this environment — supply `gl` or `createCanvas`');\n}\n\n/** Where a {@link RasterSession} draws. Pass `gl` or `createCanvas`, or\n *  neither for the default canvas source. */\nexport interface RasterSessionOptions {\n  /** Caller-owned WebGL2 context. The session never disposes it. Its drawing\n   *  buffer must be at least as large as every render the session does. */\n  gl?: WebGL2RenderingContext;\n  /** Canvas factory, called once, at the size of the first render. The\n   *  session grows the canvas when a later render needs more room and never\n   *  shrinks it. Default: `OffscreenCanvas` when available, else a detached\n   *  DOM canvas. */\n  createCanvas?: (widthPx: number, heightPx: number) => HeadlessCanvasLike;\n}\n\n/** One render through a {@link RasterSession}: everything\n *  `renderSceneToPixels` takes except where to draw. */\nexport type RasterRenderArgs<TData, TLayer extends string, TPose> =\n  Omit<RenderSceneToPixelsArgs<TData, TLayer, TPose>, 'gl' | 'createCanvas'>;\n\n/** One renderer and its GPU caches, kept across any number of headless\n *  renders. Scenes, source rects and scales may differ per render. */\nexport interface RasterSession {\n  /** Same contract as `renderSceneToPixels`. Throws once disposed. */\n  render<TData, TLayer extends string, TPose>(args: RasterRenderArgs<TData, TLayer, TPose>): RasterImage;\n  /** Free every GL resource the session created — programs, geometry, and\n   *  the texture and mesh caches — and drop its own canvas. A caller-owned\n   *  context stays open. Idempotent. */\n  dispose(): void;\n}\n\n/**\n * Open a raster session: one `WeaselRenderer` that many headless renders\n * share, for a consumer producing thumbnails or pages in bulk. Programs\n * compile once, and a bitmap or recurring mesh uploads once, rather than per\n * render. `renderSceneToPixels` is a session opened for one render.\n *\n * The renderer is created on the first render, so opening a session costs\n * nothing and fails nothing. Each render draws into the bottom-left\n * `width × height` of the buffer and reads that region back.\n */\nexport function createRasterSession(options: RasterSessionOptions = {}): RasterSession {\n  if (options.gl && options.createCanvas) {\n    throw new Error('raster session: `gl` and `createCanvas` are mutually exclusive');\n  }\n  let canvas: HeadlessCanvasLike | null = null;\n  let gl: WebGL2RenderingContext | undefined = options.gl;\n  let renderer: WeaselRenderer | null = null;\n  let disposed = false;\n\n  function contextFor(width: number, height: number): WebGL2RenderingContext {\n    if (!options.gl) {\n      if (!canvas) {\n        canvas = (options.createCanvas ?? defaultCreateCanvas)(width, height);\n        canvas.width = width;\n        canvas.height = height;\n        // Same context attributes as the screen path (Canvas.tsx).\n        gl = (canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true }) as WebGL2RenderingContext | null) ?? undefined;\n      } else {\n        if (canvas.width < width) canvas.width = width;\n        if (canvas.height < height) canvas.height = height;\n      }\n    }\n    if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') {\n      throw new Error('raster session: WebGL2 is unavailable — supply `gl` or a WebGL2-capable `createCanvas`');\n    }\n    if (isLost(gl)) {\n      throw new Error('raster session: the WebGL2 context is lost — dispose this session and open another');\n    }\n    // A context clamps a drawing buffer it cannot allocate, and reading past\n    // the real one returns transparent pixels rather than failing.\n    const { drawingBufferWidth: bufferW, drawingBufferHeight: bufferH } = gl;\n    if (bufferW < width || bufferH < height) {\n      throw new Error(\n        `raster session: a ${width} × ${height} render does not fit the context's `\n        + `${bufferW} × ${bufferH} drawing buffer — lower \\`scale\\` or render the source rect in tiles`,\n      );\n    }\n    return gl;\n  }\n\n  return {\n    render(args) {\n      if (disposed) throw new Error('raster session: render() on a disposed session');\n      const plan = planPixelRender(args);\n      const { width, height } = plan;\n      const ctx = contextFor(width, height);\n      const flattenTolerance = (args.flattenTolerancePx ?? 0.25) / Math.max(Math.abs(args.scale.x), Math.abs(args.scale.y));\n      if (!renderer) {\n        renderer = new WeaselRenderer({\n          gl: ctx,\n          width,\n          height,\n          dpr: 1,\n          imageMinification: 'mipmap',\n          flattenTolerance,\n          // Dynamic canvas-SDF glyphs must all bake inline — this path is\n          // synchronous with no notify-and-redraw, and print must be complete.\n          bakeBudget: Infinity,\n        });\n      } else {\n        renderer.resize({ width, height, dpr: 1 });\n        renderer.setFlattenTolerance(flattenTolerance);\n      }\n      renderer.render(plan.commands, viewToMat3(plan.view));\n      if (isLost(ctx)) {\n        throw new Error('raster session: the WebGL2 context was lost during render');\n      }\n      const raw = new Uint8Array(width * height * 4);\n      ctx.readPixels(0, 0, width, height, ctx.RGBA, ctx.UNSIGNED_BYTE, raw);\n      return { width, height, data: straightTopDown(raw, width, height) };\n    },\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      renderer?.dispose();\n      renderer = null;\n      // A browser caps live contexts per page and evicts the oldest, which is\n      // a canvas on screen; a dropped reference frees nothing until collected.\n      if (canvas && !options.createCanvas) gl?.getExtension('WEBGL_lose_context')?.loseContext();\n      canvas = null;\n      gl = undefined;\n    },\n  };\n}\n\nfunction isLost(gl: WebGL2RenderingContext): boolean {\n  return typeof gl.isContextLost === 'function' && gl.isContextLost() === true;\n}\n\n/** What {@link warmRender} loads. */\nexport interface WarmRenderOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {\n  /** The render about to happen, as `renderSceneToPixels` or\n   *  `RasterSession.render` will take it. Its commands are built the way the\n   *  render builds them, and only the faces and paint kinds they draw with\n   *  load. */\n  render?: RasterRenderArgs<TData, TLayer, TPose>;\n  /** Commands about to be drawn, read the same way as `render`'s. Both may be\n   *  given; what either needs loads. */\n  commands?: readonly DrawCommand[];\n  /** Fonts to load in place of the ones derived — family names or single\n   *  variants, as `warmFonts` takes them. */\n  families?: readonly (string | FontRequest)[];\n  /** Paint kinds to load in place of the ones derived, as `warmPaintKinds`\n   *  takes them. */\n  paintKinds?: readonly string[];\n}\n\n/**\n * Load everything a synchronous render would otherwise draw as nothing — the\n * lazily registered font atlases and the paint kinds loaded on demand — so\n * that a `renderSceneToPixels` or `RasterSession.render` issued after it\n * resolves is complete.\n *\n * Pass the render (`{ render: args }`) or its commands, and only what they\n * draw with loads: each face their text is set in, through the same\n * resolution the renderer does, and each paint kind they name. A rejection\n * then means something this render needs failed to load. `families` and\n * `paintKinds` replace either derived list.\n *\n * With neither `render` nor `commands`, an omitted list loads everything\n * registered: every font family and every kind that has a loader — which\n * fails when any one of them does, and fetches what nothing draws.\n */\nexport function warmRender<TData, TLayer extends string, TPose>(\n  opts: WarmRenderOptions<TData, TLayer, TPose> = {},\n): Promise<void> {\n  let { families, paintKinds } = opts;\n  if (opts.render || opts.commands) {\n    let planned: DrawCommand[];\n    try {\n      planned = opts.render ? planPixelRender(opts.render).commands : [];\n    } catch (err) {\n      return Promise.reject(err);\n    }\n    const needs = renderNeeds([...planned, ...(opts.commands ?? [])]);\n    families ??= needs.fonts;\n    // A kind nothing registered draws nothing whether or not this waits.\n    paintKinds ??= needs.paintKinds.filter(isPaintKindKnown);\n  }\n  return Promise.all([warmFonts(families), warmPaintKinds(paintKinds)]).then(() => undefined);\n}\n\n/**\n * Render part of a scene to raw pixels, with no canvas mounted and no React\n * involved — for export, thumbnails, print, and pixel-diff tests.\n *\n * Output size follows from the source rect and the requested scale, so\n * rendering the same region at a higher scale is a real resolution increase\n * rather than an upscale: curves are re-flattened and glyphs re-rasterized for\n * the output resolution.\n *\n * Synchronous, so nothing lands mid-render: a paint kind loaded on demand\n * (`mesh-gradient`, or one declared with `registerPaintKindLoader`) that has\n * not loaded yet draws nothing, and neither does text set in a font atlas\n * still fetching — one registered `{ lazy: true }` is not fetched until text\n * first asks for it. `await warmRender({ render: args })` first.\n *\n * Each call opens a {@link RasterSession} and disposes it before returning.\n * Rendering many scenes, open one with `createRasterSession` instead.\n */\nexport function renderSceneToPixels<TData, TLayer extends string, TPose>(\n  args: RenderSceneToPixelsArgs<TData, TLayer, TPose>,\n): RasterImage {\n  const { gl, createCanvas, ...renderArgs } = args;\n  const session = createRasterSession({ gl, createCanvas });\n  try {\n    return session.render(renderArgs);\n  } finally {\n    session.dispose();\n  }\n}\n"],"mappings":"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"}

package/dist/canvas/sceneAdapter.js

@@ -1,145 +1,81 @@
-import { composeWorldPose as e, frameAtOrAbove as t } from "../core/scene/composeFrame.js";
-import { definesFrame as n, effectivePose as r } from "../core/scene/effectivePose.js";
-import { poseDescriptorForNode as i, translatePoseViaDescriptor as a, visualBoundsViaDescriptor as o } from "../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as s } from "../interactions/actions/resize/autoPoseDescriptor.js";
-import { asNodeId as c } from "../core/scene/types.js";
-import { fnFieldsOfNode as l } from "../core/scene/nodeFnFields.js";
-import { pickability as u } from "../core/scene/pickability.js";
+import { composeWorldPose as e, composesFrames as t, frameAtOrAbove as n } from "../core/scene/composeFrame.js";
+import { definesFrame as r, effectivePose as i } from "../core/scene/effectivePose.js";
+import { poseDescriptorForNode as a, translatePoseViaDescriptor as o, visualBoundsViaDescriptor as s } from "../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as c } from "../core/geometry/autoPoseDescriptor.js";
+import { asNodeId as l } from "../core/scene/types.js";
+import { sceneMutators as u } from "../core/scene/sceneMutators.js";
 import { applyOpsTo as d } from "../core/applyOps.js";
 import { hitTestArea as f, hitTestLassoPolygon as p, regionPickOptions as m } from "./deps/hitTestArea.js";
-import { pasteSceneSnapshot as h, snapshotSceneSelection as g } from "./sceneClipboard.js";
-import { useMemo as _ } from "react";
+import { scenePoseTarget as h } from "../animation/poseTarget.js";
+import { cascadingSetPose as g, containerCascade as _ } from "./poseCascade.js";
+import { pasteSceneSnapshot as v, snapshotSceneSelection as y } from "./sceneClipboard.js";
 //#region src/canvas/sceneAdapter.ts
-function v(_, v = {}) {
-	let y = () => {
+function b(b, x = {}) {
+	let S = () => {
 		let e = /* @__PURE__ */ new Set();
-		for (let t of _.layers) t.visible && e.add(t.id);
+		for (let t of b.layers) t.visible && e.add(t.id);
 		return e;
-	}, b = v.selection, x = b?.getSelection ?? b?.get ?? (() => []), S = b?.setSelection ?? b?.set ?? (() => {}), C = v.poseDescriptor ?? s, w = (e, t) => o(e, i(C, t)), T = (e, t, n, r) => a(e, t, n, r === void 0 ? C : i(C, r)), E = v.poseComposition, D = E !== void 0 && E.closure !== "identity", O = E ? { poseComposition: E } : {}, k = (e) => e ? {
-		...O,
-		...m(e, void 0, void 0)
-	} : O;
-	if (D && v.cascadeContainerPose) throw Error("sceneToAdapter: poseComposition and cascadeContainerPose contradict each other. Under a composing strategy a child's pose is already relative to its parent, so the cascade would move every descendant twice. Drop cascadeContainerPose.");
-	let A = {
-		scene: _,
-		composes: D,
-		worldPoseOf: (e) => j.getWorldPose(e),
-		frameAtOrAbove: (e) => t(j, e),
-		poseBounds: w,
-		translate: T
-	}, j = {
-		getNode(e) {
-			return _.get(c(e));
-		},
+	}, C = x.selection, w = C?.getSelection ?? C?.get ?? (() => []), T = C?.setSelection ?? C?.set ?? (() => {}), E = x.poseDescriptor ?? c, D = (e, t) => s(e, a(E, t)), O = (e, t, n, r) => o(e, t, n, r === void 0 ? E : a(E, r)), k = b.composition, A = t(k), j = {}, M = (e) => e ? {
+		...j,
+		...m(e, void 0)
+	} : j, N = A ? null : { setPose: g(b, E) }, P = {
+		scene: b,
+		composes: A,
+		worldPoseOf: (e) => F.getWorldPose(e),
+		frameAtOrAbove: (e) => n(F, e),
+		poseBounds: D,
+		translate: O
+	}, F = {
+		...u(b),
 		getNodes() {
-			let e = y(), t = [];
-			for (let n of _.renderOrderNodes()) e.has(n.layer) && t.push(n);
+			let e = S(), t = [];
+			for (let n of b.renderOrderNodes()) e.has(n.layer) && t.push(n);
 			return t;
 		},
 		getPose(e) {
-			let t = c(e), n = _.get(t);
+			let t = l(e), n = b.get(t);
 			if (!n) throw Error(`sceneToAdapter: unknown node "${e}"`);
-			return r(_, n);
-		},
-		getParent(e) {
-			return _.get(c(e))?.parent ?? null;
+			return i(b, n);
 		},
 		definesFrame(e) {
-			let t = _.get(c(e));
-			return t === void 0 || n(t);
+			let t = b.get(l(e));
+			return t === void 0 || r(t);
 		},
 		getWorldPose(t) {
-			return D ? e(j, t, E.compose) : j.getPose(t);
-		},
-		...D ? { composePose: E.compose } : {},
-		setPose(e, t) {
-			if (v.cascadeContainerPose) {
-				let n = _.get(c(e));
-				if (n && n.kind === "container") {
-					let r = i(C, n), a = r.getBounds(n.pose), o = r.getBounds(t), s = o.x - a.x, l = o.y - a.y;
-					if (s !== 0 || l !== 0) {
-						let n = [], r = (e) => {
-							for (let t of _.childrenOf(c(e))) n.push(t), r(t);
-						};
-						r(e), _.batch("move container", () => {
-							_.setPose(c(e), t);
-							for (let e of n) {
-								let t = _.get(c(e));
-								t && _.setPose(c(e), T(t.pose, s, l, t));
-							}
-						});
-						return;
-					}
-				}
-			}
-			_.setPose(c(e), t);
-		},
-		setParent(e, t) {
-			_.move(c(e), t === null ? null : c(t));
-		},
-		getChildren(e) {
-			return e === null ? [..._.roots] : [..._.childrenOf(c(e))];
-		},
-		setChildOrder(e, t) {
-			_.batch("Reorder", () => {
-				for (let n = 0; n < t.length; n++) (e === null ? _.roots : _.childrenOf(c(e)))[n] !== t[n] && _.reorder(c(t[n]), n);
-			});
-		},
-		getLayers() {
-			return _.layers.map((e) => ({
-				id: e.id,
-				visible: e.visible,
-				parallax: e.parallax
-			}));
-		},
-		getLayout(e) {
-			let t = _.layoutOf(c(e));
-			return t !== null || !v.layouts ? t : typeof v.layouts == "function" ? v.layouts(e) : v.layouts[e] ?? null;
-		},
+			return A ? e(F, t, k.compose) : F.getPose(t);
+		},
+		...A ? { composePose: k.compose } : {},
+		...N ? { setPose: (e, t) => N.setPose(l(e), t) } : {},
+		poseTarget(e, t) {
+			if (N === null || b.get(l(e))?.kind !== "container") return h(b, e, t ?? E);
+			let n = _(b, l(e), E, (t) => F.setPose(e, t));
+			return h(b, e, t ?? E, n);
+		},
+		getLayers: () => b.layers.map((e) => ({
+			id: e.id,
+			visible: e.visible,
+			parallax: e.parallax
+		})),
+		subscribeLayers: (e) => b.subscribe(e),
+		getLayout: (e) => b.layoutOf(l(e)),
 		applyOps(e, t) {
-			t === void 0 ? d(this, e) : _.applyBatch(e, t, this);
-		},
-		insertNode(e, t) {
-			_.add({
-				kind: e.kind,
-				layer: e.layer,
-				pose: e.pose,
-				data: e.data,
-				id: e.id,
-				...t === void 0 ? {} : { index: t },
-				...e.parent === null ? {} : { parent: e.parent },
-				...e.dependsOn === void 0 ? {} : { dependsOn: e.dependsOn },
-				...u(e),
-				...l(e)
-			});
-		},
-		removeNode(e) {
-			_.remove(c(e));
-		},
-		setData(e, t) {
-			_.update(c(e), { data: t });
+			t === void 0 ? d(this, e) : b.applyBatch(e, t, this);
 		},
-		setLayout(e, t) {
-			_.setLayout(c(e), t);
-		},
-		getRemovalClosure(e) {
-			return [..._.removalClosure(e.map(c))];
-		},
-		getSelection: x,
-		setSelection: S,
+		getSelection: w,
+		setSelection: T,
 		hitTestArea(e, t) {
-			return f(_, e, k(t), C, { includeContainers: !0 });
+			return f(b, e, M(t), E, { includeContainers: !0 });
 		},
 		hitTestLasso(e, t, n) {
-			return p(_, e, t, k(n), C, { includeContainers: !0 });
+			return p(b, e, t, M(n), E, { includeContainers: !0 });
 		},
-		...v.commitInsert ? { commitInsert: (e) => {
-			let t = v.commitInsert(e);
+		...x.commitInsert ? { commitInsert: (e) => {
+			let t = x.commitInsert(e);
 			if (!t) return null;
-			let n = v.insertLayer ?? "default";
+			let n = x.insertLayer ?? "default";
 			return {
 				kind: "leaf",
-				id: t.id === void 0 ? _.mintId() : c(t.id),
+				id: t.id === void 0 ? b.mintId() : l(t.id),
 				layer: n,
 				pose: t.pose,
 				data: t.data,
@@ -147,10 +83,10 @@ function v(_, v = {}) {
 			};
 		} } : {},
 		snapshotSelection(e) {
-			return g(A, e);
+			return y(P, e);
 		},
 		commitPaste(e, t, n) {
-			return h(A, e, t, n);
+			return v(P, e, t, n);
 		},
 		getPasteOffset() {
 			return {
@@ -159,30 +95,9 @@ function v(_, v = {}) {
 			};
 		}
 	};
-	return j;
-}
-function y(e, t = {}) {
-	let { selection: n, commitInsert: r, insertLayer: i, layouts: a, poseDescriptor: o, cascadeContainerPose: s, poseComposition: c } = t;
-	return _(() => v(e, {
-		selection: n,
-		commitInsert: r,
-		insertLayer: i,
-		layouts: a,
-		poseDescriptor: o,
-		cascadeContainerPose: s,
-		poseComposition: c
-	}), [
-		e,
-		n,
-		r,
-		i,
-		a,
-		o,
-		s,
-		c
-	]);
+	return F;
 }
 //#endregion
-export { v as sceneToAdapter, y as useSceneAdapter };
+export { b as sceneToAdapter };
 
 //# sourceMappingURL=sceneAdapter.js.map