@weasel-js/core 1.6.1 → 1.7.1

package/dist/canvas/renderNeeds.js

@@ -0,0 +1,25 @@
+//#region src/canvas/renderNeeds.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), r = (e) => {
+		e && n.add(e.fill ?? "solid");
+	}, i = (e) => {
+		for (let n of e) if (n.kind === "group") i(n.children);
+		else if (n.kind === "path") r(n.fill), r(n.stroke?.paint);
+		else if (n.kind === "text") for (let e of n.runs) {
+			let n = `${e.fontFamily}|${e.fontWeight}|${e.fontStyle}`;
+			t.has(n) || t.set(n, {
+				family: e.fontFamily,
+				weight: e.fontWeight,
+				style: e.fontStyle
+			}), r(e.fill), r(e.stroke?.paint);
+		}
+	};
+	return i(e), {
+		fonts: [...t.values()],
+		paintKinds: [...n]
+	};
+}
+//#endregion
+export { e as renderNeeds };
+
+//# sourceMappingURL=renderNeeds.js.map

package/dist/canvas/renderNeeds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderNeeds.js","names":["renderNeeds","fonts","kinds","paint","p","walk","c","list","r","key","commands"],"sources":["../../src/canvas/renderNeeds.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport type { FontRequest } from '@weasel-js/font';\nimport type { DrawCommand } from '../renderer/DrawCommand';\n\n/** What drawing a command list loads on demand: the faces its text is set in\n *  and the paint kinds its fills and strokes name. */\nexport interface RenderNeeds {\n  /** Each `(family, weight, style)` a text run is set in, once, in the order\n   *  met. */\n  fonts: FontRequest[];\n  /** Each paint kind a fill or stroke names, once, in the order met —\n   *  registered ones included. */\n  paintKinds: string[];\n}\n\n/**\n * The fonts and paint kinds `commands` draw with, read off the commands\n * themselves: text runs, path fills and strokes, run fills and strokes, and\n * everything under a group. What `warmRender({ render })` loads, and nothing\n * more. Images, sprites and shaders load nothing on demand, so they add\n * nothing.\n */\nexport function renderNeeds(commands: readonly DrawCommand[]): RenderNeeds {\n  const fonts = new Map<string, FontRequest>();\n  const kinds = new Set<string>();\n  const paint = (p: FillStyle | null | undefined) => {\n    if (p) kinds.add(p.fill ?? 'solid');\n  };\n  const walk = (list: readonly DrawCommand[]) => {\n    for (const c of list) {\n      if (c.kind === 'group') walk(c.children);\n      else if (c.kind === 'path') {\n        paint(c.fill);\n        paint(c.stroke?.paint);\n      } else if (c.kind === 'text') {\n        for (const r of c.runs) {\n          const key = `${r.fontFamily}|${r.fontWeight}|${r.fontStyle}`;\n          if (!fonts.has(key)) fonts.set(key, { family: r.fontFamily, weight: r.fontWeight, style: r.fontStyle });\n          paint(r.fill);\n          paint(r.stroke?.paint);\n        }\n      }\n    }\n  };\n  walk(commands);\n  return { fonts: [...fonts.values()], paintKinds: [...kinds] };\n}\n"],"mappings":";AAsBA,SAAgBA,EAAY,GAA+C;CACzE,IAAMC,oBAAQ,IAAI,IAAyB,GACrCC,oBAAQ,IAAI,IAAY,GACxBC,KAAS,MAAoC;EACjD,AAAIC,KAAGF,EAAM,IAAIE,EAAE,QAAQ,OAAO;CACpC,GACMC,KAAQ,MAAiC;EAC7C,KAAK,IAAMC,KAAKC,GACd,IAAID,EAAE,SAAS,SAAS,EAAKA,EAAE,QAAQ;OAClC,IAAIA,EAAE,SAAS,QAElB,AADAH,EAAMG,EAAE,IAAI,GACZH,EAAMG,EAAE,QAAQ,KAAK;OAChB,IAAIA,EAAE,SAAS,QACpB,KAAK,IAAME,KAAKF,EAAE,MAAM;GACtB,IAAMG,IAAM,GAAGD,EAAE,WAAW,GAAGA,EAAE,WAAW,GAAGA,EAAE;GAGjD,AAFKP,EAAM,IAAIQ,CAAG,KAAGR,EAAM,IAAIQ,GAAK;IAAE,QAAQD,EAAE;IAAY,QAAQA,EAAE;IAAY,OAAOA,EAAE;GAAU,CAAC,GACtGL,EAAMK,EAAE,IAAI,GACZL,EAAMK,EAAE,QAAQ,KAAK;EACvB;CAGN;CAEA,OADAH,EAAKK,CAAQ,GACN;EAAE,OAAO,CAAC,GAAGT,EAAM,OAAO,CAAC;EAAG,YAAY,CAAC,GAAGC,CAAK;CAAE;AAC9D"}

package/dist/canvas/renderSceneToPixels.js

@@ -0,0 +1,143 @@
+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";
+//#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,
+		scale: {
+			x: n.x,
+			y: n.y
+		}
+	}, c = e.resolveImage, l = e.drawOne ?? ((e, t, n, r) => i(e, t, n, {
+		...r,
+		resolveImage: c
+	})), u = [];
+	return e.background !== void 0 && u.push({
+		kind: "path",
+		path: {
+			kind: "rect",
+			x: 0,
+			y: 0,
+			width: r,
+			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,
+		height: o,
+		view: s,
+		commands: u
+	};
+}
+function l(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;
+	}
+	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 = {}) {
+	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", {
+			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");
+		return i;
+	}
+	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);
+			if (a ? (a.resize({
+				width: i,
+				height: l,
+				dpr: 1
+			}), a.setFlattenTolerance(m)) : a = new n({
+				gl: f,
+				width: i,
+				height: l,
+				dpr: 1,
+				imageMinification: "mipmap",
+				flattenTolerance: m,
+				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
+			};
+		},
+		dispose() {
+			o || (o = !0, a?.dispose(), a = null, t = null, i = void 0);
+		}
+	};
+}
+function p(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;
+		try {
+			t = n.render ? c(n.render).commands : [];
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		let a = o([...t, ...n.commands ?? []]);
+		r ??= a.fonts, i ??= a.paintKinds.filter(e);
+	}
+	return Promise.all([s(r), t(i)]).then(() => void 0);
+}
+function h(e) {
+	let { gl: t, createCanvas: n, ...r } = e, i = f({
+		gl: t,
+		createCanvas: n
+	});
+	try {
+		return i.render(r);
+	} finally {
+		i.dispose();
+	}
+}
+//#endregion
+export { f as createRasterSession, c as planPixelRender, h as renderSceneToPixels, m as warmRender };
+
+//# sourceMappingURL=renderSceneToPixels.js.map

