@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/renderSceneToPixels.js

@@ -1,126 +1,241 @@
-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";
+import { defaultDrawOne } from "./defaultDrawOne.js";
+import { buildSceneViewCommands } from "./sceneViewRender.js";
+import { renderNeeds } from "./renderNeeds.js";
+import { straightTopDown } from "./rasterReadback.js";
+import { WeaselRenderer, isPaintKindKnown, warmPaintKinds } from "@weasel-js/renderer";
+import { viewToMat3 as viewToMat3$1 } from "@weasel-js/geom";
+import { warmFonts } from "@weasel-js/font";
+
 //#region src/canvas/renderSceneToPixels.ts
-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,
+/**
+* `renderSceneToPixels` — headless rasterization of a scene-space rect to raw RGBA pixels at an
+* explicit, per-axis scale. It drives the same WebGL2 pipeline (`WeaselRenderer` +
+* `buildSceneViewCommands`) as the on-screen view, so print, thumbnail, and export callers get
+* the same pixels the screen would produce at that scale.
+*
+* Environment contract:
+* - Density arrives exclusively via `scale`; this function never reads
+*   `window.devicePixelRatio`.
+* - Rounding: output width = max(1, round(sourceRect.width × |scale.x|)), height analogously.
+*   When round() lands below rect × scale, the rightmost/bottom sub-pixel band of scene content
+*   is cropped; when it rounds up, that band is padded (the `background` fill, or transparent).
+* - Context lifetime: a caller-supplied `gl` is caller-owned. It is never disposed here, and
+*   its drawing buffer must be at least width × height pixels (the render targets the
+*   bottom-left region). Auto-created canvases are discarded with the session.
+* - Context loss: throws — a lost context cannot produce pixels, and the silent-noop
+*   convention of the screen path would return all-zero bytes.
+* - Output: top-down row order, NON-premultiplied ("straight") RGBA. The GL framebuffer is
+*   premultiplied and bottom-up; readback flips and unpremultiplies.
+* - Determinism: same context + same inputs → same bytes. Cross-driver / cross-machine byte
+*   equality is NOT guaranteed; do not build golden-image tests on committed bytes.
+* - Image quality: image textures upload with mipmaps so minified bitmaps don't moiré, and
+*   curve tessellation runs at an output-scale tolerance (`flattenTolerancePx`, default 0.25
+*   output px).
+*/
+/** Pure planning half of `renderSceneToPixels`: output dimensions, the
+*  anisotropic `View`, and the full command list (background + view-wrapped
+*  scene). Exported for tests and for callers targeting their own renderer. */
+function planPixelRender(args) {
+	const { sourceRect, scale } = args;
+	for (const [label, v] of [["sourceRect.width", sourceRect.width], ["sourceRect.height", sourceRect.height]]) if (!Number.isFinite(v) || v <= 0) throw new Error(`renderSceneToPixels: ${label} must be a positive finite number, got ${v}`);
+	for (const [label, v] of [["scale.x", scale.x], ["scale.y", scale.y]]) if (!Number.isFinite(v) || v === 0) throw new Error(`renderSceneToPixels: ${label} must be a nonzero finite number, got ${v}`);
+	for (const [label, v] of [["sourceRect.x", sourceRect.x], ["sourceRect.y", sourceRect.y]]) if (!Number.isFinite(v)) throw new Error(`renderSceneToPixels: ${label} must be a finite number, got ${v}`);
+	const width = Math.max(1, Math.round(sourceRect.width * Math.abs(scale.x)));
+	const height = Math.max(1, Math.round(sourceRect.height * Math.abs(scale.y)));
+	const view = {
+		x: scale.x < 0 ? sourceRect.x + sourceRect.width : sourceRect.x,
+		y: scale.y < 0 ? sourceRect.y + sourceRect.height : sourceRect.y,
 		scale: {
-			x: i.x,
-			y: i.y
+			x: scale.x,
+			y: scale.y
 		}
-	}, c = n.resolveImage, l = n.drawOne ?? ((t, n, r, i) => e(t, n, r, {
-		...i,
-		resolveImage: c
-	})), u = [];
-	return n.background !== void 0 && u.push({
+	};
+	const resolveImage = args.resolveImage;
+	const drawOne = args.drawOne ?? ((node, pose, view, ctx) => defaultDrawOne(node, pose, view, {
+		...ctx,
+		resolveImage
+	}));
+	const commands = [];
+	if (args.background !== void 0) commands.push({
 		kind: "path",
 		path: {
 			kind: "rect",
 			x: 0,
 			y: 0,
-			width: a,
-			height: o
+			width,
+			height
 		},
 		fill: { paint: {
 			kind: "solid",
-			color: n.background
+			color: args.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
+	});
+	commands.push(...buildSceneViewCommands(args.scene, view, drawOne, void 0, args.alphaFor, void 0, args.colorOverrides));
+	if (args.overlay) commands.push(...args.overlay);
+	return {
+		width,
+		height,
+		view,
+		commands
 	};
 }
-function u(e, t) {
-	if (typeof OffscreenCanvas < "u") return new OffscreenCanvas(e, t);
-	if (typeof document < "u") {
-		let n = document.createElement("canvas");
-		return n.width = e, n.height = t, n;
+function defaultCreateCanvas(width, height) {
+	if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(width, height);
+	if (typeof document !== "undefined") {
+		const c = document.createElement("canvas");
+		c.width = width;
+		c.height = height;
+		return c;
 	}
-	throw Error("renderSceneToPixels: no canvas source in this environment — supply `gl` or `createCanvas`");
+	throw new Error("renderSceneToPixels: no canvas source in this environment — supply `gl` or `createCanvas`");
 }
-function d(e = {}) {
-	if (e.gl && e.createCanvas) throw Error("raster session: `gl` and `createCanvas` are mutually exclusive");
-	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)), !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;
+/**
+* Open a raster session: one `WeaselRenderer` that many headless renders
+* share, for a consumer producing thumbnails or pages in bulk. Programs
+* compile once, and a bitmap or recurring mesh uploads once, rather than per
+* render. `renderSceneToPixels` is a session opened for one render.
+*
+* The renderer is created on the first render, so opening a session costs
+* nothing and fails nothing. Each render draws into the bottom-left
+* `width × height` of the buffer and reads that region back.
+*/
+function createRasterSession(options = {}) {
+	if (options.gl && options.createCanvas) throw new Error("raster session: `gl` and `createCanvas` are mutually exclusive");
+	let canvas = null;
+	let gl = options.gl;
+	let renderer = null;
+	let disposed = false;
+	function contextFor(width, height) {
+		if (!options.gl) {
+			if (!canvas) {
+				canvas = (options.createCanvas ?? defaultCreateCanvas)(width, height);
+				canvas.width = width;
+				canvas.height = height;
+				gl = canvas.getContext("webgl2", {
+					preserveDrawingBuffer: true,
+					stencil: true
+				}) ?? void 0;
+			} else {
+				if (canvas.width < width) canvas.width = width;
+				if (canvas.height < height) canvas.height = height;
+			}
+		}
+		if (!gl || typeof gl.enable !== "function") throw new Error("raster session: WebGL2 is unavailable — supply `gl` or a WebGL2-capable `createCanvas`");
+		if (isLost(gl)) throw new Error("raster session: the WebGL2 context is lost — dispose this session and open another");
+		const { drawingBufferWidth: bufferW, drawingBufferHeight: bufferH } = gl;
+		if (bufferW < width || bufferH < height) throw new Error(`raster session: a ${width} × ${height} render does not fit the context's ${bufferW} × ${bufferH} drawing buffer — lower \`scale\` or render the source rect in tiles`);
+		return gl;
 	}
 	return {
-		render(e) {
-			if (o) throw Error("raster session: render() on a disposed session");
-			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: n,
-				height: u,
-				dpr: 1
-			}), a.setFlattenTolerance(p)) : a = new i({
-				gl: d,
-				width: n,
-				height: u,
+		render(args) {
+			if (disposed) throw new Error("raster session: render() on a disposed session");
+			const plan = planPixelRender(args);
+			const { width, height } = plan;
+			const ctx = contextFor(width, height);
+			const flattenTolerance = { px: args.flattenTolerancePx ?? .25 };
+			if (!renderer) renderer = new WeaselRenderer({
+				gl: ctx,
+				width,
+				height,
 				dpr: 1,
 				imageMinification: "mipmap",
-				flattenTolerance: p,
+				flattenTolerance,
 				bakeBudget: Infinity
-			}), 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)
+			});
+			else {
+				renderer.resize({
+					width,
+					height,
+					dpr: 1
+				});
+				renderer.setFlattenTolerance(flattenTolerance);
+			}
+			renderer.render(plan.commands, viewToMat3$1(plan.view));
+			if (isLost(ctx)) throw new Error("raster session: the WebGL2 context was lost during render");
+			const raw = new Uint8Array(width * height * 4);
+			ctx.readPixels(0, 0, width, height, ctx.RGBA, ctx.UNSIGNED_BYTE, raw);
+			return {
+				width,
+				height,
+				data: straightTopDown(raw, width, height)
 			};
 		},
 		dispose() {
-			o || (o = !0, a?.dispose(), a = null, t && !e.createCanvas && n?.getExtension("WEBGL_lose_context")?.loseContext(), t = null, n = void 0);
+			if (disposed) return;
+			disposed = true;
+			renderer?.dispose();
+			renderer = null;
+			if (canvas && !options.createCanvas) gl?.getExtension("WEBGL_lose_context")?.loseContext();
+			canvas = null;
+			gl = void 0;
 		}
 	};
 }
-function f(e) {
-	return typeof e.isContextLost == "function" && e.isContextLost() === !0;
+function isLost(gl) {
+	return typeof gl.isContextLost === "function" && gl.isContextLost() === true;
 }
-function p(e = {}) {
-	let { families: t, paintKinds: r } = e;
-	if (e.render || e.commands) {
-		let i;
+/**
+* Load everything a synchronous render would otherwise draw as nothing — the
+* lazily registered font atlases and the paint kinds loaded on demand — so
+* that a `renderSceneToPixels` or `RasterSession.render` issued after it
+* resolves is complete.
+*
+* Pass the render (`{ render: args }`) or its commands, and only what they
+* draw with loads: each face their text is set in, through the same
+* resolution the renderer does, and each paint kind they name. A rejection
+* then means something this render needs failed to load. `families` and
+* `paintKinds` replace either derived list.
+*
+* With neither `render` nor `commands`, an omitted list loads everything
+* registered: every font family and every kind that has a loader — which
+* fails when any one of them does, and fetches what nothing draws.
+*/
+function warmRender(opts = {}) {
+	let { families, paintKinds } = opts;
+	if (opts.render || opts.commands) {
+		let planned;
 		try {
-			i = e.render ? l(e.render).commands : [];
-		} catch (e) {
-			return Promise.reject(e);
+			planned = opts.render ? planPixelRender(opts.render).commands : [];
+		} catch (err) {
+			return Promise.reject(err);
 		}
-		let o = n([...i, ...e.commands ?? []]);
-		t ??= o.fonts, r ??= o.paintKinds.filter(a);
+		const needs = renderNeeds([...planned, ...opts.commands ?? []]);
+		families ??= needs.fonts;
+		paintKinds ??= needs.paintKinds.filter(isPaintKindKnown);
 	}
-	return Promise.all([c(t), o(r)]).then(() => void 0);
+	return Promise.all([warmFonts(families), warmPaintKinds(paintKinds)]).then(() => void 0);
 }
-function m(e) {
-	let { gl: t, createCanvas: n, ...r } = e, i = d({
-		gl: t,
-		createCanvas: n
+/**
+* Render part of a scene to raw pixels, with no canvas mounted and no React
+* involved — for export, thumbnails, print, and pixel-diff tests.
+*
+* Output size follows from the source rect and the requested scale, so
+* rendering the same region at a higher scale is a real resolution increase
+* rather than an upscale: curves are re-flattened and glyphs re-rasterized for
+* the output resolution.
+*
+* Synchronous, so nothing lands mid-render: a paint kind loaded on demand
+* (`mesh-gradient`, or one declared with `registerPaintKindLoader`) that has
+* not loaded yet draws nothing, and neither does text set in a font atlas
+* still fetching — one registered `{ lazy: true }` is not fetched until text
+* first asks for it. `await warmRender({ render: args })` first.
+*
+* Each call opens a {@link RasterSession} and disposes it before returning.
+* Rendering many scenes, open one with `createRasterSession` instead.
+*/
+function renderSceneToPixels(args) {
+	const { gl, createCanvas, ...renderArgs } = args;
+	const session = createRasterSession({
+		gl,
+		createCanvas
 	});
 	try {
-		return i.render(r);
+		return session.render(renderArgs);
 	} finally {
-		i.dispose();
+		session.dispose();
 	}
 }
-//#endregion
-export { d as createRasterSession, l as planPixelRender, m as renderSceneToPixels, p as warmRender };
 
+//#endregion
+export { createRasterSession, planPixelRender, renderSceneToPixels, warmRender };
 //# sourceMappingURL=renderSceneToPixels.js.map

package/dist/canvas/renderSceneToPixels.js.map

@@ -1 +1 @@
-{"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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"}
+{"version":3,"file":"renderSceneToPixels.js","names":["viewToMat3"],"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. Measured\n   *  along each path's most stretched 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 = { px: args.flattenTolerancePx ?? 0.25 };\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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"}