@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/layerOrder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layerOrder.js","names":["STANDARD_SLOT_SET","STANDARD_SLOTS","composeOrderedLayers","afterByParent","beforeByParent","tail","allCustomKeys","key","value","layersMap","isCustomEntry","arr","emitted","out","background","emitChild","child","emitBefore","emitAfter","parentKey","slot","sceneLayers","sl","layer","standardLayers","t","ref","placeToolOverlays","before","overlays","after","at","selectionOverlay","ordered"],"sources":["../../src/canvas/layerOrder.ts"],"sourcesContent":["import type { RenderLayer } from '../core/layers/render';\nimport type { LayerSlotValue } from './Canvas';\nimport { STANDARD_SLOTS, isCustomEntry } from './layerSlots';\nimport type { OverlayPosition } from '@weasel-js/routing';\n\nconst STANDARD_SLOT_SET = new Set<string>(STANDARD_SLOTS);\n\n/**\n * Compose the final ordered layer list from a layersMap and the resolved\n * standard-slot layers.\n *\n * Semantics:\n * - Standard slots are emitted in `STANDARD_SLOTS` order.\n * - Each standard-slot layer is preceded by its `before` chain (deepest first)\n *   and followed by its `after` chain (ancestors first).\n * - `after: 'X'` / `before: 'X'` accept standard slot names OR other\n *   custom-layer keys, and chains may mix the two — a custom anchored\n *   `before` a slot can itself carry an `after` chain, and vice versa.\n * - Customs with neither `after` nor `before` go to a tail bucket emitted\n *   after all standard slots.\n * - Dangling references (target unresolvable) go to the tail with a\n *   `console.warn`. Cycles are detected and broken with a warning.\n *\n * Pure function — no side effects beyond `console.warn` on malformed input.\n */\nexport function composeOrderedLayers<TNode extends { id: string }, TPose>(\n  layersMap: Record<string, LayerSlotValue<TNode, TPose> | null | undefined>,\n  standardLayers: Partial<Record<(typeof STANDARD_SLOTS)[number], RenderLayer<unknown>>>,\n  /** When the `scene` slot is split into per-scene-layer canvas layers (keyed\n   *  `scene:<layerId>`), pass them here in render order. Each key becomes an\n   *  anchor point, so customs can target `before/after: 'scene:<layerId>'`.\n   *  `before/after: 'scene'` still works (before the first / after the last).\n   *  When omitted, the `scene` slot uses `standardLayers.scene` as before. */\n  sceneLayers?: ReadonlyArray<{ key: string; layer: RenderLayer<unknown> }>,\n  /** Drawn beneath everything else, grid and customs anchored before the\n   *  scene included — a fill that must never cover what is laid over it. */\n  background?: RenderLayer<unknown>,\n): RenderLayer<unknown>[] {\n  // Map<parent key, [{ key, layer }, ...]> — children grouped by their declared anchor.\n  const afterByParent = new Map<string, Array<{ key: string; layer: RenderLayer<unknown> }>>();\n  const beforeByParent = new Map<string, Array<{ key: string; layer: RenderLayer<unknown> }>>();\n  const tail: Array<{ key: string; layer: RenderLayer<unknown> }> = [];\n  const allCustomKeys = new Set<string>();\n\n  for (const [key, value] of Object.entries(layersMap)) {\n    if (STANDARD_SLOT_SET.has(key)) continue;\n    if (!isCustomEntry(value)) continue;\n    allCustomKeys.add(key);\n    if (value.after) {\n      const arr = afterByParent.get(value.after) ?? [];\n      arr.push({ key, layer: value.layer });\n      afterByParent.set(value.after, arr);\n    } else if (value.before) {\n      const arr = beforeByParent.get(value.before) ?? [];\n      arr.push({ key, layer: value.layer });\n      beforeByParent.set(value.before, arr);\n    } else {\n      tail.push({ key, layer: value.layer });\n    }\n  }\n\n  const emitted = new Set<string>();\n  const out: RenderLayer<unknown>[] = background ? [background] : [];\n\n  function emitChild(child: { key: string; layer: RenderLayer<unknown> }) {\n    if (emitted.has(child.key)) {\n      // Cycle — already emitted via another path. Warn once.\n      console.warn(`composeOrderedLayers: cycle detected involving custom layer \"${child.key}\"`);\n      return;\n    }\n    emitted.add(child.key);\n    emitBefore(child.key);\n    out.push(child.layer);\n    emitAfter(child.key);\n  }\n\n  function emitAfter(parentKey: string) {\n    for (const child of afterByParent.get(parentKey) ?? []) emitChild(child);\n  }\n\n  function emitBefore(parentKey: string) {\n    for (const child of beforeByParent.get(parentKey) ?? []) emitChild(child);\n  }\n\n  for (const slot of STANDARD_SLOTS) {\n    if (slot === 'scene' && sceneLayers) {\n      // Split scene slot: emit each per-scene-layer canvas layer in order, with\n      // its own anchor point. `before/after: 'scene'` brackets the whole group.\n      emitBefore('scene');\n      for (const sl of sceneLayers) {\n        emitBefore(sl.key);\n        out.push(sl.layer);\n        emitAfter(sl.key);\n      }\n      emitAfter('scene');\n      continue;\n    }\n    emitBefore(slot);\n    const layer = standardLayers[slot];\n    if (layer) out.push(layer);\n    emitAfter(slot);\n  }\n\n  // Tail customs (neither after nor before).\n  for (const t of tail) {\n    if (emitted.has(t.key)) continue;\n    emitted.add(t.key);\n    out.push(t.layer);\n  }\n\n  // Orphans: customs that declared an `after`/`before` but never got emitted\n  // (target didn't resolve through any chain to a known standard slot or custom).\n  for (const key of allCustomKeys) {\n    if (emitted.has(key)) continue;\n    const value = layersMap[key];\n    if (!isCustomEntry(value)) continue;\n    const ref = value.after ?? value.before;\n    console.warn(`composeOrderedLayers: dangling reference \"${ref}\" from custom layer \"${key}\" — falling back to tail`);\n    emitted.add(key);\n    out.push(value.layer);\n  }\n\n  return out;\n}\n\n/**\n * Splice a tool's positioned overlays into an already-composed layer list.\n *\n * `'top'` appends; the other two anchor on the selection-chrome layer's index\n * in `ordered`. With no selection chrome present the anchored overlays fall\n * back to the tail, keeping their relative order. Mutates and returns\n * `ordered`.\n */\nexport function placeToolOverlays(\n  ordered: RenderLayer<unknown>[],\n  selectionOverlay: RenderLayer<unknown> | undefined,\n  overlays: (position: OverlayPosition) => RenderLayer<unknown>[],\n): RenderLayer<unknown>[] {\n  const before = overlays('before-selection');\n  const after = overlays('after-selection');\n  const at = selectionOverlay ? ordered.indexOf(selectionOverlay) : -1;\n  if (at >= 0) {\n    ordered.splice(at + 1, 0, ...after);\n    ordered.splice(at, 0, ...before);\n  } else {\n    ordered.push(...before, ...after);\n  }\n  ordered.push(...overlays('top'));\n  return ordered;\n}\n"],"mappings":"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"}

package/dist/canvas/layerSlots.js

@@ -0,0 +1,14 @@
+//#region src/canvas/layerSlots.ts
+var e = [
+	"grid",
+	"cellHighlight",
+	"scene",
+	"selectionOverlay"
+];
+function t(e) {
+	return !!e && typeof e == "object" && "layer" in e;
+}
+//#endregion
+export { e as STANDARD_SLOTS, t as isCustomEntry };
+
+//# sourceMappingURL=layerSlots.js.map

package/dist/canvas/layerSlots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layerSlots.js","names":["STANDARD_SLOTS","isCustomEntry","v"],"sources":["../../src/canvas/layerSlots.ts"],"sourcesContent":["import type { RenderLayer } from '../core/layers/render';\n\n/** Standard slot names — render in this canonical order.\n *  `cellHighlight` is not an anchor for custom layers: it sits between the\n *  grid and the scene, so anchor to one of those. */\n/** @internal */\nexport const STANDARD_SLOTS = [\n  'grid',\n  'cellHighlight',\n  'scene',\n  'selectionOverlay',\n] as const;\n\n/** Names of the slots `<Canvas>` supports out of the box (excluding the implicit cell-highlight overlay). */\nexport type StandardSlotName = Exclude<(typeof STANDARD_SLOTS)[number], 'cellHighlight'>;\n\n/** Custom layer entry — any key not in `STANDARD_SLOTS`. The presence of\n *  `.layer` discriminates this from a slot config. */\nexport interface CustomLayerEntry {\n  layer: RenderLayer<unknown>;\n  /** Insert immediately after the named standard slot or another custom-layer key. */\n  after?: StandardSlotName | (string & {});\n  /** Insert immediately before the named standard slot or another custom-layer key. */\n  before?: StandardSlotName | (string & {});\n}\n\nexport function isCustomEntry(v: unknown): v is CustomLayerEntry {\n  return !!v && typeof v === 'object' && 'layer' in (v as Record<string, unknown>);\n}\n"],"mappings":";AAMA,IAAaA,IAAiB;CAC5B;CACA;CACA;CACA;AACF;AAeA,SAAgBC,EAAc,GAAmC;CAC/D,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,WAAYA;AACrD"}

package/dist/canvas/minimapMath.js

@@ -0,0 +1,80 @@
+import { documentPose as e } from "../core/scene/effectivePose.js";
+import { poseDescriptorForNode as t } from "../core/geometry/poseDescriptor.js";
+//#region src/canvas/minimapMath.ts
+var n = 8, r = {
+	x: 0,
+	y: 0,
+	scale: {
+		x: 1,
+		y: 1
+	}
+}, i = "#ffffff", a = 1, o = [2, 3];
+function s(e, t, n) {
+	let r = Math.max(1, t.width - n * 2), i = Math.max(1, t.height - n * 2);
+	if (e.width <= 0 || e.height <= 0) return {
+		x: e.x - t.width / 2,
+		y: e.y - t.height / 2,
+		scale: {
+			x: 1,
+			y: 1
+		}
+	};
+	let a = r / e.width, o = i / e.height, s = Math.min(a, o), c = e.x + e.width / 2, l = e.y + e.height / 2;
+	return {
+		x: c - t.width / (2 * s),
+		y: l - t.height / (2 * s),
+		scale: {
+			x: s,
+			y: s
+		}
+	};
+}
+function c(n, r) {
+	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity, c = !1;
+	for (let l of n.nodes.values()) {
+		if (l.kind !== "leaf") continue;
+		let u = t(r, l).getBounds(e(n, l));
+		u.x < i && (i = u.x), u.y < a && (a = u.y);
+		let d = u.x + u.width, f = u.y + u.height;
+		d > o && (o = d), f > s && (s = f), c = !0;
+	}
+	return c ? {
+		x: i,
+		y: a,
+		width: o - i,
+		height: s - a
+	} : null;
+}
+function l(e, t, i, a, o = {}) {
+	let l = o.padding ?? n;
+	if (typeof i == "function") return i(e, t);
+	if (i === "scene") {
+		let n = c(e, a);
+		return n === null ? r : s(n, t, l);
+	}
+	return s(i.rect, t, l);
+}
+function u(e, t, n = {}) {
+	return {
+		kind: "path",
+		path: {
+			kind: "rect",
+			x: e.x,
+			y: e.y,
+			width: t.width / e.scale.x,
+			height: t.height / e.scale.y
+		},
+		stroke: {
+			paint: {
+				fill: "solid",
+				color: n.stroke ?? i
+			},
+			width: n.width ?? a,
+			dash: n.dash ?? [...o]
+		}
+	};
+}
+//#endregion
+export { r as FALLBACK_FIT_VIEW, l as computeFitView, u as computeIndicatorCommand };
+
+//# sourceMappingURL=minimapMath.js.map

package/dist/canvas/minimapMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimapMath.js","names":["DEFAULT_FIT_PADDING","FALLBACK_FIT_VIEW","DEFAULT_INDICATOR_STROKE","DEFAULT_INDICATOR_WIDTH","DEFAULT_INDICATOR_DASH","fitRectInto","availW","dims","padding","availH","rect","sx","sy","worldCx","worldCy","sceneLeafBounds","minX","minY","maxX","maxY","any","node","scene","b","poseDescriptorForNode","descriptor","documentPose","right","bottom","computeFitView","opts","fit","computeIndicatorCommand","mainView","mainViewDims","style"],"sources":["../../src/canvas/minimapMath.ts"],"sourcesContent":["/**\n * Pure math helpers for `<MinimapCanvas>`.\n *\n * `computeFitView` derives a `View` that fits a chosen world rect into a\n * minimap canvas of given pixel dims. `computeIndicatorCommand` builds the\n * dashed \"visible window\" rect — the main canvas's screen window projected\n * into the minimap's own screen coordinates.\n *\n * Neither helper touches GL, the DOM, or the renderer; they're pure\n * functions, unit-testable with `expect`.\n */\nimport { documentPose } from '../core/scene';\nimport type { Scene } from '../core/scene';\nimport type { View } from '../core/viewport/view';\nimport type { Bounds, ViewportDims } from '../core/viewport/fitViewToBounds';\nimport { poseDescriptorForNode, type PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport type { PathDrawCommand } from '../renderer/DrawCommand';\n\n/** Inset (CSS px) around the fit rect on each side. Matches the spec note. */\nconst DEFAULT_FIT_PADDING = 8;\n\n/**\n * Fallback view returned when there is nothing to fit (empty scene, etc.).\n * Identity view at the origin — produces a 1:1 mapping centered on (0, 0).\n */\nexport const FALLBACK_FIT_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/**\n * Fit policy for `<MinimapCanvas>` / `computeFitView`.\n *\n * - `\"scene\"` — union of leaf-node pose AABBs (via the pose descriptor).\n * - `{ kind: \"world\", rect }` — caller-supplied world rect.\n * - `(scene, dims) => View` — caller derives the view directly.\n */\nexport type MinimapFit<TData, TLayer extends string, TPose> =\n  | 'scene'\n  | { kind: 'world'; rect: Bounds }\n  | ((scene: Scene<TData, TLayer, TPose>, dims: ViewportDims) => View);\n\n/** Style for the visible-window indicator rect drawn over the minimap. */\nexport interface IndicatorStyle {\n  /** Stroke color (any CSS color). Defaults to `'#ffffff'`. */\n  stroke?: string;\n  /** Stroke width in CSS px. Defaults to `1`. */\n  width?: number;\n  /** Dash pattern in CSS px. Defaults to `[2, 3]`. */\n  dash?: number[];\n}\n\nconst DEFAULT_INDICATOR_STROKE = '#ffffff';\nconst DEFAULT_INDICATOR_WIDTH = 1;\nconst DEFAULT_INDICATOR_DASH: readonly number[] = [2, 3];\n\n/** Internal: fit a world rect uniformly into dims with padding. */\nfunction fitRectInto(rect: Bounds, dims: ViewportDims, padding: number): View {\n  const availW = Math.max(1, dims.width - padding * 2);\n  const availH = Math.max(1, dims.height - padding * 2);\n  // Degenerate rect (zero / negative area): fall back to identity at the\n  // rect's top-left so we at least center *something* sensible.\n  if (rect.width <= 0 || rect.height <= 0) {\n    return {\n      x: rect.x - dims.width / 2,\n      y: rect.y - dims.height / 2,\n      scale: { x: 1, y: 1 },\n    };\n  }\n  const sx = availW / rect.width;\n  const sy = availH / rect.height;\n  const s = Math.min(sx, sy);\n  const worldCx = rect.x + rect.width / 2;\n  const worldCy = rect.y + rect.height / 2;\n  return {\n    x: worldCx - dims.width / (2 * s),\n    y: worldCy - dims.height / (2 * s),\n    scale: { x: s, y: s },\n  };\n}\n\n/**\n * Compute the AABB union of all leaf-node poses in the scene, via\n * `descriptor`. Container nodes are skipped — their effective bounds come\n * from their descendant leaves. Returns `null` when the scene has no\n * leaves.\n */\nfunction sceneLeafBounds<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  descriptor: PoseDescriptor<TPose>,\n): Bounds | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let any = false;\n  for (const node of scene.nodes.values()) {\n    if (node.kind !== 'leaf') continue;\n    const b = poseDescriptorForNode(descriptor, node).getBounds(documentPose(scene, node));\n    if (b.x < minX) minX = b.x;\n    if (b.y < minY) minY = b.y;\n    const right = b.x + b.width;\n    const bottom = b.y + b.height;\n    if (right > maxX) maxX = right;\n    if (bottom > maxY) maxY = bottom;\n    any = true;\n  }\n  if (!any) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** Options for {@link computeFitView}. */\nexport interface ComputeFitViewOptions {\n  /** Inset (CSS px) around the fit rect on each side. Defaults to `8`. */\n  padding?: number;\n}\n\n/**\n * Derive a `View` that fits the chosen world rect into a minimap of\n * `dims.width × dims.height` CSS px. Uniform scale on both axes; the rect\n * is centered with `padding` (default 8) on each side. The smaller-axis\n * fit ratio wins, so the whole rect is visible.\n *\n * - `fit === \"scene\"`: union AABB of leaf-node poses via `descriptor`.\n *   Empty scene → {@link FALLBACK_FIT_VIEW}.\n * - `fit` is `{ kind: \"world\", rect }`: fit `rect`. A degenerate rect\n *   (zero or negative area) falls back to identity scale centered on the\n *   rect's top-left — we don't divide by zero.\n * - `fit` is a function: called with `(scene, dims)`; its return is\n *   passed through unchanged.\n */\nexport function computeFitView<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  dims: ViewportDims,\n  fit: MinimapFit<TData, TLayer, TPose>,\n  descriptor: PoseDescriptor<TPose>,\n  opts: ComputeFitViewOptions = {},\n): View {\n  const padding = opts.padding ?? DEFAULT_FIT_PADDING;\n\n  if (typeof fit === 'function') {\n    return fit(scene, dims);\n  }\n  if (fit === 'scene') {\n    const rect = sceneLeafBounds(scene, descriptor);\n    if (rect === null) return FALLBACK_FIT_VIEW;\n    return fitRectInto(rect, dims, padding);\n  }\n  // { kind: 'world', rect }\n  return fitRectInto(fit.rect, dims, padding);\n}\n\n/**\n * Build the visible-window indicator `DrawCommand` for the minimap.\n *\n * The main canvas's visible world rect is:\n * ```\n * worldX = mainView.x\n * worldY = mainView.y\n * worldW = mainViewDims.width  / mainView.scale.x\n * worldH = mainViewDims.height / mainView.scale.y\n * ```\n * That world rect is then transformed into the minimap's screen\n * coordinates through `minimapView`.\n *\n * The returned command is a dashed-stroke `path` rect with no fill.\n */\nexport function computeIndicatorCommand(\n  mainView: View,\n  mainViewDims: ViewportDims,\n  style: IndicatorStyle = {},\n): PathDrawCommand {\n  // World-space rect: returned as-is. The caller wraps the command list\n  // (scene + extras) in a group transformed by the minimap's view, so the\n  // indicator lands in screen coords automatically. Returning screen coords\n  // here would get the view transform applied a second time — a bug that\n  // manifested as the indicator drifting at non-identity minimap scale.\n  const x = mainView.x;\n  const y = mainView.y;\n  const width = mainViewDims.width / mainView.scale.x;\n  const height = mainViewDims.height / mainView.scale.y;\n  return {\n    kind: 'path',\n    path: { kind: 'rect', x, y, width, height },\n    stroke: {\n      paint: { fill: 'solid', color: style.stroke ?? DEFAULT_INDICATOR_STROKE },\n      width: style.width ?? DEFAULT_INDICATOR_WIDTH,\n      dash: style.dash ?? [...DEFAULT_INDICATOR_DASH],\n    },\n  };\n}\n"],"mappings":";;;AAmBA,IAAMA,IAAsB,GAMfC,IAA0B;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE,GAwBrEC,IAA2B,WAC3BC,IAA0B,GAC1BC,IAA4C,CAAC,GAAG,CAAC;AAGvD,SAASC,EAAY,GAAc,GAAoB,GAAuB;CAC5E,IAAMC,IAAS,KAAK,IAAI,GAAGC,EAAK,QAAQC,IAAU,CAAC,GAC7CC,IAAS,KAAK,IAAI,GAAGF,EAAK,SAASC,IAAU,CAAC;CAGpD,IAAIE,EAAK,SAAS,KAAKA,EAAK,UAAU,GACpC,OAAO;EACL,GAAGA,EAAK,IAAIH,EAAK,QAAQ;EACzB,GAAGG,EAAK,IAAIH,EAAK,SAAS;EAC1B,OAAO;GAAE,GAAG;GAAG,GAAG;EAAE;CACtB;CAEF,IAAMI,IAAKL,IAASI,EAAK,OACnBE,IAAKH,IAASC,EAAK,QACnB,IAAI,KAAK,IAAIC,GAAIC,CAAE,GACnBC,IAAUH,EAAK,IAAIA,EAAK,QAAQ,GAChCI,IAAUJ,EAAK,IAAIA,EAAK,SAAS;CACvC,OAAO;EACL,GAAGG,IAAUN,EAAK,SAAS,IAAI;EAC/B,GAAGO,IAAUP,EAAK,UAAU,IAAI;EAChC,OAAO;GAAE,GAAG;GAAG,GAAG;EAAE;CACtB;AACF;AAQA,SAASQ,EACP,GACA,GACe;CACf,IAAIC,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO,WACPC,IAAM;CACV,KAAK,IAAMC,KAAQC,EAAM,MAAM,OAAO,GAAG;EACvC,IAAID,EAAK,SAAS,QAAQ;EAC1B,IAAME,IAAIC,EAAsBC,GAAYJ,CAAI,CAAC,CAAC,UAAUK,EAAaJ,GAAOD,CAAI,CAAC;EAErF,AADIE,EAAE,IAAIP,MAAM,IAAOO,EAAE,IACrBA,EAAE,IAAIN,MAAM,IAAOM,EAAE;EACzB,IAAMI,IAAQJ,EAAE,IAAIA,EAAE,OAChBK,IAASL,EAAE,IAAIA,EAAE;EAGvB,AAFII,IAAQT,MAAM,IAAOS,IACrBC,IAAST,MAAM,IAAOS,IAC1B,IAAM;CACR;CAEA,OADKR,IACE;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK,IADlD;AAEnB;AAsBA,SAAgBY,EACd,GACA,GACA,GACA,GACA,IAA8B,CAAC,GACzB;CACN,IAAMrB,IAAUsB,EAAK,WAAW9B;CAEhC,IAAI,OAAO+B,KAAQ,YACjB,OAAOA,EAAIT,GAAOf,CAAI;CAExB,IAAIwB,MAAQ,SAAS;EACnB,IAAMrB,IAAOK,EAAgBO,GAAOG,CAAU;EAE9C,OADIf,MAAS,OAAaT,IACnBI,EAAYK,GAAMH,GAAMC,CAAO;CACxC;CAEA,OAAOH,EAAY0B,EAAI,MAAMxB,GAAMC,CAAO;AAC5C;AAiBA,SAAgBwB,EACd,GACA,GACA,IAAwB,CAAC,GACR;CAUjB,OAAO;EACL,MAAM;EACN,MAAM;GAAE,MAAM;GAAQ,GANdC,EAAS;GAMQ,GALjBA,EAAS;GAKW,OAJhBC,EAAa,QAAQD,EAAS,MAAM;GAIb,QAHtBC,EAAa,SAASD,EAAS,MAAM;EAGR;EAC1C,QAAQ;GACN,OAAO;IAAE,MAAM;IAAS,OAAOE,EAAM,UAAUjC;GAAyB;GACxE,OAAOiC,EAAM,SAAShC;GACtB,MAAMgC,EAAM,QAAQ,CAAC,GAAG/B,CAAsB;EAChD;CACF;AACF"}

package/dist/canvas/mountedCanvases.js

@@ -0,0 +1,20 @@
+//#region src/canvas/mountedCanvases.ts
+var e = /* @__PURE__ */ new Map();
+function t(t) {
+	return e.set(t.element, t), () => {
+		e.get(t.element) === t && e.delete(t.element);
+	};
+}
+function n(t, n) {
+	if (n instanceof Node) for (let r = n; r && t.contains(r); r = r.parentNode) {
+		let t = e.get(r);
+		if (t) return t;
+	}
+	let r = null;
+	for (let n of e.values()) t.contains(n.element) && (!r || r.element.compareDocumentPosition(n.element) & Node.DOCUMENT_POSITION_PRECEDING) && (r = n);
+	return r;
+}
+//#endregion
+export { n as findMountedCanvas, t as registerMountedCanvas };
+
+//# sourceMappingURL=mountedCanvases.js.map

package/dist/canvas/mountedCanvases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mountedCanvases.js","names":["mounted","registerMountedCanvas","entry","findMountedCanvas","hint","n","root","hit","first"],"sources":["../../src/canvas/mountedCanvases.ts"],"sourcesContent":["/**\n * Every mounted kit canvas, keyed by the element its input and its\n * client→world conversions measure. DOM chrome that is handed only an element\n * — a text-edit container — finds the camera beneath it here instead of making\n * the consumer thread the view through by hand.\n */\nimport type { View } from 'core/viewport/view';\n\nexport interface MountedCanvas {\n  readonly element: HTMLElement;\n  getView(): View;\n}\n\nconst mounted = new Map<HTMLElement, MountedCanvas>();\n\n/** Register `entry` until the returned disposer runs. */\nexport function registerMountedCanvas(entry: MountedCanvas): () => void {\n  mounted.set(entry.element, entry);\n  return () => {\n    if (mounted.get(entry.element) === entry) mounted.delete(entry.element);\n  };\n}\n\n/**\n * The kit canvas at or inside `root`. When `hint` is given, the canvas that\n * contains it wins — the one a click actually landed on. Otherwise the first\n * in document order.\n */\nexport function findMountedCanvas(root: Element, hint?: EventTarget | null): MountedCanvas | null {\n  if (hint instanceof Node) {\n    for (let n: Node | null = hint; n && root.contains(n); n = n.parentNode) {\n      const hit = mounted.get(n as HTMLElement);\n      if (hit) return hit;\n    }\n  }\n  let first: MountedCanvas | null = null;\n  for (const entry of mounted.values()) {\n    if (!root.contains(entry.element)) continue;\n    if (\n      !first\n      || first.element.compareDocumentPosition(entry.element) & Node.DOCUMENT_POSITION_PRECEDING\n    ) {\n      first = entry;\n    }\n  }\n  return first;\n}\n"],"mappings":";AAaA,IAAMA,oBAAU,IAAI,IAAgC;AAGpD,SAAgBC,EAAsB,GAAkC;CAEtE,OADAD,EAAQ,IAAIE,EAAM,SAASA,CAAK,SACnB;EACX,AAAIF,EAAQ,IAAIE,EAAM,OAAO,MAAMA,KAAOF,EAAQ,OAAOE,EAAM,OAAO;CACxE;AACF;AAOA,SAAgBC,EAAkB,GAAe,GAAiD;CAChG,IAAIC,aAAgB,MAClB,KAAK,IAAIC,IAAiBD,GAAMC,KAAKC,EAAK,SAASD,CAAC,GAAG,IAAIA,EAAE,YAAY;EACvE,IAAME,IAAMP,EAAQ,IAAIK,CAAgB;EACxC,IAAIE,GAAK,OAAOA;CAClB;CAEF,IAAIC,IAA8B;CAClC,KAAK,IAAMN,KAASF,EAAQ,OAAO,GACjC,AAAKM,EAAK,SAASJ,EAAM,OAAO,MAE9B,CAACM,KACEA,EAAM,QAAQ,wBAAwBN,EAAM,OAAO,IAAI,KAAK,iCAE/D,IAAQA;CAGZ,OAAOM;AACT"}

package/dist/canvas/overlayRoleStrokes.js

@@ -0,0 +1,17 @@
+//#region src/canvas/overlayRoleStrokes.ts
+var e = {
+	cut: {
+		paint: { color: "#e23b3b" },
+		width: 1,
+		dash: [6, 4]
+	},
+	connector: {
+		paint: { color: "#7ba7c7" },
+		width: 2,
+		dash: [4, 4]
+	}
+};
+//#endregion
+export { e as OVERLAY_ROLE_STROKES };
+
+//# sourceMappingURL=overlayRoleStrokes.js.map

package/dist/canvas/overlayRoleStrokes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayRoleStrokes.js","names":["OVERLAY_ROLE_STROKES"],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\n\n/** How each `polyline` overlay role reads. An action publishes the run and\n *  the word; this table is the whole of the paint, for the dispatcher overlay\n *  and for any tool previewing the same kind of run between gestures. */\nexport const OVERLAY_ROLE_STROKES: Readonly<Record<string, Stroke>> = {\n  cut: { paint: { color: '#e23b3b' }, width: 1, dash: [6, 4] },\n  connector: { paint: { color: '#7ba7c7' }, width: 2, dash: [4, 4] },\n};\n"],"mappings":";AAKA,IAAaA,IAAyD;CACpE,KAAK;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CAC3D,WAAW;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;AACnE"}

package/dist/canvas/paintCull.js

@@ -0,0 +1,20 @@
+import { mat3 as e } from "../renderer/math/mat3.js";
+import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
+import { boundsMissRect as n } from "../renderer/cullDrawCommands.js";
+import { poseRotationOf as r } from "../core/geometry/poseRotation.js";
+import { rotationMatrixAbout as i } from "./poseRotation.js";
+//#region src/canvas/paintCull.ts
+function a(a, o, s) {
+	let c = o, l = t(o);
+	return (u, d, f = o) => {
+		f !== c && (c = f, l = t(f));
+		let p = a(u, d, f);
+		if (!p) return !1;
+		let m = r(d), h = m ? e.multiply(l, i(m.cx, m.cy, m.rotation)) : l;
+		return n(p, h, s);
+	};
+}
+//#endregion
+export { a as paintMissesView };
+
+//# sourceMappingURL=paintCull.js.map

package/dist/canvas/paintCull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintCull.js","names":["paintMissesView","last","view","toScreen","viewToMat3","layerView","b","paintBounds","node","pose","r","poseRotationOf","m","mat3","rotationMatrixAbout","boundsMissRect","rect"],"sources":["../../src/canvas/paintCull.ts"],"sourcesContent":["import type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport { boundsMissRect, type CullRect } from '../renderer/cullDrawCommands';\nimport { mat3, type GlMat3 } from '../renderer/math/mat3';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport { rotationMatrixAbout } from './poseRotation';\n\n/** Where a node's paint can reach, before its pose rotation — the scene\n *  slot's `paintBounds`. `null` means unknown, and the node is painted. */\nexport type PaintBoundsFn<TNode, TPose> = (node: TNode, pose: TPose, view: View) => Bounds | null;\n\n/**\n * A predicate true for the nodes whose paint cannot reach `rect` (screen\n * pixels) under `view`, by `paintBounds` taken through the pose rotation\n * `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot\n * bound is never culled.\n */\nexport function paintMissesView<TNode, TPose>(\n  paintBounds: PaintBoundsFn<TNode, TPose>,\n  view: View,\n  rect: CullRect,\n): (node: TNode, pose: TPose, layerView?: View) => boolean {\n  // `layerView` is a parallax plane's own view; planes are few, so one slot\n  // of memo covers a walk that meets them layer by layer.\n  let last = view;\n  let toScreen = viewToMat3(view);\n  return (node, pose, layerView = view) => {\n    if (layerView !== last) { last = layerView; toScreen = viewToMat3(layerView); }\n    const b = paintBounds(node, pose, layerView);\n    if (!b) return false;\n    const r = poseRotationOf(pose);\n    const m = r ? mat3.multiply(toScreen, rotationMatrixAbout(r.cx, r.cy, r.rotation) as GlMat3) : toScreen;\n    return boundsMissRect(b, m, rect);\n  };\n}\n"],"mappings":";;;;;;AAkBA,SAAgBA,EACd,GACA,GACA,GACyD;CAGzD,IAAIC,IAAOC,GACPC,IAAWC,EAAWF,CAAI;CAC9B,QAAQ,GAAM,GAAM,IAAYA,MAAS;EACvC,AAAIG,MAAcJ,MAAQ,IAAOI,GAAW,IAAWD,EAAWC,CAAS;EAC3E,IAAMC,IAAIC,EAAYC,GAAMC,GAAMJ,CAAS;EAC3C,IAAI,CAACC,GAAG,OAAO;EACf,IAAMI,IAAIC,EAAeF,CAAI,GACvBG,IAAIF,IAAIG,EAAK,SAASV,GAAUW,EAAoBJ,EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ,CAAW,IAAIP;EAC/F,OAAOY,EAAeT,GAAGM,GAAGI,CAAI;CAClC;AACF"}

package/dist/canvas/pickWalk.js

@@ -0,0 +1,158 @@
+import { planeMap as e } from "../core/viewport/parallax.js";
+import { composeWorldPose as t } from "../core/scene/composeFrame.js";
+import { resolveDerivedPath as n } from "../core/scene/derivedPath.js";
+import { definesFrame as r, effectivePose as i } from "../core/scene/effectivePose.js";
+import { asNodeId as a } from "../core/scene/types.js";
+import { findShapeSilhouette as o } from "./NodeShape.js";
+import { clipCarrier as s } from "./planeClips.js";
+//#region src/canvas/pickWalk.ts
+var c = [];
+function l(e, t, n) {
+	return e.kind === "container" ? typeof e.clipFromPose == "function" ? e.clipFromPose(t) : o(e, t, { derivedPath: n }) : null;
+}
+function u(e, t) {
+	let n = t.includeContainers ?? !0, r = t.includeLocked === !0 ? void 0 : e.isLocked, i = [], a = /* @__PURE__ */ new Map(), o = s(e.planeOf ?? null), c = (t) => {
+		let n = a.get(t.id);
+		if (n !== void 0) return n;
+		let r = l(t, e.poseOf(t), e.derivedPathOf?.(t));
+		return a.set(t.id, r), r;
+	}, u = /* @__PURE__ */ new Map(), d = (n) => {
+		if (n === void 0 || e.planeOf === void 0) return t;
+		let r = u.get(n);
+		if (r === void 0) {
+			let i = e.planeOf(n);
+			r = i === null ? t : t.inPlane?.(i) ?? null, u.set(n, r);
+		}
+		return r;
+	};
+	for (let t of e.order()) {
+		if (!n && t.kind === "container" || t.pickable === !1 || t.layer !== void 0 && e.layerIsPainted?.(t.layer) === !1 || e.alphaOf !== void 0 && e.alphaOf(t.id) <= 0 || r !== void 0 && r(t)) continue;
+		let a = d(t.layer);
+		if (a === null) continue;
+		let s = e.poseOf(t), l = e.derivedPathOf?.(t);
+		if (!a.hits(t, s, l)) continue;
+		let u = !1;
+		for (let n of e.parentsOf(t)) {
+			let e = c(n);
+			if (e !== null && !a.clipAdmits(o(e, n.layer, t.layer), t, s, l)) {
+				u = !0;
+				break;
+			}
+		}
+		u || i.push(t.id);
+	}
+	return i;
+}
+function d(e) {
+	let t = null;
+	for (let n of e.layers ?? []) n.locked === !0 && (t ??= /* @__PURE__ */ new Set()).add(n.id);
+	if (t === null) return null;
+	let n = t;
+	return (t) => {
+		let r = e.get(a(t)), i = /* @__PURE__ */ new Set();
+		for (; r !== void 0 && !i.has(r.id);) {
+			if (n.has(r.layer)) return !0;
+			i.add(r.id), r = r.parent === null ? void 0 : e.get(r.parent);
+		}
+		return !1;
+	};
+}
+function f(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e ?? []) n.visible === !1 && t.add(n.id);
+	return t;
+}
+function p(e, o = {}) {
+	let s = f(e.layers), l = d(e), { getPose: u, alphaOf: p, layerIsPainted: h } = o, g = null, _ = typeof e.overrides?.ids == "function";
+	if (!p && _) for (let t of e.overrides.ids()) {
+		let n = e.overrides.get(t)?.alpha;
+		n !== void 0 && n <= 0 && (g ??= /* @__PURE__ */ new Set()).add(t);
+	}
+	let v = p ?? (_ ? g ? (e) => +!g.has(e) : void 0 : (t) => e.overrides.get(a(t))?.alpha ?? 1), y = o.poseComposition, b = y !== void 0 && y.closure !== "identity" ? {
+		getPose: (t) => {
+			let n = e.get(a(t));
+			return n ? i(e, n) : void 0;
+		},
+		getParent: (t) => e.get(a(t))?.parent ?? null,
+		definesFrame: (t) => {
+			let n = e.get(a(t));
+			return n === void 0 || r(n);
+		}
+	} : null, x = u ? (e) => u(e.id) : b ? (e) => t(b, e.id, y.compose) : (t) => i(e, t), S = (t) => e.childrenOf(t), C = (t) => {
+		let r = e.get(t);
+		if (r !== void 0) return {
+			node: r,
+			pose: x(r),
+			get path() {
+				return n(r, C, S);
+			}
+		};
+	}, w = (e) => {
+		let t = e;
+		return t.dependsOn === void 0 ? null : n(t, C, S);
+	}, T = o.camera ? m(e.layers, o.camera) : null;
+	return {
+		...T ? { planeOf: T } : {},
+		order: () => e.renderOrderNodes(),
+		derivedPathOf: w,
+		poseOf: x,
+		parentsOf(t) {
+			let n = t.parent ?? null;
+			if (n === null) return c;
+			let r = [], i = /* @__PURE__ */ new Set();
+			for (; n !== null && !i.has(n);) {
+				i.add(n);
+				let t = e.get(a(n));
+				if (!t) break;
+				r.push(t), n = t.parent ?? null;
+			}
+			return r;
+		},
+		...v ? { alphaOf: v } : {},
+		...l ? { isLocked: (e) => l(e.id) } : {},
+		...s.size > 0 || h ? { layerIsPainted: (e) => !s.has(e) && (h === void 0 || h(e)) } : {}
+	};
+}
+function m(t, n) {
+	let r = null;
+	for (let i of t ?? []) i.parallax && (r ??= /* @__PURE__ */ new Map()).set(i.id, e(n, i.parallax));
+	if (r === null) return null;
+	let i = r;
+	return (e) => i.get(e) ?? null;
+}
+function h(e, t = {}) {
+	let n = e, r = typeof e.getChildren == "function" && typeof e.getNode == "function", i = /* @__PURE__ */ new Map(), a = (t) => typeof e.getWorldPose == "function" ? e.getWorldPose(t) : e.getPose(t), o = (e) => ({
+		...n.getNode(e),
+		id: e,
+		pose: a(e)
+	});
+	return {
+		order() {
+			if (!r) return i = /* @__PURE__ */ new Map(), e.getNodes().map((e) => ({
+				...e,
+				id: e.id,
+				pose: a(e.id)
+			}));
+			let t = [], s = /* @__PURE__ */ new Map(), c = (e, r) => {
+				for (let i of n.getChildren(e)) {
+					let e = o(i);
+					r && s.set(i, r), t.push(e), c(i, e);
+				}
+			};
+			return c(null, null), i = s, t;
+		},
+		...t.alphaOf ? { alphaOf: t.alphaOf } : {},
+		...t.layerIsPainted ? { layerIsPainted: t.layerIsPainted } : {},
+		...t.planeOf ? { planeOf: t.planeOf } : {},
+		poseOf: (e) => a(e.id),
+		parentsOf(e) {
+			let t = [], n = i.get(e.id), r = /* @__PURE__ */ new Set();
+			for (; n && !r.has(n.id);) r.add(n.id), t.push(n), n = i.get(n.id);
+			return t;
+		}
+	};
+}
+//#endregion
+export { h as adapterPickSource, f as hiddenLayerIds, l as ownClipOf, u as pickWalk, p as scenePickSource, m as scenePlaneOf };
+
+//# sourceMappingURL=pickWalk.js.map

package/dist/canvas/pickWalk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickWalk.js","names":["EMPTY_PARENTS","ownClipOf","node","pose","findShapeSilhouette","derived","pickWalk","includeContainers","q","isLocked","src","out","clipPath","carry","clipCarrier","clipOf","cached","ancestor","resolved","planeQueries","queryFor","layer","found","map","query","clipped","clip","lockedNodeTest","locked","scene","lockedLayers","cur","asNodeId","id","seen","hiddenLayerIds","layers","scenePickSource","hidden","opts","faded","enumerable","alphaOf","a","readAlpha","composition","chain","effectivePose","definesFrame","poseOf","getPose","composeWorldPose","childrenOf","depOf","dep","resolveDerivedPath","derivedPathOf","n","planeOf","scenePlaneOf","parentId","parent","layerIsPainted","maps","l","planeMap","camera","adapterPickSource","hier","adapter","hierarchical","parents","worldPose","nodeOf","next","visit","childId","gates"],"sources":["../../src/canvas/pickWalk.ts"],"sourcesContent":["/**\n * The one hit-test walk.\n *\n * Four walks used to answer this question — two point queries, two area\n * queries — over the same tree with the same gates. They drifted three times\n * without a failing test, because nothing held them to each other. Everything\n * that decides whether a node *can* be hit lives here now; a query supplies\n * only the shape test and the clip predicate for its own region.\n *\n * The gates, in the order the walk applies them:\n *   1. containers, when the query does not want them\n *   2. the layer is painted at all — scene visibility, and the asking view's\n *      `layerVisibility` / `layerOrder`\n *   3. painted alpha is above zero\n *   4. the node is not locked, unless the query asks for locked nodes\n *   5. the query's own shape test\n *   6. every ancestor clip admits the query region\n *\n * 2, 3 and 6 are all \"the renderer did not put this on screen\". A pick path\n * that skips one answers for a node the user cannot see. 4 is the other axis:\n * a locked node is on screen and still out of reach.\n */\n\nimport type { Path } from '@weasel-js/geom';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\nimport type { DerivedDep, Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport { resolveDerivedPath } from './derivedPath';\nimport { composeWorldPose, type PoseAdapter, type PoseComposition } from 'features/groups/composePose';\nimport { planeMap, type ParallaxOpts, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { clipCarrier } from './planeClips';\n\n/** Shared, never mutated: most scenes are flat and every node returns it. */\nconst EMPTY_PARENTS: readonly never[] = [];\n\n/** The subset of a node the walk itself reads. Deliberately structural: a\n *  bare adapter's node satisfies it as readily as a `SceneNode`. */\nexport interface PickCandidate<TPose> {\n  id: string;\n  kind?: string;\n  layer?: string;\n  pose: TPose;\n  /** `false` makes the node transparent to the walk — see `SceneNode.pickable`. */\n  pickable?: boolean;\n  clipFromPose?: (pose: TPose) => Path | null;\n}\n\n/**\n * Everything the walk reads that a **view** owns.\n *\n * A layer must not hold state a view owns, so none of these are closed over\n * at construction — each is asked per walk, of the view being dispatched to.\n */\nexport interface PickSource<TPose> {\n  /** Candidates in paint order, back-to-front. Containers included; the\n   *  query decides whether they can be hit. */\n  order(): readonly PickCandidate<TPose>[];\n  /** The pose the renderer draws — override-aware. Not `node.pose`, which is\n   *  how the render and pick paths came to disagree about where a node is. */\n  poseOf(node: PickCandidate<TPose>): TPose;\n  /** Ancestors, innermost first. Only walked for candidates that already\n   *  passed their own shape test. */\n  parentsOf(node: PickCandidate<TPose>): readonly PickCandidate<TPose>[];\n  /** Painted alpha for the asking view: the view's `alphaFor` times any\n   *  per-node override alpha. Omit when the source has no alpha concept. */\n  alphaOf?(id: string): number;\n  /** Whether this layer reaches the screen in the asking view. Omit for a\n   *  source with no layers. */\n  layerIsPainted?(layer: string): boolean;\n  /** Whether the node is locked — painted, but not something a pointer can\n   *  take. Omit for a source with no lock concept. */\n  isLocked?(node: PickCandidate<TPose>): boolean;\n  /** The path a node computes from its dependencies' poses, or null when it\n   *  derives nothing. Only a scene-backed source can answer — deriving needs\n   *  the dependencies' poses — so a bare adapter omits it, and every derived\n   *  node there keeps answering from its own (placeholder) pose. */\n  derivedPathOf?(node: PickCandidate<TPose>): Path | null;\n  /** How the asking view's world maps into a parallax layer's, or null for a\n   *  layer that moves with the camera. Omit for a source with no planes. */\n  planeOf?(layer: string): PlaneMap | null;\n}\n\n/** One hit-test question: what region, and what counts as covering it. */\nexport interface PickQuery<TPose> {\n  /** Default `true`. The area walks exclude containers so a marquee does not\n   *  return a container and its children both. */\n  includeContainers?: boolean;\n  /** Default `false`. Every selecting or editing query passes over locked\n   *  nodes; one that only samples what is painted can take them back. */\n  includeLocked?: boolean;\n  /** Does this node, drawn at this pose, cover the query region? `derived`\n   *  is the node's resolved path when it has one — a derived node's pose is a\n   *  placeholder, so a region test that reads only the pose answers for the\n   *  wrong box. */\n  hits(node: PickCandidate<TPose>, pose: TPose, derived?: Path | null): boolean;\n  /**\n   * Does an ancestor's clip leave anything of `node` for this query to hit?\n   *\n   * A point query asks point-in-clip and ignores the node. An area query has\n   * to ask about the node as well: the clip and the area can overlap where\n   * the node is not, and the node and the clip can overlap where the area is\n   * not, and only the two terms together reject both.\n   */\n  clipAdmits(\n    clip: Path,\n    node: PickCandidate<TPose>,\n    pose: TPose,\n    derived?: Path | null,\n  ): boolean;\n  /** The same question asked in a parallax plane's world: the region carried\n   *  through `map`, and any screen-pixel slop re-derived at the plane's scale.\n   *  A query without it cannot reach nodes on a plane — it would test them\n   *  where their poses sit rather than where they are painted. */\n  inPlane?(map: PlaneMap): PickQuery<TPose>;\n}\n\n/** The clip a container imposes on its subtree, or null when it imposes none. */\nexport function ownClipOf<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived?: Path | null,\n): Path | null {\n  if (node.kind !== 'container') return null;\n  if (typeof node.clipFromPose === 'function') return node.clipFromPose(pose);\n  return findShapeSilhouette(\n    node as unknown as Node<unknown, string, TPose>,\n    pose,\n    { derivedPath: derived },\n  );\n}\n\n/**\n * Collect every candidate the query hits, back-to-front — the last element is\n * the topmost, which is the order `pickTopMostHit` expects.\n */\nexport function pickWalk<TPose>(\n  src: PickSource<TPose>,\n  q: PickQuery<TPose>,\n): string[] {\n  const includeContainers = q.includeContainers ?? true;\n  const isLocked = q.includeLocked === true ? undefined : src.isLocked;\n  const out: string[] = [];\n\n  // Resolving a container's clip means `clipFromPose` or a silhouette build,\n  // which is the expensive half; the predicate against it is cheap. So the\n  // *path* is memoized per container for the walk and the predicate re-runs\n  // per candidate — `clipAdmits` needs the candidate, and caching its answer\n  // per container would answer the wrong question for an area query.\n  const clipPath = new Map<string, Path | null>();\n  // A clip is in its container's plane; the query is in the candidate's.\n  const carry = clipCarrier(src.planeOf ?? null);\n\n  const clipOf = (ancestor: PickCandidate<TPose>): Path | null => {\n    const cached = clipPath.get(ancestor.id);\n    if (cached !== undefined) return cached;\n    const resolved = ownClipOf(\n      ancestor, src.poseOf(ancestor), src.derivedPathOf?.(ancestor),\n    );\n    clipPath.set(ancestor.id, resolved);\n    return resolved;\n  };\n\n  // One reprojected query per plane per walk; `null` marks a plane this\n  // query cannot reach.\n  const planeQueries = new Map<string, PickQuery<TPose> | null>();\n  const queryFor = (layer: string | undefined): PickQuery<TPose> | null => {\n    if (layer === undefined || src.planeOf === undefined) return q;\n    let found = planeQueries.get(layer);\n    if (found === undefined) {\n      const map = src.planeOf(layer);\n      found = map === null ? q : (q.inPlane?.(map) ?? null);\n      planeQueries.set(layer, found);\n    }\n    return found;\n  };\n\n  for (const node of src.order()) {\n    if (!includeContainers && node.kind === 'container') continue;\n    // Transparent to picking: the click belongs to whatever is behind it,\n    // which for a label inside a box is the box.\n    if (node.pickable === false) continue;\n    if (node.layer !== undefined && src.layerIsPainted?.(node.layer) === false) continue;\n    if (src.alphaOf !== undefined && src.alphaOf(node.id) <= 0) continue;\n    if (isLocked !== undefined && isLocked(node)) continue;\n\n    const query = queryFor(node.layer);\n    if (query === null) continue;\n    const pose = src.poseOf(node);\n    const derived = src.derivedPathOf?.(node);\n    if (!query.hits(node, pose, derived)) continue;\n\n    let clipped = false;\n    for (const ancestor of src.parentsOf(node)) {\n      const clip = clipOf(ancestor);\n      if (clip === null) continue;\n      if (!query.clipAdmits(carry(clip, ancestor.layer, node.layer), node, pose, derived)) {\n        clipped = true;\n        break;\n      }\n    }\n    if (clipped) continue;\n\n    out.push(node.id);\n  }\n\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// Sources\n// ---------------------------------------------------------------------------\n\n/** Answers `Scene.isLocked` from the layer records and parent links alone,\n *  so a partial scene stand-in works too. Null when nothing is locked, which\n *  is what keeps the gate off the walk in the common case. */\nfunction lockedNodeTest(\n  scene: Pick<Scene<unknown, string, unknown>, 'layers' | 'get'>,\n): ((id: string) => boolean) | null {\n  let locked: Set<string> | null = null;\n  for (const layer of scene.layers ?? []) {\n    if (layer.locked === true) (locked ??= new Set()).add(layer.id);\n  }\n  if (locked === null) return null;\n  const lockedLayers = locked;\n  return (id) => {\n    let cur = scene.get(asNodeId(id));\n    const seen = new Set<string>();\n    while (cur !== undefined && !seen.has(cur.id)) {\n      if (lockedLayers.has(cur.layer)) return true;\n      seen.add(cur.id);\n      cur = cur.parent === null ? undefined : scene.get(cur.parent);\n    }\n    return false;\n  };\n}\n\n/** Layer ids the scene reports as hidden. Only an explicit `false` hides a\n *  layer: a partial scene stand-in that omits the flag stays pickable. */\nexport function hiddenLayerIds(\n  layers: readonly { id: string; visible?: boolean }[] | undefined,\n): Set<string> {\n  const out = new Set<string>();\n  for (const layer of layers ?? []) {\n    if (layer.visible === false) out.add(layer.id);\n  }\n  return out;\n}\n\n/**\n * The two answers a pick needs from the view it is asked for rather than from\n * the data behind it: how that view paints a node, and whether it paints a\n * layer at all. A scene and a bare adapter take the same pair.\n */\nexport interface ViewPickGates {\n  /** Painted alpha: the view's `alphaFor` times any per-node override alpha.\n   *  A node painted at alpha 0 cannot be hit. */\n  alphaOf?: (id: string) => number;\n  /** Whether a node's `layer` reaches the screen in the asking view. */\n  layerIsPainted?: (layer: string) => boolean;\n}\n\n/** The gates a bare adapter takes from its view, plus how that view's camera\n *  maps into each parallax layer — see `scenePlaneOf`. */\nexport interface AdapterPickGates extends ViewPickGates {\n  planeOf?: (layer: string) => PlaneMap | null;\n}\n\nexport interface ScenePickSourceOptions<TPose> extends ViewPickGates {\n  /** Pose lookup, when the caller holds an adapter that already resolves\n   *  overrides. Defaults to `effectivePose` against the scene's own. */\n  getPose?: (id: string) => TPose;\n  /** The asking view's composed alpha — `alphaFor(id)` times override alpha.\n   *  Defaults to the override alpha alone, which is all a bare scene knows. */\n  alphaOf?: (id: string) => number;\n  /** The asking view's answer to \"does this scene layer reach the screen\",\n   *  which is `layerVisibility` and `layerOrder` on top of the scene's own\n   *  `visible` flag. Consulted after the scene's flag, never instead of it. */\n  layerIsPainted?: (layer: string) => boolean;\n  /** How a child's stored pose folds into its parent's frame. Needed because\n   *  picking tests where a node is drawn, and under a composing strategy that\n   *  is not where its own pose says. Ignored when `getPose` already answers in\n   *  world coordinates. */\n  poseComposition?: PoseComposition<TPose>;\n  /** The asking view's camera. With it, a layer carrying `parallax` is picked\n   *  through its plane; without it, every layer is taken to move with the\n   *  camera. */\n  camera?: View;\n}\n\nexport function scenePickSource<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: ScenePickSourceOptions<TPose> = {},\n): PickSource<TPose> {\n  const hidden = hiddenLayerIds(scene.layers);\n  const locked = lockedNodeTest(scene as never);\n  const { getPose, alphaOf, layerIsPainted } = opts;\n\n  // Resolved once per walk rather than once per candidate: a scene with\n  // nothing faded has nothing to say about alpha, and asking it per node is a\n  // Map lookup on a linear scan that has no other reason to touch the\n  // override table. Needs enumeration — a partial scene stand-in carrying\n  // only `get` falls back to reading per node.\n  let faded: Set<string> | null = null;\n  const enumerable = typeof scene.overrides?.ids === 'function';\n  if (!alphaOf && enumerable) {\n    for (const id of scene.overrides.ids()) {\n      const a = scene.overrides.get(id)?.alpha;\n      if (a !== undefined && a <= 0) (faded ??= new Set()).add(id);\n    }\n  }\n  const readAlpha = alphaOf\n    ?? (enumerable\n      ? (faded ? (id: string) => (faded.has(id) ? 0 : 1) : undefined)\n      : (id: string) => scene.overrides.get(asNodeId(id))?.alpha ?? 1);\n\n  // A composing strategy makes a node's own pose local, so picking has to fold\n  // the parent chain the same way the render walk does or it tests where the\n  // node is stored rather than where it is drawn.\n  const composition = opts.poseComposition;\n  const chain: PoseAdapter<TPose> | null =\n    composition !== undefined && composition.closure !== 'identity'\n      ? {\n          getPose: (id: string) => {\n            const n = scene.get(asNodeId(id));\n            return n ? effectivePose(scene, n) : (undefined as unknown as TPose);\n          },\n          getParent: (id: string) => scene.get(asNodeId(id))?.parent ?? null,\n          definesFrame: (id: string) => {\n            const n = scene.get(asNodeId(id));\n            return n === undefined || definesFrame(n);\n          },\n        }\n      : null;\n\n  const poseOf = getPose\n    ? (node: PickCandidate<TPose>) => getPose(node.id)\n    : chain\n      ? (node: PickCandidate<TPose>) => composeWorldPose(chain, node.id, composition!.compose)\n      : (node: PickCandidate<TPose>) => effectivePose(scene, node as never);\n\n  // Through `poseOf`, not the document pose: a derived node has to be tested\n  // where the renderer draws its dependencies, which is what an override says.\n  const childrenOf = (id: NodeId): readonly NodeId[] => scene.childrenOf(id);\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const dep = scene.get(id);\n    if (dep === undefined) return undefined;\n    return {\n      node: dep as Node<unknown, string, TPose>,\n      pose: poseOf(dep as never),\n      get path(): Path | null {\n        return resolveDerivedPath(dep as never, depOf, childrenOf);\n      },\n    };\n  };\n\n  const derivedPathOf = (node: PickCandidate<TPose>): Path | null => {\n    const n = node as unknown as Node<TData, TLayer, TPose>;\n    if (n.dependsOn === undefined) return null;\n    return resolveDerivedPath(n, depOf, childrenOf);\n  };\n\n  const planeOf = opts.camera ? scenePlaneOf(scene.layers, opts.camera) : null;\n\n  return {\n    ...(planeOf ? { planeOf } : {}),\n    order: () => scene.renderOrderNodes() as unknown as readonly PickCandidate<TPose>[],\n    derivedPathOf,\n    poseOf,\n    parentsOf(node) {\n      let parentId = (node as { parent?: string | null }).parent ?? null;\n      if (parentId === null) return EMPTY_PARENTS;\n      const chain: PickCandidate<TPose>[] = [];\n      const seen = new Set<string>();\n      while (parentId !== null) {\n        if (seen.has(parentId)) break;\n        seen.add(parentId);\n        const parent = scene.get(asNodeId(parentId));\n        if (!parent) break;\n        chain.push(parent as unknown as PickCandidate<TPose>);\n        parentId = parent.parent ?? null;\n      }\n      return chain;\n    },\n    // Absent entirely when nothing is faded, so the walk skips the gate.\n    ...(readAlpha ? { alphaOf: readAlpha } : {}),\n    ...(locked ? { isLocked: (node: PickCandidate<TPose>) => locked(node.id) } : {}),\n    ...(hidden.size > 0 || layerIsPainted\n      ? {\n        layerIsPainted: (layer: string) =>\n          !hidden.has(layer) && (layerIsPainted === undefined || layerIsPainted(layer)),\n      }\n      : {}),\n  };\n}\n\n/** Each parallax layer's plane map under `camera`, or null when no layer is a\n *  plane — which keeps the per-layer lookup off the walk entirely. */\nexport function scenePlaneOf(\n  layers: readonly { id: string; parallax?: ParallaxOpts }[] | undefined,\n  camera: View,\n): ((layer: string) => PlaneMap | null) | null {\n  let maps: Map<string, PlaneMap> | null = null;\n  for (const l of layers ?? []) {\n    if (l.parallax) (maps ??= new Map()).set(l.id, planeMap(camera, l.parallax));\n  }\n  if (maps === null) return null;\n  const found = maps;\n  return (layer) => found.get(layer) ?? null;\n}\n\n/** The adapter surface the walk can reach without a `Scene`. */\ninterface PickAdapter<TPose> {\n  /** Composed world pose, when the adapter has a composition strategy.\n   *  Falls back to `getPose`, which is the same value under the\n   *  absolute-pose model. */\n  getWorldPose?(id: string): TPose;\n  getNodes(): readonly { id: string }[];\n  getPose(id: string): TPose;\n  getNode?: (id: string) => unknown;\n  getChildren?: (parentId: string | null) => readonly string[];\n}\n\n/**\n * A source over a bare `SelectAdapter`, for consumers with no `Scene`.\n *\n * A hierarchical adapter is walked depth-first, parents before children —\n * the same back-to-front order `renderOrderNodes` produces for a single\n * layer. A flat adapter falls back to `getNodes()`, which carries no\n * parentage, so nothing clips.\n *\n * `gates` come from whichever view is picking, never from the adapter.\n */\nexport function adapterPickSource<TPose>(\n  adapter: PickAdapter<TPose>,\n  gates: AdapterPickGates = {},\n): PickSource<TPose> {\n  const hier = adapter as Required<Pick<PickAdapter<TPose>, 'getNode' | 'getChildren'>>;\n  const hierarchical =\n    typeof adapter.getChildren === 'function' && typeof adapter.getNode === 'function';\n\n  // Rebuilt per walk: the tree may have changed between queries, and a walk\n  // is the only thing that reads it.\n  let parents = new Map<string, PickCandidate<TPose>>();\n\n  // The adapter composes if it has a strategy; `getPose` alone is the node's\n  // own pose, which is not where a framed child is drawn.\n  const worldPose = (id: string): TPose =>\n    (typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id));\n\n  const nodeOf = (id: string): PickCandidate<TPose> => {\n    const raw = hier.getNode(id) as Partial<PickCandidate<TPose>>;\n    return { ...raw, id, pose: worldPose(id) } as PickCandidate<TPose>;\n  };\n\n  return {\n    order() {\n      if (!hierarchical) {\n        parents = new Map();\n        return adapter.getNodes().map((n) => ({\n          ...(n as object), id: n.id, pose: worldPose(n.id),\n        })) as PickCandidate<TPose>[];\n      }\n      const out: PickCandidate<TPose>[] = [];\n      const next = new Map<string, PickCandidate<TPose>>();\n      const visit = (parentId: string | null, parent: PickCandidate<TPose> | null): void => {\n        for (const childId of hier.getChildren(parentId)) {\n          const node = nodeOf(childId);\n          if (parent) next.set(childId, parent);\n          out.push(node);\n          visit(childId, node);\n        }\n      };\n      visit(null, null);\n      parents = next;\n      return out;\n    },\n    ...(gates.alphaOf ? { alphaOf: gates.alphaOf } : {}),\n    ...(gates.layerIsPainted ? { layerIsPainted: gates.layerIsPainted } : {}),\n    ...(gates.planeOf ? { planeOf: gates.planeOf } : {}),\n    poseOf: (node) => worldPose(node.id),\n    parentsOf(node) {\n      const chain: PickCandidate<TPose>[] = [];\n      let cur = parents.get(node.id);\n      const seen = new Set<string>();\n      while (cur && !seen.has(cur.id)) {\n        seen.add(cur.id);\n        chain.push(cur);\n        cur = parents.get(cur.id);\n      }\n      return chain;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/planeClips.js

@@ -0,0 +1,30 @@
+import { mat3 as e } from "../renderer/math/mat3.js";
+import { planeMatrix as t, planeToPlane as n } from "../core/viewport/parallax.js";
+import { transformPath as r } from "@weasel-js/geom";
+//#region src/canvas/planeClips.ts
+function i(e) {
+	if (e === null) return (e) => e;
+	let i = (t) => t === void 0 ? null : e(t), a = /* @__PURE__ */ new WeakMap();
+	return (e, o, s) => {
+		let c = i(s), l = n(i(o), c);
+		if (l === null) return e;
+		let u = a.get(e);
+		u === void 0 && a.set(e, u = /* @__PURE__ */ new Map());
+		let d = u.get(c);
+		return d === void 0 && u.set(c, d = r(e, t(l))), d;
+	};
+}
+function a(r, i) {
+	let a = n(r, i);
+	return a === null ? void 0 : e.fromAffine(t(a));
+}
+function o(e, i) {
+	let a = e;
+	if (i === null || !a || a.kind !== "polygon" && a.kind !== "rect") return e;
+	let o = n(i, null);
+	return o === null ? e : r(e, t(o));
+}
+//#endregion
+export { i as clipCarrier, o as pathFromPlane, a as planeTransform };
+
+//# sourceMappingURL=planeClips.js.map

package/dist/canvas/planeClips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planeClips.js","names":["clipCarrier","planeOf","clip","mapOf","layer","cache","to","toLayer","m","planeToPlane","fromLayer","byTarget","out","transformPath","planeMatrix","planeTransform","from","mat3","pathFromPlane","p","path","back"],"sources":["../../src/canvas/planeClips.ts"],"sourcesContent":["import { type Path, transformPath } from '@weasel-js/geom';\nimport { planeMatrix, planeToPlane, type PlaneMap } from 'core/viewport/parallax';\nimport { mat3, type GlMat3 } from '../renderer/math/mat3';\n\n/**\n * Carries a container's clip into the world a descendant is drawn or picked\n * in. A clip is built from the container's pose, so it is in the container's\n * plane; a child on another plane reads it in its own. Null `planeOf` means no\n * layer is a plane, and every clip passes through untouched.\n *\n * Memoized per clip path and target plane, so a container with many children\n * on one other plane maps its clip once.\n */\nexport function clipCarrier(\n  planeOf: ((layer: string) => PlaneMap | null) | null,\n): (clip: Path, fromLayer: string | undefined, toLayer: string | undefined) => Path {\n  if (planeOf === null) return (clip) => clip;\n  const mapOf = (layer: string | undefined) => (layer === undefined ? null : planeOf(layer));\n  const cache = new WeakMap<Path, Map<PlaneMap | null, Path>>();\n  return (clip, fromLayer, toLayer) => {\n    const to = mapOf(toLayer);\n    const m = planeToPlane(mapOf(fromLayer), to);\n    if (m === null) return clip;\n    let byTarget = cache.get(clip);\n    if (byTarget === undefined) cache.set(clip, byTarget = new Map());\n    let out = byTarget.get(to);\n    if (out === undefined) byTarget.set(to, out = transformPath(clip, planeMatrix(m)));\n    return out;\n  };\n}\n\n/** The group transform that draws `from`'s world inside `to`'s, where `null`\n *  is the camera's. Undefined when they are the same world. */\nexport function planeTransform(from: PlaneMap | null, to: PlaneMap | null): GlMat3 | undefined {\n  const m = planeToPlane(from, to);\n  return m === null ? undefined : mat3.fromAffine(planeMatrix(m));\n}\n\n/** A path in a plane's world, in the camera's. Anything that is not a path\n *  passes through. */\nexport function pathFromPlane<T>(path: T, m: PlaneMap | null): T {\n  const p = path as { kind?: string } | null;\n  if (m === null || !p || (p.kind !== 'polygon' && p.kind !== 'rect')) return path;\n  const back = planeToPlane(m, null);\n  return back === null ? path : transformPath(path as unknown as Path, planeMatrix(back)) as unknown as T;\n}\n"],"mappings":";;;;AAaA,SAAgBA,EACd,GACkF;CAClF,IAAIC,MAAY,MAAM,QAAQ,MAASC;CACvC,IAAMC,KAAS,MAA+BC,MAAU,KAAA,IAAY,OAAOH,EAAQG,CAAK,GAClFC,oBAAQ,IAAI,QAA0C;CAC5D,QAAQ,GAAM,GAAW,MAAY;EACnC,IAAMC,IAAKH,EAAMI,CAAO,GAClBC,IAAIC,EAAaN,EAAMO,CAAS,GAAGJ,CAAE;EAC3C,IAAIE,MAAM,MAAM,OAAON;EACvB,IAAIS,IAAWN,EAAM,IAAIH,CAAI;EAC7B,AAAIS,MAAa,KAAA,KAAWN,EAAM,IAAIH,GAAM,oBAAW,IAAI,IAAI,CAAC;EAChE,IAAIU,IAAMD,EAAS,IAAIL,CAAE;EAEzB,OADIM,MAAQ,KAAA,KAAWD,EAAS,IAAIL,GAAI,IAAMO,EAAcX,GAAMY,EAAYN,CAAC,CAAC,CAAC,GAC1EI;CACT;AACF;AAIA,SAAgBG,EAAe,GAAuB,GAAyC;CAC7F,IAAMP,IAAIC,EAAaO,GAAMV,CAAE;CAC/B,OAAOE,MAAM,OAAO,KAAA,IAAYS,EAAK,WAAWH,EAAYN,CAAC,CAAC;AAChE;AAIA,SAAgBU,EAAiB,GAAS,GAAuB;CAC/D,IAAMC,IAAIC;CACV,IAAIZ,MAAM,QAAQ,CAACW,KAAMA,EAAE,SAAS,aAAaA,EAAE,SAAS,QAAS,OAAOC;CAC5E,IAAMC,IAAOZ,EAAaD,GAAG,IAAI;CACjC,OAAOa,MAAS,OAAOD,IAAOP,EAAcO,GAAyBN,EAAYO,CAAI,CAAC;AACxF"}

package/dist/canvas/poseRotation.js

@@ -0,0 +1,35 @@
+import { poseRotationOf as e } from "../core/geometry/poseRotation.js";
+import { rotateAboutPoint as t } from "@weasel-js/geom";
+//#region src/canvas/poseRotation.ts
+function n(e) {
+	return new Float32Array([
+		e[0],
+		e[1],
+		0,
+		e[2],
+		e[3],
+		0,
+		e[4],
+		e[5],
+		1
+	]);
+}
+function r(e, r, i) {
+	return n(t(e, r, i));
+}
+function i(e, t, n, i, a) {
+	return r(e + n / 2, t + i / 2, a);
+}
+function a(t, n) {
+	if (t.length === 0) return t;
+	let i = e(n);
+	return i ? [{
+		kind: "group",
+		transform: r(i.cx, i.cy, i.rotation),
+		children: t
+	}] : t;
+}
+//#endregion
+export { i as rotateAroundAABBCenter, r as rotationMatrixAbout, a as wrapWithPoseRotation };
+
+//# sourceMappingURL=poseRotation.js.map

package/dist/canvas/poseRotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseRotation.js","names":["mat3ToRenderMatrix","m","rotationMatrixAbout","rotateAboutPoint","cx","cy","rotation","rotateAroundAABBCenter","x","width","y","height","wrapWithPoseRotation","cmds","r","poseRotationOf","pose"],"sources":["../../src/canvas/poseRotation.ts"],"sourcesContent":["/**\n * Pose rotation helpers — extracted from `SceneCanvas` so the kit can apply\n * the auto-rotation wrap around EVERY per-node `drawOne` (consumer-supplied\n * or default), not only around the default painter's output.\n *\n * Without this, consumers who supply a custom `drawOne` get no rotation\n * visualization even though selection chrome (which reads `pose.rotation`\n * directly) does rotate — the rect sits still while its chrome spins.\n *\n * `wrapWithPoseRotation` is applied by `wrapNodeOutput` in both scene walks —\n * `buildSceneLayer` (main canvas) and `buildSceneViewCommands` (detached\n * renders) — and directly by `usePreviewGhostLayer.buildSubtree` (in-flight\n * preview), so every code path produces rotated geometry uniformly.\n */\nimport type { DrawCommand } from '../renderer';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport { rotateAboutPoint, type Mat3 } from '@weasel-js/geom';\n\n/** Expand a kernel 6-tuple affine `[a, b, c, d, e, f]` (DOMMatrix order) into\n *  the 9-element column-major `[a, b, 0, c, d, 0, tx, ty, 1]` `Float32Array`\n *  the `kind: 'group'` DrawCommand wrap consumes for `uniformMatrix3fv`. Pure\n *  shape glue — the rotate-about-point MATH lives in the kernel. */\nfunction mat3ToRenderMatrix(m: Mat3): Float32Array {\n  return new Float32Array([m[0], m[1], 0, m[2], m[3], 0, m[4], m[5], 1]);\n}\n\n/** Rotation by `rotation` about `(cx, cy)` as the render-tree's column-major\n *  3×3 affine. Composes on the kernel's `rotateAboutPoint` (single owner of the\n *  rotate-about-point math); this only reshapes 6→9 for the WebGL upload. */\nexport function rotationMatrixAbout(cx: number, cy: number, rotation: number): Float32Array {\n  return mat3ToRenderMatrix(rotateAboutPoint(cx, cy, rotation));\n}\n\n/** Rotation matrix about the AABB center of `(x, y, width, height)`. The pivot\n *  matches `poseRotationOf` (the shared rotation convention). */\nexport function rotateAroundAABBCenter(\n  x: number, y: number, width: number, height: number, rotation: number,\n): Float32Array {\n  return rotationMatrixAbout(x + width / 2, y + height / 2, rotation);\n}\n\n/** Wrap a per-node draw-command list in a rotation group when the pose\n *  carries a non-zero `rotation` and AABB fields (`x`, `y`, `width`,\n *  `height`). The wrap rotates the emitted geometry around the AABB\n *  center, matching the rotation-handle math and `pathInWorld` so chrome\n *  + geometry stay aligned.\n *\n *  No-ops when `cmds` is empty, when `pose.rotation` is missing/zero, or\n *  when any of the AABB fields are missing (the wrap requires a center\n *  to rotate about). Painters / consumers that need different rotation\n *  semantics (e.g. pivot at origin) should still wrap themselves. */\nexport function wrapWithPoseRotation(\n  cmds: DrawCommand[],\n  pose: unknown,\n): DrawCommand[] {\n  if (cmds.length === 0) return cmds;\n  const r = poseRotationOf(pose);\n  if (!r) return cmds;\n  return [{\n    kind: 'group',\n    transform: rotationMatrixAbout(r.cx, r.cy, r.rotation),\n    children: cmds,\n  }];\n}\n"],"mappings":";;;AAsBA,SAASA,EAAmB,GAAuB;CACjD,OAAO,IAAI,aAAa;EAACC,EAAE;EAAIA,EAAE;EAAI;EAAGA,EAAE;EAAIA,EAAE;EAAI;EAAGA,EAAE;EAAIA,EAAE;EAAI;CAAC,CAAC;AACvE;AAKA,SAAgBC,EAAoB,GAAY,GAAY,GAAgC;CAC1F,OAAOF,EAAmBG,EAAiBC,GAAIC,GAAIC,CAAQ,CAAC;AAC9D;AAIA,SAAgBC,EACd,GAAW,GAAW,GAAe,GAAgB,GACvC;CACd,OAAOL,EAAoBM,IAAIC,IAAQ,GAAGC,IAAIC,IAAS,GAAGL,CAAQ;AACpE;AAYA,SAAgBM,EACd,GACA,GACe;CACf,IAAIC,EAAK,WAAW,GAAG,OAAOA;CAC9B,IAAMC,IAAIC,EAAeC,CAAI;CAE7B,OADKF,IACE,CAAC;EACN,MAAM;EACN,WAAWZ,EAAoBY,EAAE,IAAIA,EAAE,IAAIA,EAAE,QAAQ;EACrD,UAAUD;CACZ,CAAC,IALcA;AAMjB"}

package/dist/canvas/rasterToPng.js

@@ -0,0 +1,21 @@
+//#region src/canvas/rasterToPng.ts
+async function e(e) {
+	let t = new ImageData(new Uint8ClampedArray(e.data), e.width, e.height);
+	if (typeof OffscreenCanvas < "u") {
+		let n = new OffscreenCanvas(e.width, e.height), r = n.getContext("2d");
+		if (!r) throw Error("rasterToPng: no 2D context");
+		return r.putImageData(t, 0, 0), n.convertToBlob({ type: "image/png" });
+	}
+	if (typeof document > "u") throw Error("rasterToPng: no canvas in this environment");
+	let n = document.createElement("canvas");
+	n.width = e.width, n.height = e.height;
+	let r = n.getContext("2d");
+	if (!r) throw Error("rasterToPng: no 2D context");
+	return r.putImageData(t, 0, 0), new Promise((e, t) => {
+		n.toBlob((n) => n ? e(n) : t(/* @__PURE__ */ Error("rasterToPng: encoding failed")), "image/png");
+	});
+}
+//#endregion
+export { e as rasterToPng };
+
+//# sourceMappingURL=rasterToPng.js.map

package/dist/canvas/rasterToPng.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterToPng.js","names":["rasterToPng","pixels","image","canvas","ctx","b","resolve","reject"],"sources":["../../src/canvas/rasterToPng.ts"],"sourcesContent":["import type { RasterImage } from './renderSceneToPixels';\n\n/** Encode a raster as a PNG `Blob` — for download, upload, or the clipboard.\n *  Needs a 2D canvas: `OffscreenCanvas` where there is one, else the DOM's. */\nexport async function rasterToPng(image: RasterImage): Promise<Blob> {\n  const pixels = new ImageData(new Uint8ClampedArray(image.data), image.width, image.height);\n  if (typeof OffscreenCanvas !== 'undefined') {\n    const canvas = new OffscreenCanvas(image.width, image.height);\n    const ctx = canvas.getContext('2d');\n    if (!ctx) throw new Error('rasterToPng: no 2D context');\n    ctx.putImageData(pixels, 0, 0);\n    return canvas.convertToBlob({ type: 'image/png' });\n  }\n  if (typeof document === 'undefined') throw new Error('rasterToPng: no canvas in this environment');\n  const canvas = document.createElement('canvas');\n  canvas.width = image.width;\n  canvas.height = image.height;\n  const ctx = canvas.getContext('2d');\n  if (!ctx) throw new Error('rasterToPng: no 2D context');\n  ctx.putImageData(pixels, 0, 0);\n  return new Promise((resolve, reject) => {\n    canvas.toBlob((b) => (b ? resolve(b) : reject(new Error('rasterToPng: encoding failed'))), 'image/png');\n  });\n}\n"],"mappings":";AAIA,eAAsBA,EAAY,GAAmC;CACnE,IAAMC,IAAS,IAAI,UAAU,IAAI,kBAAkBC,EAAM,IAAI,GAAGA,EAAM,OAAOA,EAAM,MAAM;CACzF,IAAI,OAAO,kBAAoB,KAAa;EAC1C,IAAMC,IAAS,IAAI,gBAAgBD,EAAM,OAAOA,EAAM,MAAM,GACtDE,IAAMD,EAAO,WAAW,IAAI;EAClC,IAAI,CAACC,GAAK,MAAU,MAAM,4BAA4B;EAEtD,OADAA,EAAI,aAAaH,GAAQ,GAAG,CAAC,GACtBE,EAAO,cAAc,EAAE,MAAM,YAAY,CAAC;CACnD;CACA,IAAI,OAAO,WAAa,KAAa,MAAU,MAAM,4CAA4C;CACjG,IAAMA,IAAS,SAAS,cAAc,QAAQ;CAE9C,AADA,EAAO,QAAQD,EAAM,OACrB,EAAO,SAASA,EAAM;CACtB,IAAME,IAAMD,EAAO,WAAW,IAAI;CAClC,IAAI,CAACC,GAAK,MAAU,MAAM,4BAA4B;CAEtD,OADAA,EAAI,aAAaH,GAAQ,GAAG,CAAC,GACtB,IAAI,SAAS,GAAS,MAAW;EACtC,EAAO,QAAQ,MAAOI,IAAIC,EAAQD,CAAC,IAAIE,EAAO,gBAAI,MAAM,8BAA8B,CAAC,GAAI,WAAW;CACxG,CAAC;AACH"}

package/dist/canvas/renderDebugSnapshot.js

@@ -0,0 +1,32 @@
+import { mat3 as e } from "../renderer/math/mat3.js";
+import { buildDebugOverlayCommands as t } from "../debug/createDebugOverlayLayer.js";
+import { renderSceneToPixels as n } from "./renderSceneToPixels.js";
+//#region src/canvas/renderDebugSnapshot.ts
+function r(e) {
+	return n(i(e));
+}
+function i(n) {
+	let { view: r, size: i, debug: a, config: o, pixelRatio: s = 1, ...c } = n, l = t(a, o, r, i);
+	return {
+		...c,
+		sourceRect: {
+			x: r.x,
+			y: r.y,
+			width: i.width / r.scale.x,
+			height: i.height / r.scale.y
+		},
+		scale: {
+			x: r.scale.x * s,
+			y: r.scale.y * s
+		},
+		overlay: s === 1 ? l : [{
+			kind: "group",
+			transform: e.scaled(e.identity(), s, s),
+			children: l
+		}]
+	};
+}
+//#endregion
+export { i as debugSnapshotArgs, r as renderDebugSnapshot };
+
+//# sourceMappingURL=renderDebugSnapshot.js.map

package/dist/canvas/renderDebugSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderDebugSnapshot.js","names":["renderDebugSnapshot","renderSceneToPixels","debugSnapshotArgs","args","rest","overlay","buildDebugOverlayCommands","debug","config","view","size","pixelRatio","mat3"],"sources":["../../src/canvas/renderDebugSnapshot.ts"],"sourcesContent":["/**\n * `renderDebugSnapshot` — the canvas as its debug overlay showed it, scene and\n * overlay in one raster, for attaching to a bug report.\n */\nimport { renderSceneToPixels, type RasterImage, type RenderSceneToPixelsArgs } from './renderSceneToPixels';\nimport { buildDebugOverlayCommands } from '../debug/createDebugOverlayLayer';\nimport type { DebugConfig, DebugSnapshot } from '../debug/types';\nimport type { View } from '../core/viewport/view';\nimport { mat3 } from '../renderer/math/mat3';\n\n/** The canvas to reproduce — its camera, its size, and what its debug overlay\n *  had recorded — plus how to rasterize the scene under it. */\nexport interface RenderDebugSnapshotArgs<TData, TLayer extends string, TPose>\n  extends Omit<RenderSceneToPixelsArgs<TData, TLayer, TPose>, 'sourceRect' | 'scale' | 'overlay'> {\n  /** The camera the canvas was looking through. */\n  view: View;\n  /** The canvas's size in CSS pixels. */\n  size: { width: number; height: number };\n  /** Output pixels per CSS pixel. Default 1; pass `devicePixelRatio` for what\n   *  the screen showed. */\n  pixelRatio?: number;\n  /** What the overlay draws — a canvas's `getDebug()?.snapshot()`. */\n  debug: DebugSnapshot;\n  /** Which overlay features to draw, as on `<Canvas debug>`. The frame panel\n   *  shows the recorded paint cost but no rate: a still image has no frames. */\n  config: DebugConfig;\n}\n\n/**\n * Rasterize the scene through `view` at `size` and paint the debug overlay\n * over it, the way the canvas composed them. Built on `renderSceneToPixels`,\n * so the scene pixels are the screen's pixels at that resolution, and\n * synchronous like it: `await warmRender({ render: debugSnapshotArgs(args) })`\n * first. Encode the result with `rasterToPng` to attach it somewhere.\n */\nexport function renderDebugSnapshot<TData, TLayer extends string, TPose>(\n  args: RenderDebugSnapshotArgs<TData, TLayer, TPose>,\n): RasterImage {\n  return renderSceneToPixels(debugSnapshotArgs(args));\n}\n\n/** What {@link renderDebugSnapshot} hands `renderSceneToPixels`: the source\n *  rect and scale that reproduce the canvas, with the overlay composed on top. */\nexport function debugSnapshotArgs<TData, TLayer extends string, TPose>(\n  args: RenderDebugSnapshotArgs<TData, TLayer, TPose>,\n): RenderSceneToPixelsArgs<TData, TLayer, TPose> {\n  const { view, size, debug, config, pixelRatio = 1, ...rest } = args;\n  const overlay = buildDebugOverlayCommands(debug, config, view, size);\n  return {\n    ...rest,\n    sourceRect: { x: view.x, y: view.y, width: size.width / view.scale.x, height: size.height / view.scale.y },\n    scale: { x: view.scale.x * pixelRatio, y: view.scale.y * pixelRatio },\n    overlay: pixelRatio === 1\n      ? overlay\n      : [{ kind: 'group', transform: mat3.scaled(mat3.identity(), pixelRatio, pixelRatio), children: overlay }],\n  };\n}\n"],"mappings":";;;;AAmCA,SAAgBA,EACd,GACa;CACb,OAAOC,EAAoBC,EAAkBC,CAAI,CAAC;AACpD;AAIA,SAAgBD,EACd,GAC+C;CAC/C,IAAM,EAAE,SAAM,SAAM,UAAO,WAAQ,gBAAa,GAAG,GAAGE,MAASD,GACzDE,IAAUC,EAA0BC,GAAOC,GAAQC,GAAMC,CAAI;CACnE,OAAO;EACL,GAAGN;EACH,YAAY;GAAE,GAAGK,EAAK;GAAG,GAAGA,EAAK;GAAG,OAAOC,EAAK,QAAQD,EAAK,MAAM;GAAG,QAAQC,EAAK,SAASD,EAAK,MAAM;EAAE;EACzG,OAAO;GAAE,GAAGA,EAAK,MAAM,IAAIE;GAAY,GAAGF,EAAK,MAAM,IAAIE;EAAW;EACpE,SAASA,MAAe,IACpBN,IACA,CAAC;GAAE,MAAM;GAAS,WAAWO,EAAK,OAAOA,EAAK,SAAS,GAAGD,GAAYA,CAAU;GAAG,UAAUN;EAAQ,CAAC;CAC5G;AACF"}