package/dist/canvas/renderSceneToPixels.js.map

@@ -0,0 +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","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    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      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

@@ -0,0 +1,270 @@
+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 { asNodeId as i } from "../core/scene/types.js";
+import { poseDescriptorForNode as a, translatePoseViaDescriptor as o, visualBoundsViaDescriptor as s } from "../core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as c } from "../interactions/actions/resize/autoPoseDescriptor.js";
+import { fnFieldsOfNode as l } from "../core/scene/nodeFnFields.js";
+import { applyOpsTo as u } from "../core/applyOps.js";
+import { hitTestArea as d, hitTestLassoPolygon as f, regionPickOptions as p } from "./deps/hitTestArea.js";
+import { useMemo as m } from "react";
+//#region src/canvas/sceneAdapter.ts
+var h = 0;
+function g() {
+	return `n${(h++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+var _ = 0;
+function v() {
+	return `paste-${(_++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function y(e) {
+	return Array.isArray(e) ? [...e] : typeof e == "object" && e ? { ...e } : e;
+}
+function b(m, h = {}) {
+	let _ = () => {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of m.layers) t.visible && e.add(t.id);
+		return e;
+	}, b = h.selection, x = b?.getSelection ?? b?.get ?? (() => []), S = b?.setSelection ?? b?.set ?? (() => {}), C = h.poseDescriptor ?? c, w = (e) => s(e, C), T = (e, t, n, r) => o(e, t, n, r === void 0 ? C : a(C, r)), E = h.poseComposition, D = E !== void 0 && E.closure !== "identity", O = E ? { poseComposition: E } : {}, k = (e) => e ? {
+		...O,
+		...p(e, void 0, void 0)
+	} : O;
+	if (D && h.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 = {
+		getNode(e) {
+			return m.get(i(e));
+		},
+		getNodes() {
+			let e = _(), t = [];
+			for (let n of m.renderOrderNodes()) e.has(n.layer) && t.push(n);
+			return t;
+		},
+		getPose(e) {
+			let t = i(e), n = m.get(t);
+			if (!n) throw Error(`sceneToAdapter: unknown node "${e}"`);
+			return r(m, n);
+		},
+		getParent(e) {
+			return m.get(i(e))?.parent ?? null;
+		},
+		definesFrame(e) {
+			let t = m.get(i(e));
+			return t === void 0 || n(t);
+		},
+		getWorldPose(t) {
+			return D ? e(A, t, E.compose) : A.getPose(t);
+		},
+		...D ? { composePose: E.compose } : {},
+		setPose(e, t) {
+			if (h.cascadeContainerPose) {
+				let n = m.get(i(e));
+				if (n && n.kind === "container") {
+					let r = a(C, n), o = r.getBounds(n.pose), s = r.getBounds(t), c = s.x - o.x, l = s.y - o.y;
+					if (c !== 0 || l !== 0) {
+						let n = [], r = (e) => {
+							for (let t of m.childrenOf(i(e))) n.push(t), r(t);
+						};
+						r(e), m.batch("move container", () => {
+							m.setPose(i(e), t);
+							for (let e of n) {
+								let t = m.get(i(e));
+								t && m.setPose(i(e), T(t.pose, c, l, t));
+							}
+						});
+						return;
+					}
+				}
+			}
+			m.setPose(i(e), t);
+		},
+		setParent(e, t) {
+			m.move(i(e), t === null ? null : i(t));
+		},
+		getChildren(e) {
+			return e === null ? [...m.roots] : [...m.childrenOf(i(e))];
+		},
+		setChildOrder(e, t) {
+			m.batch("Reorder", () => {
+				for (let n = 0; n < t.length; n++) (e === null ? m.roots : m.childrenOf(i(e)))[n] !== t[n] && m.reorder(i(t[n]), n);
+			});
+		},
+		getLayers() {
+			return m.layers.map((e) => ({
+				id: e.id,
+				visible: e.visible,
+				parallax: e.parallax
+			}));
+		},
+		getLayout(e) {
+			let t = m.layoutOf(i(e));
+			return t !== null || !h.layouts ? t : typeof h.layouts == "function" ? h.layouts(e) : h.layouts[e] ?? null;
+		},
+		applyOps(e, t) {
+			t === void 0 ? u(this, e) : m.applyBatch(e, t, this);
+		},
+		insertNode(e, t) {
+			m.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 },
+				...l(e)
+			});
+		},
+		removeNode(e) {
+			m.remove(i(e));
+		},
+		setData(e, t) {
+			m.update(i(e), { data: t });
+		},
+		setLayout(e, t) {
+			m.setLayout(i(e), t);
+		},
+		getRemovalClosure(e) {
+			return [...m.removalClosure(e.map(i))];
+		},
+		getSelection: x,
+		setSelection: S,
+		hitTestArea(e, t) {
+			return d(m, e, k(t), C, { includeContainers: !0 });
+		},
+		hitTestLasso(e, t, n) {
+			return f(m, e, t, k(n), C, { includeContainers: !0 });
+		},
+		...h.commitInsert ? { commitInsert: (e) => {
+			let t = h.commitInsert(e);
+			if (!t) return null;
+			let n = h.insertLayer ?? "default";
+			return {
+				kind: "leaf",
+				id: i(t.id ?? g()),
+				layer: n,
+				pose: t.pose,
+				data: t.data,
+				parent: null
+			};
+		} } : {},
+		snapshotSelection(e) {
+			let n = new Set(e), r = /* @__PURE__ */ new Set(), a = [], o = (e, n) => {
+				if (!D) return e.pose;
+				if (n) return A.getWorldPose(e.id);
+				let i = t(A, e.parent);
+				return i !== null && r.has(i) ? e.pose : A.getWorldPose(e.id);
+			}, s = (e) => e.dependsOn === "children" && e.derivePose ? {
+				dependsOn: e.dependsOn,
+				derivePose: e.derivePose
+			} : {}, c = (e, t = !1) => {
+				if (r.has(e)) return;
+				let n = m.get(i(e));
+				if (n) {
+					if (r.add(e), n.kind === "container") {
+						a.push({
+							kind: "container",
+							id: n.id,
+							layer: n.layer,
+							parent: n.parent,
+							pose: y(o(n, t)),
+							data: y(n.data),
+							children: [...n.children],
+							...n.clipFromPose ? { clipFromPose: n.clipFromPose } : {},
+							...s(n)
+						});
+						for (let t of m.childrenOf(i(e))) c(t);
+					} else a.push({
+						kind: "leaf",
+						id: n.id,
+						layer: n.layer,
+						parent: n.parent,
+						pose: y(o(n, t)),
+						data: y(n.data)
+					});
+				}
+			};
+			for (let t of e) m.ancestorsOf(i(t)).some((e) => n.has(e)) || c(t, !0);
+			return { items: a };
+		},
+		commitPaste(e, t, r) {
+			let a = e.items;
+			if (a.length === 0) return [];
+			let o = /* @__PURE__ */ new Map();
+			for (let e of a) o.set(e.id, i(v()));
+			let s = (e) => e.parent === null || !o.has(e.parent), c = new Map(a.map((e) => [e.id, e])), l = (e) => {
+				if (!D) return !1;
+				let t = e.parent === null ? void 0 : c.get(e.parent);
+				for (; t !== void 0;) {
+					if (n(t)) return !0;
+					t = t.parent === null ? void 0 : c.get(t.parent);
+				}
+				return !1;
+			}, u = t.dx, d = t.dy;
+			if (r?.dropPoint) {
+				let e = Infinity, t = Infinity;
+				for (let n of a) {
+					if (!s(n)) continue;
+					let r = w(n.pose);
+					r.x < e && (e = r.x), r.y < t && (t = r.y);
+				}
+				Number.isFinite(e) && Number.isFinite(t) && (u = r.dropPoint.worldX - e, d = r.dropPoint.worldY - t);
+			}
+			let f = [];
+			for (let e of a) {
+				let t = {
+					id: o.get(e.id),
+					layer: e.layer,
+					parent: s(e) ? null : o.get(e.parent),
+					pose: l(e) ? y(e.pose) : T(y(e.pose), u, d),
+					data: y(e.data)
+				};
+				e.kind === "container" ? f.push({
+					...t,
+					kind: "container",
+					children: e.children.filter((e) => o.has(e)).map((e) => o.get(e)),
+					...e.clipFromPose ? { clipFromPose: e.clipFromPose } : {},
+					...e.dependsOn === "children" && e.derivePose ? {
+						dependsOn: e.dependsOn,
+						derivePose: e.derivePose
+					} : {}
+				}) : f.push({
+					...t,
+					kind: "leaf"
+				});
+			}
+			return f;
+		},
+		getPasteOffset() {
+			return {
+				dx: 12,
+				dy: 12
+			};
+		}
+	};
+	return A;
+}
+function x(e, t = {}) {
+	let { selection: n, commitInsert: r, insertLayer: i, layouts: a, poseDescriptor: o, cascadeContainerPose: s, poseComposition: c } = t;
+	return m(() => b(e, {
+		selection: n,
+		commitInsert: r,
+		insertLayer: i,
+		layouts: a,
+		poseDescriptor: o,
+		cascadeContainerPose: s,
+		poseComposition: c
+	}), [
+		e,
+		n,
+		r,
+		i,
+		a,
+		o,
+		s,
+		c
+	]);
+}
+//#endregion
+export { b as sceneToAdapter, x as useSceneAdapter };
+
+//# sourceMappingURL=sceneAdapter.js.map

package/dist/canvas/sceneAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneAdapter.js","names":["adapterFallbackIdCounter","adapterFallbackId","pasteIdCounter","pasteNodeId","copyField","value","sceneToAdapter","visibleLayers","out","layer","scene","sel","options","getSelection","setSelection","d","AUTO_POSE_DESCRIPTOR","poseBounds","visualBoundsViaDescriptor","p","translate","translatePoseViaDescriptor","dx","dy","node","poseDescriptorForNode","composition","composes","pickOpts","pickOptsFor","view","regionPickOptions","adapter","asNodeId","id","visible","nid","effectivePose","n","definesFrame","composeWorldPose","g","before","after","pose","descIds","collect","cid","rootId","cn","parentId","i","ids","l","declared","label","applyOpsTo","ops","index","fnFieldsOfNode","layout","hitTestArea","rect","hitTestLassoPolygon","polygon","mode","created","bounds","idSet","taken","items","poseFor","isRoot","frame","frameAtOrAbove","derivation","capture","a","src","clipboard","idMap","item","byId","ridesPastedFrame","offset","ctx","minX","minY","b","base","c","useSceneAdapter","useMemo","selection","commitInsert","insertLayer","layouts","poseDescriptor","cascadeContainerPose","poseComposition"],"sources":["../../src/canvas/sceneAdapter.ts"],"sourcesContent":["/**\n * Synthesize a `<Canvas>`-compatible adapter from a `Scene` primitive.\n *\n * The Scene owns nodes/poses/parenting and auto-records ops on every mutation.\n * `<SceneCanvas>` calls `sceneToAdapter(scene)` and forwards the result to\n * `<Canvas>`'s `adapter` prop. Selection and hit-testing are not part of the\n * Scene model — Canvas's internal `useSelection` and pose-derived pickEvery\n * cover those.\n *\n * Pose semantics match the rest of the kit: `getPose` / `setPose` return /\n * write **local** coordinates (relative to parent). The Scene stores pose on\n * each node directly; world composition (when needed) is the renderer's job\n * via `composeWorldPose`, not the adapter's.\n */\nimport { useMemo } from 'react';\nimport type {\n  AreaSelectAdapter,\n  ClipboardSnapshot,\n  InsertAdapter,\n  LassoHitMode,\n  LassoSelectAdapter,\n  RegionPickView,\n  LayerEnumerableAdapter,\n  MoveAdapter,\n  ResizeAdapter,\n  RotateAdapter,\n} from 'core/adapters/types';\nimport type { LayoutStrategy } from '../layout/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport { fnFieldsOfNode } from 'core/scene/nodeFnFields';\nimport { asNodeId } from 'core/scene/types';\nimport { applyOpsTo } from 'core/applyOps';\nimport { hitTestArea, hitTestLassoPolygon, regionPickOptions } from 'canvas/deps/hitTestArea';\nimport type { ScenePickSourceOptions } from 'canvas/pickWalk';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { composeWorldPose, frameAtOrAbove, type PoseComposition } from 'features/groups/composePose';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\n\n/** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /\n *  `setSelection`. Matches `useSelection().adapterMethods` plus an imperative\n *  read; pass `useSelection()` itself or `selection.adapterMethods`. */\nexport interface SceneAdapterSelection {\n  get?(): string[];\n  set?(ids: string[]): void;\n  getSelection?(): string[];\n  setSelection?(ids: string[]): void;\n}\n\n/** Sibling z-order surface used by reorder ops. Inlined here (rather than\n *  pulled from `core/ops/reorder` to avoid import cycles); the `null` parent\n *  channel addresses the root sibling list. */\n/** @internal */\ninterface ReorderAdapter {\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** Everything the interaction layer can ask of a scene, as one type: the\n *  move, resize, rotate, selection, layer and reorder contracts combined.\n *  `<SceneCanvas>` synthesizes one of these, which is why most consumers never\n *  touch an adapter directly. */\nexport type SceneCanvasAdapter<TData, TLayer extends string, TPose> =\n  & MoveAdapter<Node<TData, TLayer, TPose>, TPose>\n  & ResizeAdapter<Node<TData, TLayer, TPose>, TPose>\n  & RotateAdapter<Node<TData, TLayer, TPose>, TPose>\n  & AreaSelectAdapter\n  & LassoSelectAdapter\n  & LayerEnumerableAdapter<TLayer>\n  & ReorderAdapter\n  & Partial<InsertAdapter<Node<TData, TLayer, TPose>>>\n  // Tighten the parts that are optional on the underlying adapter contracts\n  // but unconditionally provided by a scene-backed adapter. Anything that\n  // routes scene mutations through this adapter (kit InsertOps, hierarchical\n  // hooks like useNest, etc.) can rely on these being present.\n  & {\n      getParent(id: string): string | null;\n      /** The node's pose with every ancestor's frame folded in. Equal to\n       *  `getPose` unless a `poseComposition` is configured. */\n      getWorldPose(id: string): TPose;\n      /** Whether `id`'s pose is a frame its children are expressed in — see\n       *  `definesFrame`. */\n      definesFrame(id: string): boolean;\n      /** Present only when a composing strategy is configured; the render\n       *  walk feature-detects it. */\n      composePose?(parent: TPose, child: TPose): TPose;\n      getSelection(): string[];\n      setSelection(ids: string[]): void;\n      insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;\n      removeNode(id: string): void;\n      /** Replace a node's `data` — what a `setData` op writes through. */\n      setData(id: string, data: TData): void;\n      /** Swap a container's layout — what a `setLayout` op writes through. */\n      setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;\n      getRemovalClosure(ids: readonly string[]): string[];\n      applyOps(ops: Op[], label?: string): void;\n      snapshotSelection(ids: string[]): ClipboardSnapshot;\n      commitPaste(\n        clipboard: ClipboardSnapshot,\n        offset: { dx: number; dy: number },\n        ctx?: { dropPoint?: { worldX: number; worldY: number } },\n      ): Node<TData, TLayer, TPose>[];\n      getPasteOffset(clipboard: ClipboardSnapshot): { dx: number; dy: number };\n    };\n\n/** Optional extras for the synthesized adapter. Pass `commitInsert` to wire\n *  the insert gesture into a Scene-owned canvas; the returned object becomes\n *  a leaf on the layer named by `layer` (default `'default'`). */\nexport interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {\n  /** Factory for new objects. Returning `null` aborts the insert. */\n  commitInsert?: (bounds: Bounds) => {\n    pose: TPose;\n    data: TData;\n    id?: string;\n  } | null;\n  /** Layer to place inserted nodes on. Defaults to the trivial-form layer. */\n  insertLayer?: TLayer;\n  /** Selection source for `AreaSelectAdapter.getSelection` / `setSelection`.\n   *  Pass the result of `useSelection()` (or its `adapterMethods`). When\n   *  omitted, `getSelection` returns `[]` and `setSelection` is a noop —\n   *  fine for read-only or selection-less canvases, but the marquee gesture\n   *  won't update any external selection state. */\n  selection?: SceneAdapterSelection;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Layout strategies keyed by container node id, for containers whose\n   *  scene node declares none (`ContainerNode.layout` wins). `move` runs its\n   *  layout-aware pass on them; for inserts, deletes and resizes to reach\n   *  them too, install them with `useLayoutArrivals`. Pass either a static\n   *  map, or a `getLayout(id)` function for dynamic resolution. */\n  layouts?:\n    | Record<string, LayoutStrategy<TPose>>\n    | ((containerId: string) => LayoutStrategy<TPose> | null);\n  /** When true, `setPose` on a container translates every descendant by the\n   *  same delta, through the pose descriptor. Scene v1 stores absolute poses,\n   *  so without it children stay behind. */\n  cascadeContainerPose?: boolean;\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model, where a parent contributes no transform. Supplying a\n   *  composing strategy makes a container's pose a **frame**: rotating the\n   *  container rotates its contents, and `setPose` on it must not also\n   *  translate them, so it cannot be combined with `cascadeContainerPose`. */\n  poseComposition?: PoseComposition<TPose>;\n}\n\n// Fallback id generator for `commitInsert` when the consumer factory omits\n// `created.id`. Mirrors `scene.ts`'s `defaultGenerateId` shape; module-scoped\n// counter keeps ids unique across adapters in a session.\nlet adapterFallbackIdCounter = 0;\nfunction adapterFallbackId(): string {\n  return `n${(adapterFallbackIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;\n}\n\n// Fresh ids for pasted nodes. The scene's own `generateId` isn't reachable\n// from the adapter, so `commitPaste` mints ids in the same shape as\n// `defaultGenerateId` with a `paste-` prefix (module-scoped counter + random\n// suffix keeps them unique across adapters and repeated pastes). Accepted\n// risk: the counter is per-tab, so cross-tab paste (the OS-clipboard path)\n// leans on the random suffix alone for uniqueness — a collision makes\n// `scene.add` throw rather than silently overwrite.\nlet pasteIdCounter = 0;\nfunction pasteNodeId(): string {\n  return `paste-${(pasteIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;\n}\n\n// Copy one node field (pose / data / children) so clipboard snapshots don't\n// alias live scene state. Spread-level copy per the clipboard contract:\n// mutating a snapshot's pose/data/children must not touch the scene.\nfunction copyField<T>(value: T): T {\n  if (Array.isArray(value)) return [...value] as T;\n  if (value !== null && typeof value === 'object') return { ...(value as object) } as T;\n  return value;\n}\n\n/** Derive the adapter for a scene. Reads go straight to the scene; writes are\n *  ops applied through its history, so anything done through the adapter is\n *  undoable. */\nexport function sceneToAdapter<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  options: SceneToAdapterOptions<TData, TLayer, TPose> = {},\n): SceneCanvasAdapter<TData, TLayer, TPose> {\n  const visibleLayers = (): Set<TLayer> => {\n    const out = new Set<TLayer>();\n    for (const layer of scene.layers) {\n      if (layer.visible) out.add(layer.id);\n    }\n    return out;\n  };\n\n  const sel = options.selection;\n  const getSelection = sel?.getSelection ?? sel?.get ?? (() => [] as string[]);\n  const setSelection = sel?.setSelection ?? sel?.set ?? (() => {});\n  const d = (options.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const poseBounds = (p: TPose): Bounds => visualBoundsViaDescriptor(p, d);\n  const translate = (p: TPose, dx: number, dy: number, node?: unknown): TPose =>\n    translatePoseViaDescriptor(\n      p, dx, dy, node === undefined ? d : poseDescriptorForNode(d, node),\n    );\n\n  const composition = options.poseComposition;\n  const composes = composition !== undefined && composition.closure !== 'identity';\n  const pickOpts: ScenePickSourceOptions<unknown> = composition\n    ? { poseComposition: composition as PoseComposition<unknown> }\n    : {};\n  // The asking view's layer gate and camera, over the adapter's own options.\n  const pickOptsFor = (view: RegionPickView | undefined): ScenePickSourceOptions<unknown> =>\n    (view ? { ...pickOpts, ...regionPickOptions(view, undefined, undefined) } : pickOpts);\n  if (composes && options.cascadeContainerPose) {\n    throw new Error(\n      'sceneToAdapter: poseComposition and cascadeContainerPose contradict each other. ' +\n      'Under a composing strategy a child\\'s pose is already relative to its parent, so ' +\n      'the cascade would move every descendant twice. Drop cascadeContainerPose.',\n    );\n  }\n\n  const adapter: SceneCanvasAdapter<TData, TLayer, TPose> = {\n    getNode(id) {\n      return scene.get(asNodeId(id));\n    },\n    getNodes() {\n      const visible = visibleLayers();\n      const out: Node<TData, TLayer, TPose>[] = [];\n      for (const n of scene.renderOrderNodes()) {\n        if (visible.has(n.layer)) out.push(n);\n      }\n      return out;\n    },\n    getPose(id) {\n      const nid = asNodeId(id);\n      const n = scene.get(nid);\n      if (!n) throw new Error(`sceneToAdapter: unknown node \"${id}\"`);\n      return effectivePose(scene, n);\n    },\n    getParent(id) {\n      const n = scene.get(asNodeId(id));\n      return n?.parent ?? null;\n    },\n    definesFrame(id) {\n      const n = scene.get(asNodeId(id));\n      return n === undefined || definesFrame(n);\n    },\n    getWorldPose(id) {\n      if (!composes) return adapter.getPose(id);\n      return composeWorldPose(adapter, id, composition!.compose);\n    },\n    // Only present when it would do something: the render walk skips the fold\n    // entirely when this is absent, which is the absolute-pose path.\n    ...(composes ? { composePose: composition!.compose } : {}),\n    setPose(id, pose) {\n      // Container cascade (opt-in): under scene v1's absolute-pose semantics,\n      // moving a container needs to translate every descendant by the same\n      // delta so children visually stay attached. The whole cascade lands as\n      // one scene.batch so undo collapses to a single step.\n      if (options.cascadeContainerPose) {\n        const node = scene.get(asNodeId(id));\n        if (node && node.kind === 'container') {\n          const g = poseDescriptorForNode(d, node);\n          const before = g.getBounds(node.pose);\n          const after = g.getBounds(pose);\n          const dx = after.x - before.x;\n          const dy = after.y - before.y;\n          if (dx !== 0 || dy !== 0) {\n            const descIds: string[] = [];\n            const collect = (rootId: string): void => {\n              for (const cid of scene.childrenOf(asNodeId(rootId))) {\n                descIds.push(cid);\n                collect(cid);\n              }\n            };\n            collect(id);\n            scene.batch('move container', () => {\n              scene.setPose(asNodeId(id), pose);\n              for (const cid of descIds) {\n                const cn = scene.get(asNodeId(cid));\n                if (!cn) continue;\n                scene.setPose(asNodeId(cid), translate(cn.pose, dx, dy, cn));\n              }\n            });\n            return;\n          }\n        }\n      }\n      scene.setPose(asNodeId(id), pose);\n    },\n    setParent(id, parentId) {\n      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId));\n    },\n    getChildren(id) {\n      // Reorder ops call this with parentId === null to mean \"root siblings.\"\n      // The kit's existing callers always pass a string, so this widening is\n      // additive — falls through to scene.childrenOf for the typed path and\n      // returns scene.roots for the null path.\n      if (id === null) return [...scene.roots];\n      return [...scene.childrenOf(asNodeId(id))];\n    },\n    setChildOrder(parentId, ids) {\n      // Batched reorder: each scene.reorder call is its own kit:move log\n      // entry, but scene.batch wraps them into one undo unit + one notify.\n      scene.batch('Reorder', () => {\n        for (let i = 0; i < ids.length; i++) {\n          // Skip ids that are already in the target slot to avoid useless\n          // log entries.\n          const current = parentId === null\n            ? scene.roots\n            : scene.childrenOf(asNodeId(parentId));\n          if (current[i] === ids[i]) continue;\n          scene.reorder(asNodeId(ids[i]), i);\n        }\n      });\n    },\n    getLayers() {\n      return scene.layers.map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax }));\n    },\n    getLayout(id) {\n      const declared = scene.layoutOf(asNodeId(id));\n      if (declared !== null || !options.layouts) return declared;\n      return typeof options.layouts === 'function'\n        ? options.layouts(id)\n        : options.layouts[id] ?? null;\n    },\n    // Unified applyOps: when a label is supplied the ops are wrapped in a\n    // batch checkpoint (history-aware path used by Move/Resize/Rotate/Insert/\n    // Delete tools). When a journal is active (via scene's getActiveJournal\n    // option), scene.applyBatch routes to the journal instead of recording a\n    // new parent-history entry. Without a label the ops are applied transiently\n    // via applyOpsTo (AreaSelectAdapter contract — no checkpoint).\n    applyOps(ops: Op[], label?: string) {\n      if (label !== undefined) {\n        scene.applyBatch(ops, label, this);\n      } else {\n        applyOpsTo(this, ops);\n      }\n    },\n    // Node-mutation surface used by kit InsertOps / DeleteOps (e.g.\n    // useNest wrapping the selection in a new container node, or its\n    // inverse). Re-adds via the full structural spec so the round-trip\n    // survives undo/redo; removes by id.\n    insertNode(node: Node<TData, TLayer, TPose>, index?: number) {\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(index !== undefined ? { index } : {}),\n        ...(node.parent !== null ? { parent: node.parent } : {}),\n        // Derivation travels with the node, or undo of a delete brings an\n        // edge back as a static path that never follows its endpoints again.\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...fnFieldsOfNode(node),\n      });\n    },\n    removeNode(id: string) {\n      scene.remove(asNodeId(id));\n    },\n    setData(id: string, data: TData) {\n      scene.update(asNodeId(id), { data });\n    },\n    setLayout(id: string, layout: LayoutStrategy<TPose> | string | null) {\n      scene.setLayout(asNodeId(id), layout);\n    },\n    getRemovalClosure(ids: readonly string[]): string[] {\n      return [...scene.removalClosure(ids.map(asNodeId))];\n    },\n    // AreaSelectAdapter surface — included unconditionally so plain\n    // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the\n    // marquee gesture. `applyOps` (above) dispatches transiently when called\n    // without a label, matching the AreaSelectAdapter contract.\n    getSelection,\n    setSelection,\n    // The live marquee's and lasso's own hit-tests. Containers come back:\n    // this adapter's consumer has nothing to fold children into them.\n    hitTestArea(rect: Bounds, view?: RegionPickView) {\n      return hitTestArea(\n        scene as unknown as Scene<unknown, string, unknown>,\n        rect,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    hitTestLasso(polygon, mode: LassoHitMode, view?: RegionPickView) {\n      return hitTestLassoPolygon(\n        scene as unknown as Scene<unknown, string, unknown>,\n        polygon,\n        mode,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    // commitInsert (gesture-time leaf insert) is opt-in: present only when\n    // `options.commitInsert` is. The full insertNode/removeNode mutators\n    // above are always present so kit-side InsertOp / DeleteOp round-trip\n    // through scene.add / scene.remove regardless.\n    //\n    // Contract: this is a pure factory — it constructs a Node spec but does\n    // NOT touch the scene. `useInsert`'s onEnd dispatches an `InsertOp`\n    // whose apply() calls `adapter.insertNode` → `scene.add`, which is the\n    // sole insertion path. Calling `scene.add` here too would double-insert,\n    // and the second add throws on id collision (silently dropping the\n    // gesture's pointer-up cleanup and breaking the next drag).\n    ...(options.commitInsert\n      ? {\n          commitInsert: (bounds: { x: number; y: number; width: number; height: number }) => {\n            const created = options.commitInsert!(bounds);\n            if (!created) return null;\n            const layer = (options.insertLayer ?? ('default' as TLayer));\n            const id = asNodeId(created.id ?? adapterFallbackId());\n            return {\n              kind: 'leaf',\n              id,\n              layer,\n              pose: created.pose,\n              data: created.data,\n              parent: null,\n            } as Node<TData, TLayer, TPose>;\n          },\n        }\n      : {}),\n    // Clipboard seam (`useClipboardOps` / the paste ingestion path).\n    //\n    // `snapshotSelection` captures adapter-shaped node copies; `commitPaste`\n    // is a pure factory like `commitInsert` above — it mints fresh nodes but\n    // NEVER touches the scene. Insertion happens via the hook's InsertOps\n    // (one per created node, parents before children), which is what makes a\n    // whole paste a single undo entry.\n    snapshotSelection(ids: string[]): ClipboardSnapshot {\n      const idSet = new Set(ids);\n      const taken = new Set<string>();\n      const items: Node<TData, TLayer, TPose>[] = [];\n      // DFS from one snapshot root: push the node, then its subtree —\n      // parents-before-children, so paste can re-insert in array order.\n      // A stored pose is relative to its frame, and a node whose frame is not\n      // copied with it lands somewhere else entirely on paste. Capture those in\n      // world coordinates: every root, and under an envelope root, the nodes\n      // sharing the frame the root left behind.\n      const poseFor = (n: Node<TData, TLayer, TPose>, isRoot: boolean): TPose => {\n        if (!composes) return n.pose;\n        if (isRoot) return adapter.getWorldPose(n.id);\n        const frame = frameAtOrAbove(adapter, n.parent);\n        return frame !== null && taken.has(frame) ? n.pose : adapter.getWorldPose(n.id);\n      };\n      // Only a derivation over `'children'` survives the copy: an id list\n      // would still name the originals.\n      const derivation = (n: Node<TData, TLayer, TPose>) =>\n        n.dependsOn === 'children' && n.derivePose\n          ? { dependsOn: n.dependsOn, derivePose: n.derivePose }\n          : {};\n\n      const capture = (id: string, isRoot = false): void => {\n        if (taken.has(id)) return;\n        const n = scene.get(asNodeId(id));\n        if (!n) return;\n        taken.add(id);\n        if (n.kind === 'container') {\n          items.push({\n            kind: 'container',\n            id: n.id,\n            layer: n.layer,\n            parent: n.parent,\n            pose: copyField(poseFor(n, isRoot)),\n            data: copyField(n.data),\n            children: [...n.children],\n            ...(n.clipFromPose ? { clipFromPose: n.clipFromPose } : {}),\n            ...derivation(n),\n          });\n          for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);\n        } else {\n          items.push({\n            kind: 'leaf',\n            id: n.id,\n            layer: n.layer,\n            parent: n.parent,\n            pose: copyField(poseFor(n, isRoot)),\n            data: copyField(n.data),\n          });\n        }\n      };\n      for (const id of ids) {\n        // Dedupe: an id whose ancestor is also selected is already covered\n        // by that ancestor's subtree walk.\n        if (scene.ancestorsOf(asNodeId(id)).some((a) => idSet.has(a))) continue;\n        capture(id, true);\n      }\n      return { items };\n    },\n    commitPaste(\n      clipboard: ClipboardSnapshot,\n      offset: { dx: number; dy: number },\n      ctx?: { dropPoint?: { worldX: number; worldY: number } },\n    ): Node<TData, TLayer, TPose>[] {\n      // Snapshot items are adapter-shaped node copies: what snapshotSelection\n      // captures, and what commitPaste itself returns (`useClipboardOps`\n      // feeds `created` back in as the next cascade source).\n      const src = clipboard.items as Node<TData, TLayer, TPose>[];\n      if (src.length === 0) return [];\n      const idMap = new Map<string, NodeId>();\n      for (const item of src) idMap.set(item.id, asNodeId(pasteNodeId()));\n      // Items whose captured parent isn't part of the snapshot become roots\n      // of the pasted cluster.\n      const isRoot = (item: Node<TData, TLayer, TPose>): boolean =>\n        item.parent === null || !idMap.has(item.parent);\n      // Under a composing strategy a node inside a pasted frame rides it, and\n      // offsetting it as well would move it twice.\n      const byId = new Map(src.map((item) => [item.id, item]));\n      const ridesPastedFrame = (item: Node<TData, TLayer, TPose>): boolean => {\n        if (!composes) return false;\n        let p = item.parent === null ? undefined : byId.get(item.parent);\n        while (p !== undefined) {\n          if (definesFrame(p)) return true;\n          p = p.parent === null ? undefined : byId.get(p.parent);\n        }\n        return false;\n      };\n      // Scene v1 poses are absolute (see the cascade notes above), so the\n      // delta applies to EVERY pasted node — the cluster translates rigidly,\n      // descendants staying attached to their parents.\n      let dx = offset.dx;\n      let dy = offset.dy;\n      if (ctx?.dropPoint) {\n        // Drop-point policy: land the cluster origin (min corner of the root\n        // items' bounds) on the drop point; `offset` is ignored.\n        let minX = Infinity;\n        let minY = Infinity;\n        for (const item of src) {\n          if (!isRoot(item)) continue;\n          const b = poseBounds(item.pose);\n          if (b.x < minX) minX = b.x;\n          if (b.y < minY) minY = b.y;\n        }\n        if (Number.isFinite(minX) && Number.isFinite(minY)) {\n          dx = ctx.dropPoint.worldX - minX;\n          dy = ctx.dropPoint.worldY - minY;\n        }\n      }\n      const out: Node<TData, TLayer, TPose>[] = [];\n      for (const item of src) {\n        const base = {\n          id: idMap.get(item.id)!,\n          layer: item.layer,\n          parent: isRoot(item) ? null : idMap.get(item.parent as string)!,\n          pose: ridesPastedFrame(item) ? copyField(item.pose) : translate(copyField(item.pose), dx, dy),\n          data: copyField(item.data),\n        };\n        if (item.kind === 'container') {\n          out.push({\n            ...base,\n            kind: 'container',\n            children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)!),\n            ...(item.clipFromPose ? { clipFromPose: item.clipFromPose } : {}),\n            ...(item.dependsOn === 'children' && item.derivePose\n              ? { dependsOn: item.dependsOn, derivePose: item.derivePose }\n              : {}),\n          });\n        } else {\n          out.push({ ...base, kind: 'leaf' });\n        }\n      }\n      // `src` is parents-before-children (snapshotSelection's DFS order),\n      // and this loop preserves it — children re-attach to freshly-inserted\n      // parents when the hook's InsertOps apply in order.\n      return out;\n    },\n    // Constant cascade: the hook re-snapshots the just-created items, so\n    // repeated pastes stack +12/+12 each time.\n    getPasteOffset(): { dx: number; dy: number } {\n      return { dx: 12, dy: 12 };\n    },\n  };\n\n  return adapter;\n}\n\n/**\n * React-hook wrapper around `sceneToAdapter`. Memoizes on every option, so\n * the adapter keeps its identity across renders unless one of them changes.\n */\nexport function useSceneAdapter<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  options: SceneToAdapterOptions<TData, TLayer, TPose> = {},\n): SceneCanvasAdapter<TData, TLayer, TPose> {\n  const {\n    selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition,\n  } = options;\n  return useMemo(\n    () => sceneToAdapter(scene, {\n      selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition,\n    }),\n    [scene, selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition],\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/sceneLayerPaint.js

@@ -0,0 +1,37 @@
+import { isLayerVisible as e } from "../core/layers/render.js";
+//#region src/canvas/sceneLayerPaint.ts
+function t(e) {
+	return `scene:${e}`;
+}
+function n(t, n) {
+	let r = n.layers ? n.layers(t) : t, i = n.layerOrder, a = i ? i.map((e) => r.find((t) => t.id === e)).filter((e) => e !== void 0) : r, o = n.layerVisibility ?? {};
+	return a.filter((t) => e(t, o));
+}
+function r() {
+	let e = null;
+	return (r, i) => {
+		let a = [
+			r,
+			i.layers,
+			i.layerVisibility,
+			i.layerOrder
+		];
+		if (e && e.inputs.every((e, t) => e === a[t])) return e.gate;
+		let o = new Map(r.map((e) => [e.id, e])), s = new Set(n(r, i)), c = (e) => {
+			let n = o.get(t(e)) ?? o.get("scene");
+			return n === void 0 || s.has(n);
+		};
+		return e = {
+			inputs: a,
+			gate: c
+		}, c;
+	};
+}
+function i(e, n) {
+	let { layerVisibility: r, layerOrder: i } = n;
+	return r === void 0 && i === void 0 ? e : (i ? i.map((n) => e.find((e) => t(e.id) === n)).filter((e) => e !== void 0) : e).filter((e) => r?.[t(e.id)] !== !1);
+}
+//#endregion
+export { r as createSceneLayerGate, n as paintedLayers, i as paintedSceneLayers, t as sceneLayerKey };
+
+//# sourceMappingURL=sceneLayerPaint.js.map

package/dist/canvas/sceneLayerPaint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneLayerPaint.js","names":["sceneLayerKey","layerId","paintedLayers","narrowed","view","surface","order","sequence","l","id","visibility","isLayerVisible","createSceneLayerGate","last","inputs","v","i","byId","drawn","gate","carrier","paintedSceneLayers","layerVisibility","layerOrder","layers","key"],"sources":["../../src/canvas/sceneLayerPaint.ts"],"sourcesContent":["/**\n * Which scene layers a view paints.\n *\n * A view's `layerVisibility` / `layerOrder` name render layers, and `<Canvas>`\n * paints a scene as one render layer per scene layer, keyed `scene:<layerId>`.\n * Picking, marquee and select-all ask about scene layers, so this is where one\n * namespace is read in terms of the other.\n */\nimport { isLayerVisible, type RenderLayer } from 'core/layers/render';\n\n/** The render-layer id a scene layer paints under. */\nexport function sceneLayerKey(layerId: string): string {\n  return `scene:${layerId}`;\n}\n\n/** Per-view layer settings, in `<Canvas>`'s vocabulary. */\nexport interface ViewLayerPaint {\n  /** Narrows the surface's stack before the other two apply. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  layerVisibility?: Record<string, boolean>;\n  layerOrder?: readonly string[];\n}\n\n/** The layers a view draws, in the order it draws them — the two gates\n *  `drawLayers` applies, over whatever `layers` narrowed to. */\nexport function paintedLayers(\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n): readonly RenderLayer<unknown>[] {\n  const narrowed = view.layers ? view.layers(surface) : surface;\n  const order = view.layerOrder;\n  const sequence = order\n    ? order\n      .map((id) => narrowed.find((l) => l.id === id))\n      .filter((l): l is RenderLayer<unknown> => l !== undefined)\n    : narrowed;\n  const visibility = view.layerVisibility ?? {};\n  return sequence.filter((l) => isLayerVisible(l, visibility));\n}\n\n/**\n * A gate answering \"does this scene layer reach the screen in this view\",\n * rebuilt only when the surface's stack or the view's settings change — it is\n * asked once per pick candidate.\n *\n * A scene layer is painted when the render layer carrying it is: its own\n * `scene:<id>`, or the bundled `scene` layer an adapter without layers gets.\n * A surface carrying neither paints the scene some other way, which is not\n * this gate's to judge, so it passes.\n */\nexport function createSceneLayerGate(): (\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n) => (layerId: string) => boolean {\n  let last: { inputs: readonly unknown[]; gate: (layerId: string) => boolean } | null = null;\n  return (surface, view) => {\n    const inputs = [surface, view.layers, view.layerVisibility, view.layerOrder];\n    if (last && last.inputs.every((v, i) => v === inputs[i])) return last.gate;\n    const byId = new Map(surface.map((l) => [l.id, l]));\n    const drawn = new Set(paintedLayers(surface, view));\n    const gate = (layerId: string): boolean => {\n      const carrier = byId.get(sceneLayerKey(layerId)) ?? byId.get('scene');\n      return carrier === undefined || drawn.has(carrier);\n    };\n    last = { inputs, gate };\n    return gate;\n  };\n}\n\n/** Scene layers in the order a view paints them, for a view that walks the\n *  scene itself rather than a render-layer stack. Keyed as `<SceneCanvas>`\n *  keys them, so one map serves both. */\nexport function paintedSceneLayers<T extends { id: string }>(\n  layers: readonly T[],\n  view: Pick<ViewLayerPaint, 'layerVisibility' | 'layerOrder'>,\n): readonly T[] {\n  const { layerVisibility, layerOrder } = view;\n  if (layerVisibility === undefined && layerOrder === undefined) return layers;\n  const sequence = layerOrder\n    ? layerOrder\n      .map((key) => layers.find((l) => sceneLayerKey(l.id) === key))\n      .filter((l): l is T => l !== undefined)\n    : layers;\n  return sequence.filter((l) => layerVisibility?.[sceneLayerKey(l.id)] !== false);\n}\n"],"mappings":";;AAWA,SAAgBA,EAAc,GAAyB;CACrD,OAAO,SAASC;AAClB;AAYA,SAAgBC,EACd,GACA,GACiC;CACjC,IAAMC,IAAWC,EAAK,SAASA,EAAK,OAAOC,CAAO,IAAIA,GAChDC,IAAQF,EAAK,YACbG,IAAWD,IACbA,EACC,KAAK,MAAOH,EAAS,MAAM,MAAMK,EAAE,OAAOC,CAAE,CAAC,CAAC,CAC9C,QAAQ,MAAiCD,MAAM,KAAA,CAAS,IACzDL,GACEO,IAAaN,EAAK,mBAAmB,CAAC;CAC5C,OAAOG,EAAS,QAAQ,MAAMI,EAAeH,GAAGE,CAAU,CAAC;AAC7D;AAYA,SAAgBE,IAGkB;CAChC,IAAIC,IAAkF;CACtF,QAAQ,GAAS,MAAS;EACxB,IAAMC,IAAS;GAACT;GAASD,EAAK;GAAQA,EAAK;GAAiBA,EAAK;EAAU;EAC3E,IAAIS,KAAQA,EAAK,OAAO,OAAO,GAAG,MAAME,MAAMD,EAAOE,EAAE,GAAG,OAAOH,EAAK;EACtE,IAAMI,IAAO,IAAI,IAAIZ,EAAQ,KAAK,MAAM,CAACG,EAAE,IAAIA,CAAC,CAAC,CAAC,GAC5CU,IAAQ,IAAI,IAAIhB,EAAcG,GAASD,CAAI,CAAC,GAC5Ce,KAAQ,MAA6B;GACzC,IAAMC,IAAUH,EAAK,IAAIjB,EAAcC,CAAO,CAAC,KAAKgB,EAAK,IAAI,OAAO;GACpE,OAAOG,MAAY,KAAA,KAAaF,EAAM,IAAIE,CAAO;EACnD;EAEA,OADA,IAAO;GAAE;GAAQ;EAAK,GACfD;CACT;AACF;AAKA,SAAgBE,EACd,GACA,GACc;CACd,IAAM,EAAE,oBAAiB,kBAAejB;CAOxC,OANIkB,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAkBC,KACrDD,IACbA,EACC,KAAK,MAAQC,EAAO,MAAM,MAAMxB,EAAcQ,EAAE,EAAE,MAAMiB,CAAG,CAAC,CAAC,CAC7D,QAAQ,MAAcjB,MAAM,KAAA,CAAS,IACtCgB,EAAA,CACY,QAAQ,MAAMF,IAAkBtB,EAAcQ,EAAE,EAAE,OAAO,EAAK;AAChF"}