@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/sceneClipboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneClipboard.js","names":["copyField","value","dependencyList","item","snapshotSceneSelection","env","fnFields","createNodeFnFields","scene","idSet","ids","taken","items","poseFor","n","isRoot","frame","capture","id","asNodeId","statedFields","fnFieldsOfNode","fnKeysOf","cid","a","isLive","member","restoredFnFields","out","registry","spec","NODE_FN_FIELDS","key","fn","omissions","present","src","changed","omission","deps","missing","dep","fns","pasteSceneSnapshot","all","clipboard","omitted","ctx","idMap","byId","ridesPastedFrame","p","definesFrame","dx","offset","dy","minX","minY","b","c"],"sources":["../../src/canvas/sceneClipboard.ts"],"sourcesContent":["/**\n * The scene adapter's clipboard seam: what a copy captures and what a paste\n * mints from it.\n *\n * `pasteSceneSnapshot` is a pure factory — it mints fresh nodes and never\n * touches the scene. Insertion happens through the caller's InsertOps (one per\n * created node, parents before children).\n *\n * A snapshot item carries its node's function fields twice: live, for a paste\n * in the same session, and as the scene's registry keys, for a snapshot that\n * crossed JSON on the way back.\n */\nimport type { ClipboardSnapshot, PasteCtx, PasteOmission } from 'core/adapters/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport {\n  NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, type FnBearingNode,\n} from 'core/scene/nodeFnFields';\nimport { statedFields } from 'core/scene/statedFields';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\n\n/** What the seam needs from the adapter it serves. */\nexport interface SceneClipboardEnv<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Whether a stored pose is relative to its container's frame. */\n  composes: boolean;\n  worldPoseOf(id: string): TPose;\n  /** The nearest frame-defining container at or above `id`. */\n  frameAtOrAbove(id: string | null): string | null;\n  poseBounds(pose: TPose, node: unknown): Bounds;\n  translate(pose: TPose, dx: number, dy: number, node?: unknown): TPose;\n}\n\n// Spread-level copy per the clipboard contract: mutating a snapshot's\n// 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\ntype Item<TData, TLayer extends string, TPose> =\n  Node<TData, TLayer, TPose> & Record<string, unknown>;\n\nconst dependencyList = (item: { dependsOn?: readonly NodeId[] | 'children' }): readonly NodeId[] =>\n  (Array.isArray(item.dependsOn) ? item.dependsOn : []);\n\nexport function snapshotSceneSelection<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  ids: string[],\n): ClipboardSnapshot {\n  const { scene } = env;\n  const fnFields = createNodeFnFields<TPose>(scene.registry as never);\n  const idSet = new Set(ids);\n  const taken = new Set<string>();\n  const items: Node<TData, TLayer, TPose>[] = [];\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 (!env.composes) return n.pose;\n    if (isRoot) return env.worldPoseOf(n.id);\n    const frame = env.frameAtOrAbove(n.parent);\n    return frame !== null && taken.has(frame) ? n.pose : env.worldPoseOf(n.id);\n  };\n\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  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    items.push({\n      kind: n.kind,\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.kind === 'container' ? { children: [...n.children] } : {}),\n      ...statedFields(n),\n      ...(n.dependsOn !== undefined ? { dependsOn: copyField(n.dependsOn) } : {}),\n      ...fnFieldsOfNode(n),\n      ...fnKeysOf(fnFields, n as unknown as FnBearingNode, 'jsonKey'),\n    } as Node<TData, TLayer, TPose>);\n    if (n.kind === 'container') {\n      for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);\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\n// JSON drops a function, and turns a layout strategy into an object with no\n// methods on it: neither is something a pasted node can run.\nconst isLive = (value: unknown): boolean =>\n  typeof value === 'function'\n  || (typeof value === 'object' && value !== null\n    && Object.values(value).some((member) => typeof member === 'function'));\n\n/**\n * The item's function fields: for each, what its registry key names in this\n * scene, else the live one it carries, else nothing.\n */\nfunction restoredFnFields<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  item: Item<TData, TLayer, TPose>,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  const registry = scene.registry as Record<string, Record<string, unknown> | undefined>;\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && item.kind !== 'container') continue;\n    const key = item[spec.jsonKey];\n    const registered = typeof key === 'string' ? registry[spec.field]?.[key] : undefined;\n    const fn = registered ?? (isLive(item[spec.field]) ? item[spec.field] : undefined);\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out;\n}\n\n/**\n * Which items a paste leaves out, and why. A node deriving from an id list is\n * pasted only with everything it depends on, since a copy still naming the\n * originals would follow them rather than the copies beside it; and only with\n * a derivation to run, since without one it is a placeholder that paints\n * nothing. Leaving one out can strand another, so this runs to a fixed point.\n */\nfunction omissions<TData, TLayer extends string, TPose>(\n  src: readonly Item<TData, TLayer, TPose>[],\n  fns: ReadonlyMap<string, Record<string, unknown>>,\n): Map<string, PasteOmission> {\n  const out = new Map<string, PasteOmission>();\n  const present = new Set(src.map((item) => item.id as string));\n  for (let changed = true; changed;) {\n    changed = false;\n    for (const item of src) {\n      if (out.has(item.id)) continue;\n      let omission: PasteOmission | undefined;\n      const deps = dependencyList(item);\n      const missing = deps.filter((dep) => !present.has(dep));\n      const fn = fns.get(item.id)!;\n      if (item.parent !== null && out.has(item.parent)) {\n        omission = { id: item.id, reason: 'container-not-pasted' };\n      } else if (missing.length > 0) {\n        omission = { id: item.id, reason: 'dependency-not-copied', missing };\n      } else if (deps.length > 0 && fn.derivePath === undefined && fn.derivePose === undefined) {\n        omission = { id: item.id, reason: 'derivation-not-registered' };\n      }\n      if (omission === undefined) continue;\n      out.set(item.id, omission);\n      present.delete(item.id);\n      changed = true;\n    }\n  }\n  return out;\n}\n\nexport function pasteSceneSnapshot<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  clipboard: ClipboardSnapshot,\n  offset: { dx: number; dy: number },\n  ctx?: PasteCtx,\n): Node<TData, TLayer, TPose>[] {\n  const all = clipboard.items as Item<TData, TLayer, TPose>[];\n  if (all.length === 0) return [];\n  const fns = new Map(all.map((item) => [item.id as string, restoredFnFields(env.scene, item)]));\n  const omitted = omissions(all, fns);\n  if (ctx?.onOmit) for (const item of all) {\n    const omission = omitted.get(item.id);\n    if (omission) ctx.onOmit(omission);\n  }\n  const src = omitted.size === 0 ? all : all.filter((item) => !omitted.has(item.id));\n\n  const idMap = new Map<string, NodeId>();\n  for (const item of src) idMap.set(item.id, env.scene.mintId());\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 as string, item]));\n  const ridesPastedFrame = (item: Node<TData, TLayer, TPose>): boolean => {\n    if (!env.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  // Without composition poses are absolute, so the delta applies to EVERY\n  // pasted node.\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 = env.poseBounds(item.pose, item);\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  // `src` is parents-before-children and this keeps it, so children re-attach\n  // to freshly inserted parents when the caller's InsertOps apply in order.\n  return src.map((item) => ({\n    id: idMap.get(item.id)!,\n    kind: item.kind,\n    layer: item.layer,\n    parent: isRoot(item) ? null : idMap.get(item.parent as string)!,\n    pose: ridesPastedFrame(item)\n      ? copyField(item.pose)\n      : env.translate(copyField(item.pose), dx, dy, item),\n    data: copyField(item.data),\n    ...statedFields(item),\n    ...(item.kind === 'container'\n      ? { children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)!) }\n      : {}),\n    ...(item.dependsOn === 'children'\n      ? { dependsOn: 'children' as const }\n      : dependencyList(item).length > 0\n        ? { dependsOn: dependencyList(item).map((dep) => idMap.get(dep)!) }\n        : {}),\n    ...fns.get(item.id),\n  } as Node<TData, TLayer, TPose>));\n}\n"],"mappings":"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"}
+{"version":3,"file":"sceneClipboard.js","names":[],"sources":["../../src/canvas/sceneClipboard.ts"],"sourcesContent":["/**\n * The scene adapter's clipboard seam: what a copy captures and what a paste\n * mints from it.\n *\n * `pasteSceneSnapshot` is a pure factory — it mints fresh nodes and never\n * touches the scene. Insertion happens through the caller's InsertOps (one per\n * created node, parents before children).\n *\n * A snapshot item carries its node's function fields twice: live, for a paste\n * in the same session, and as the scene's registry keys, for a snapshot that\n * crossed JSON on the way back.\n */\nimport type { ClipboardSnapshot, PasteCtx, PasteOmission } from 'core/adapters/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport {\n  NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, type FnBearingNode,\n} from 'core/scene/nodeFnFields';\nimport { statedFields } from 'core/scene/statedFields';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\n\n/** What the seam needs from the adapter it serves. */\nexport interface SceneClipboardEnv<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Whether a stored pose is relative to its container's frame. */\n  composes: boolean;\n  worldPoseOf(id: string): TPose;\n  /** The nearest frame-defining container at or above `id`. */\n  frameAtOrAbove(id: string | null): string | null;\n  poseBounds(pose: TPose, node: unknown): Bounds;\n  translate(pose: TPose, dx: number, dy: number, node?: unknown): TPose;\n}\n\n// Spread-level copy per the clipboard contract: mutating a snapshot's\n// 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\ntype Item<TData, TLayer extends string, TPose> =\n  Node<TData, TLayer, TPose> & Record<string, unknown>;\n\nconst dependencyList = (item: { dependsOn?: readonly NodeId[] | 'children' }): readonly NodeId[] =>\n  (Array.isArray(item.dependsOn) ? item.dependsOn : []);\n\nexport function snapshotSceneSelection<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  ids: string[],\n): ClipboardSnapshot {\n  const { scene } = env;\n  const fnFields = createNodeFnFields<TPose>(scene.registry as never);\n  const idSet = new Set(ids);\n  const taken = new Set<string>();\n  const items: Node<TData, TLayer, TPose>[] = [];\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 (!env.composes) return n.pose;\n    if (isRoot) return env.worldPoseOf(n.id);\n    const frame = env.frameAtOrAbove(n.parent);\n    return frame !== null && taken.has(frame) ? n.pose : env.worldPoseOf(n.id);\n  };\n\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  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    items.push({\n      kind: n.kind,\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.kind === 'container' ? { children: [...n.children] } : {}),\n      ...statedFields(n),\n      ...(n.dependsOn !== undefined ? { dependsOn: copyField(n.dependsOn) } : {}),\n      ...fnFieldsOfNode(n),\n      ...fnKeysOf(fnFields, n as unknown as FnBearingNode, 'jsonKey'),\n    } as Node<TData, TLayer, TPose>);\n    if (n.kind === 'container') {\n      for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);\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\n// JSON drops a function, and turns a layout strategy into an object with no\n// methods on it: neither is something a pasted node can run.\nconst isLive = (value: unknown): boolean =>\n  typeof value === 'function'\n  || (typeof value === 'object' && value !== null\n    && Object.values(value).some((member) => typeof member === 'function'));\n\n/**\n * The item's function fields: for each, what its registry key names in this\n * scene, else the live one it carries, else nothing.\n */\nfunction restoredFnFields<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  item: Item<TData, TLayer, TPose>,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  const registry = scene.registry as Record<string, Record<string, unknown> | undefined>;\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && item.kind !== 'container') continue;\n    const key = item[spec.jsonKey];\n    const registered = typeof key === 'string' ? registry[spec.field]?.[key] : undefined;\n    const fn = registered ?? (isLive(item[spec.field]) ? item[spec.field] : undefined);\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out;\n}\n\n/**\n * Which items a paste leaves out, and why. A node deriving from an id list is\n * pasted only with everything it depends on, since a copy still naming the\n * originals would follow them rather than the copies beside it; and only with\n * a derivation to run, since without one it is a placeholder that paints\n * nothing. Leaving one out can strand another, so this runs to a fixed point.\n */\nfunction omissions<TData, TLayer extends string, TPose>(\n  src: readonly Item<TData, TLayer, TPose>[],\n  fns: ReadonlyMap<string, Record<string, unknown>>,\n): Map<string, PasteOmission> {\n  const out = new Map<string, PasteOmission>();\n  const present = new Set(src.map((item) => item.id as string));\n  for (let changed = true; changed;) {\n    changed = false;\n    for (const item of src) {\n      if (out.has(item.id)) continue;\n      let omission: PasteOmission | undefined;\n      const deps = dependencyList(item);\n      const missing = deps.filter((dep) => !present.has(dep));\n      const fn = fns.get(item.id)!;\n      if (item.parent !== null && out.has(item.parent)) {\n        omission = { id: item.id, reason: 'container-not-pasted' };\n      } else if (missing.length > 0) {\n        omission = { id: item.id, reason: 'dependency-not-copied', missing };\n      } else if (deps.length > 0 && fn.derivePath === undefined && fn.derivePose === undefined) {\n        omission = { id: item.id, reason: 'derivation-not-registered' };\n      }\n      if (omission === undefined) continue;\n      out.set(item.id, omission);\n      present.delete(item.id);\n      changed = true;\n    }\n  }\n  return out;\n}\n\nexport function pasteSceneSnapshot<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  clipboard: ClipboardSnapshot,\n  offset: { dx: number; dy: number },\n  ctx?: PasteCtx,\n): Node<TData, TLayer, TPose>[] {\n  const all = clipboard.items as Item<TData, TLayer, TPose>[];\n  if (all.length === 0) return [];\n  const fns = new Map(all.map((item) => [item.id as string, restoredFnFields(env.scene, item)]));\n  const omitted = omissions(all, fns);\n  if (ctx?.onOmit) for (const item of all) {\n    const omission = omitted.get(item.id);\n    if (omission) ctx.onOmit(omission);\n  }\n  const src = omitted.size === 0 ? all : all.filter((item) => !omitted.has(item.id));\n\n  const idMap = new Map<string, NodeId>();\n  for (const item of src) idMap.set(item.id, env.scene.mintId());\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 as string, item]));\n  const ridesPastedFrame = (item: Node<TData, TLayer, TPose>): boolean => {\n    if (!env.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  // Without composition poses are absolute, so the delta applies to EVERY\n  // pasted node.\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 = env.poseBounds(item.pose, item);\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  // `src` is parents-before-children and this keeps it, so children re-attach\n  // to freshly inserted parents when the caller's InsertOps apply in order.\n  return src.map((item) => ({\n    id: idMap.get(item.id)!,\n    kind: item.kind,\n    layer: item.layer,\n    parent: isRoot(item) ? null : idMap.get(item.parent as string)!,\n    pose: ridesPastedFrame(item)\n      ? copyField(item.pose)\n      : env.translate(copyField(item.pose), dx, dy, item),\n    data: copyField(item.data),\n    ...statedFields(item),\n    ...(item.kind === 'container'\n      ? { children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)!) }\n      : {}),\n    ...(item.dependsOn === 'children'\n      ? { dependsOn: 'children' as const }\n      : dependencyList(item).length > 0\n        ? { dependsOn: dependencyList(item).map((dep) => idMap.get(dep)!) }\n        : {}),\n    ...fns.get(item.id),\n  } as Node<TData, TLayer, TPose>));\n}\n"],"mappings":"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"}

package/dist/canvas/sceneLayerPaint.js

@@ -1,37 +1,66 @@
-import { paintedLayers as e } from "../core/layers/render.js";
+import { paintedLayers } from "../core/layers/render.js";
+
 //#region src/canvas/sceneLayerPaint.ts
-function t(e) {
-	return `scene:${e}`;
+/**
+* Which scene layers a view paints.
+*
+* A view's `layerVisibility` / `layerOrder` name render layers, and `<Canvas>`
+* paints a scene as one render layer per scene layer, keyed `scene:<layerId>`.
+* Picking, marquee and select-all ask about scene layers, so this is where one
+* namespace is read in terms of the other.
+*/
+/** The render-layer id a scene layer paints under. */
+function sceneLayerKey(layerId) {
+	return `scene:${layerId}`;
 }
-function n(t, n) {
-	let r = n.layers ? n.layers(t) : t;
-	return e(r, n.layerVisibility ?? {}, n.layerOrder);
+/** The layers a view draws, in the order it draws them: what `drawLayers`
+*  would paint of whatever `layers` narrowed to. */
+function viewPaintedLayers(surface, view) {
+	const narrowed = view.layers ? view.layers(surface) : surface;
+	return paintedLayers(narrowed, view.layerVisibility ?? {}, view.layerOrder);
 }
-function r() {
-	let e = null;
-	return (r, i) => {
-		let a = [
-			r,
-			i.layers,
-			i.layerVisibility,
-			i.layerOrder
+/**
+* A gate answering "does this scene layer reach the screen in this view",
+* rebuilt only when the surface's stack or the view's settings change — it is
+* asked once per pick candidate.
+*
+* A scene layer is painted when the render layer carrying it is: its own
+* `scene:<id>`, or the bundled `scene` layer an adapter without layers gets.
+* A surface carrying neither paints the scene some other way, which is not
+* this gate's to judge, so it passes.
+*/
+function createSceneLayerGate() {
+	let last = null;
+	return (surface, view) => {
+		const inputs = [
+			surface,
+			view.layers,
+			view.layerVisibility,
+			view.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);
+		if (last && last.inputs.every((v, i) => v === inputs[i])) return last.gate;
+		const byId = new Map(surface.map((l) => [l.id, l]));
+		const drawn = new Set(viewPaintedLayers(surface, view));
+		const gate = (layerId) => {
+			const carrier = byId.get(sceneLayerKey(layerId)) ?? byId.get("scene");
+			return carrier === void 0 || drawn.has(carrier);
+		};
+		last = {
+			inputs,
+			gate
 		};
-		return e = {
-			inputs: a,
-			gate: c
-		}, c;
+		return gate;
 	};
 }
-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);
+/** Scene layers in the order a view paints them, for a view that walks the
+*  scene itself rather than a render-layer stack. Keyed as `<SceneCanvas>`
+*  keys them, so one map serves both. */
+function paintedSceneLayers(layers, view) {
+	const { layerVisibility, layerOrder } = view;
+	if (layerVisibility === void 0 && layerOrder === void 0) return layers;
+	return (layerOrder ? layerOrder.map((key) => layers.find((l) => sceneLayerKey(l.id) === key)).filter((l) => l !== void 0) : layers).filter((l) => layerVisibility?.[sceneLayerKey(l.id)] !== false);
 }
-//#endregion
-export { r as createSceneLayerGate, i as paintedSceneLayers, t as sceneLayerKey, n as viewPaintedLayers };
 
+//#endregion
+export { createSceneLayerGate, paintedSceneLayers, sceneLayerKey, viewPaintedLayers };
 //# sourceMappingURL=sceneLayerPaint.js.map

package/dist/canvas/sceneLayerPaint.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneLayerPaint.js","names":["sceneLayerKey","layerId","viewPaintedLayers","narrowed","view","surface","paintedLayers","createSceneLayerGate","last","inputs","v","i","byId","l","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 { paintedLayers, 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: what `drawLayers`\n *  would paint of whatever `layers` narrowed to. */\nexport function viewPaintedLayers(\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n): readonly RenderLayer<unknown>[] {\n  const narrowed = view.layers ? view.layers(surface) : surface;\n  return paintedLayers(narrowed, view.layerVisibility ?? {}, view.layerOrder);\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(viewPaintedLayers(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;CACtD,OAAOC,EAAcH,GAAUC,EAAK,mBAAmB,CAAC,GAAGA,EAAK,UAAU;AAC5E;AAYA,SAAgBG,IAGkB;CAChC,IAAIC,IAAkF;CACtF,QAAQ,GAAS,MAAS;EACxB,IAAMC,IAAS;GAACJ;GAASD,EAAK;GAAQA,EAAK;GAAiBA,EAAK;EAAU;EAC3E,IAAII,KAAQA,EAAK,OAAO,OAAO,GAAG,MAAME,MAAMD,EAAOE,EAAE,GAAG,OAAOH,EAAK;EACtE,IAAMI,IAAO,IAAI,IAAIP,EAAQ,KAAK,MAAM,CAACQ,EAAE,IAAIA,CAAC,CAAC,CAAC,GAC5CC,IAAQ,IAAI,IAAIZ,EAAkBG,GAASD,CAAI,CAAC,GAChDW,KAAQ,MAA6B;GACzC,IAAMC,IAAUJ,EAAK,IAAIZ,EAAcC,CAAO,CAAC,KAAKW,EAAK,IAAI,OAAO;GACpE,OAAOI,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,kBAAeb;CAOxC,OANIc,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAkBC,KACrDD,IACbA,EACC,KAAK,MAAQC,EAAO,MAAM,MAAMpB,EAAca,EAAE,EAAE,MAAMQ,CAAG,CAAC,CAAC,CAC7D,QAAQ,MAAcR,MAAM,KAAA,CAAS,IACtCO,EAAA,CACY,QAAQ,MAAMF,IAAkBlB,EAAca,EAAE,EAAE,OAAO,EAAK;AAChF"}
+{"version":3,"file":"sceneLayerPaint.js","names":[],"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 { paintedLayers, 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: what `drawLayers`\n *  would paint of whatever `layers` narrowed to. */\nexport function viewPaintedLayers(\n  surface: readonly RenderLayer<unknown>[],\n  view: ViewLayerPaint,\n): readonly RenderLayer<unknown>[] {\n  const narrowed = view.layers ? view.layers(surface) : surface;\n  return paintedLayers(narrowed, view.layerVisibility ?? {}, view.layerOrder);\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(viewPaintedLayers(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,SAAgB,cAAc,SAAyB;CACrD,OAAO,SAAS;AAClB;;;AAYA,SAAgB,kBACd,SACA,MACiC;CACjC,MAAM,WAAW,KAAK,SAAS,KAAK,OAAO,OAAO,IAAI;CACtD,OAAO,cAAc,UAAU,KAAK,mBAAmB,CAAC,GAAG,KAAK,UAAU;AAC5E;;;;;;;;;;;AAYA,SAAgB,uBAGkB;CAChC,IAAI,OAAkF;CACtF,QAAQ,SAAS,SAAS;EACxB,MAAM,SAAS;GAAC;GAAS,KAAK;GAAQ,KAAK;GAAiB,KAAK;EAAU;EAC3E,IAAI,QAAQ,KAAK,OAAO,OAAO,GAAG,MAAM,MAAM,OAAO,EAAE,GAAG,OAAO,KAAK;EACtE,MAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;EAClD,MAAM,QAAQ,IAAI,IAAI,kBAAkB,SAAS,IAAI,CAAC;EACtD,MAAM,QAAQ,YAA6B;GACzC,MAAM,UAAU,KAAK,IAAI,cAAc,OAAO,CAAC,KAAK,KAAK,IAAI,OAAO;GACpE,OAAO,YAAY,UAAa,MAAM,IAAI,OAAO;EACnD;EACA,OAAO;GAAE;GAAQ;EAAK;EACtB,OAAO;CACT;AACF;;;;AAKA,SAAgB,mBACd,QACA,MACc;CACd,MAAM,EAAE,iBAAiB,eAAe;CACxC,IAAI,oBAAoB,UAAa,eAAe,QAAW,OAAO;CAMtE,QALiB,aACb,WACC,KAAK,QAAQ,OAAO,MAAM,MAAM,cAAc,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,CAC7D,QAAQ,MAAc,MAAM,MAAS,IACtC,OACG,CAAS,QAAQ,MAAM,kBAAkB,cAAc,EAAE,EAAE,OAAO,KAAK;AAChF"}

package/dist/canvas/sceneSlotWiring.js

@@ -1,20 +1,31 @@
-import { sceneDerivedPathOf as e, withDerivedPaths as t } from "./derivedPath.js";
-import { withColorOverrides as n } from "./colorOverrides.js";
+import { sceneDerivedPathOf, sceneShownToPose, withDerivedPaths } from "./derivedPath.js";
+import { withColorOverrides } from "./colorOverrides.js";
+
 //#region src/canvas/sceneSlotWiring.ts
-function r(e, t) {
-	let n = (t) => e.overrides.read(t)?.alpha ?? 1;
-	return t ? (e) => t(e) * n(e) : n;
+/**
+* The alpha a view paints a node at: the view's own `alphaFor` times any
+* ephemeral override alpha.
+*
+* The hit path asks this too — a node painted at alpha 0 is not on screen and
+* must not claim clicks — so it is one function rather than the painter's and
+* picking's separate readings of the same two inputs.
+*/
+function composeAlphaFor(scene, alphaFor) {
+	const overrideAlphaFor = (id) => scene.overrides.read(id)?.alpha ?? 1;
+	return alphaFor ? (id) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;
 }
-function i(i, a, o, s) {
-	let c = t(a, i.drawOne, i.toPose), l = e(a, i.toPose);
+function wireSceneSlotToScene(slot, scene, alphaFor, colorOverrides) {
+	const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);
+	const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);
 	return {
-		...i,
-		drawOne: s ? n(s, c) : c,
-		derivedPathOf: l,
-		alphaFor: r(a, o)
+		...slot,
+		...slot.toPose ? { toPose: sceneShownToPose(scene, slot.toPose) } : {},
+		drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,
+		derivedPathOf,
+		alphaFor: composeAlphaFor(scene, alphaFor)
 	};
 }
-//#endregion
-export { r as composeAlphaFor, i as wireSceneSlotToScene };
 
+//#endregion
+export { composeAlphaFor, wireSceneSlotToScene };
 //# sourceMappingURL=sceneSlotWiring.js.map

package/dist/canvas/sceneSlotWiring.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneSlotWiring.js","names":["composeAlphaFor","overrideAlphaFor","scene","id","alphaFor","wireSceneSlotToScene","derived","withDerivedPaths","slot","derivedPathOf","sceneDerivedPathOf","colorOverrides","withColorOverrides"],"sources":["../../src/canvas/sceneSlotWiring.ts"],"sourcesContent":["/**\n * What the scene slot needs from the `Scene` that `<Canvas>` cannot see.\n *\n * `<Canvas>` is scene-agnostic: it walks an adapter. Three things a node is\n * painted with are therefore invisible to it — an ephemeral override's alpha, a\n * derived path, which needs other nodes' poses to resolve, and animated vertex\n * colors, which live in an animator. `<SceneCanvas>` folds them into the slot\n * here; `buildSceneViewCommands` does the same for the headless walk.\n */\nimport type { SceneSlotConfig } from './buildSceneLayer';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\n\n/**\n * The alpha a view paints a node at: the view's own `alphaFor` times any\n * ephemeral override alpha.\n *\n * The hit path asks this too — a node painted at alpha 0 is not on screen and\n * must not claim clicks — so it is one function rather than the painter's and\n * picking's separate readings of the same two inputs.\n */\nexport function composeAlphaFor<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n): (id: string) => number {\n  const overrideAlphaFor = (id: string) => scene.overrides.read(id as NodeId)?.alpha ?? 1;\n  return alphaFor ? (id: string) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;\n}\n\nexport function wireSceneSlotToScene<TData, TLayer extends string, TPose>(\n  slot: SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n  colorOverrides?: ColorOverrideRegistry,\n): SceneSlotConfig<Node<TData, TLayer, TPose>, TPose> {\n  const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);\n  const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);\n  return {\n    ...slot,\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;AAuBA,SAAgBA,EACd,GACA,GACwB;CACxB,IAAMC,KAAoB,MAAeC,EAAM,UAAU,KAAKC,CAAY,CAAC,EAAE,SAAS;CACtF,OAAOC,KAAY,MAAeA,EAASD,CAAE,IAAIF,EAAiBE,CAAE,IAAIF;AAC1E;AAEA,SAAgBI,EACd,GACA,GACA,GACA,GACoD;CACpD,IAAMC,IAAUC,EAAiBL,GAAOM,EAAK,SAASA,EAAK,MAAM,GAC3DC,IAAgBC,EAAmBR,GAAOM,EAAK,MAAM;CAC3D,OAAO;EACL,GAAGA;EACH,SAASG,IAAiBC,EAAmBD,GAAgBL,CAAO,IAAIA;EACxE;EACA,UAAUN,EAAgBE,GAAOE,CAAQ;CAC3C;AACF"}
+{"version":3,"file":"sceneSlotWiring.js","names":[],"sources":["../../src/canvas/sceneSlotWiring.ts"],"sourcesContent":["/**\n * What the scene slot needs from the `Scene` that `<Canvas>` cannot see.\n *\n * `<Canvas>` is scene-agnostic: it walks an adapter. Three things a node is\n * painted with are therefore invisible to it — an ephemeral override's alpha, a\n * derived path, which needs other nodes' poses to resolve, and animated vertex\n * colors, which live in an animator. `<SceneCanvas>` folds them into the slot\n * here; `buildSceneViewCommands` does the same for the headless walk.\n */\nimport type { SceneSlotConfig } from './buildSceneLayer';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf, sceneShownToPose } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\n\n/**\n * The alpha a view paints a node at: the view's own `alphaFor` times any\n * ephemeral override alpha.\n *\n * The hit path asks this too — a node painted at alpha 0 is not on screen and\n * must not claim clicks — so it is one function rather than the painter's and\n * picking's separate readings of the same two inputs.\n */\nexport function composeAlphaFor<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n): (id: string) => number {\n  const overrideAlphaFor = (id: string) => scene.overrides.read(id as NodeId)?.alpha ?? 1;\n  return alphaFor ? (id: string) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;\n}\n\nexport function wireSceneSlotToScene<TData, TLayer extends string, TPose>(\n  slot: SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n  colorOverrides?: ColorOverrideRegistry,\n): SceneSlotConfig<Node<TData, TLayer, TPose>, TPose> {\n  const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);\n  const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);\n  return {\n    ...slot,\n    ...(slot.toPose ? { toPose: sceneShownToPose(scene, slot.toPose) } : {}),\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAuBA,SAAgB,gBACd,OACA,UACwB;CACxB,MAAM,oBAAoB,OAAe,MAAM,UAAU,KAAK,EAAY,CAAC,EAAE,SAAS;CACtF,OAAO,YAAY,OAAe,SAAS,EAAE,IAAI,iBAAiB,EAAE,IAAI;AAC1E;AAEA,SAAgB,qBACd,MACA,OACA,UACA,gBACoD;CACpD,MAAM,UAAU,iBAAiB,OAAO,KAAK,SAAS,KAAK,MAAM;CACjE,MAAM,gBAAgB,mBAAmB,OAAO,KAAK,MAAM;CAC3D,OAAO;EACL,GAAG;EACH,GAAI,KAAK,SAAS,EAAE,QAAQ,iBAAiB,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC;EACtE,SAAS,iBAAiB,mBAAmB,gBAAgB,OAAO,IAAI;EACxE;EACA,UAAU,gBAAgB,OAAO,QAAQ;CAC3C;AACF"}

package/dist/canvas/sceneViewRender.js

@@ -1,72 +1,102 @@
-import { composesFrames as e } from "../core/scene/composeFrame.js";
-import { effectivePose as t } from "../core/scene/effectivePose.js";
-import { paintedSceneLayers as n } from "./sceneLayerPaint.js";
-import { paintCanvas as r } from "./canvasRenderer.js";
-import { wrapNodeOutput as i } from "./wrapNodeOutput.js";
-import { sceneDerivedPathOf as a, withDerivedPaths as o } from "./derivedPath.js";
-import { buildSceneTree as s } from "./buildSceneTree.js";
-import { withColorOverrides as c } from "./colorOverrides.js";
-import { paintMissesView as l } from "./paintCull.js";
-import { paintBoundsFor as u } from "./defaultDrawOne.js";
-import { cullDrawCommands as d } from "@weasel-js/renderer";
-import { viewToMat3 as f } from "@weasel-js/geom";
+import { paintedSceneLayers } from "./sceneLayerPaint.js";
+import { paintCanvas } from "./canvasRenderer.js";
+import { wrapNodeOutput } from "./wrapNodeOutput.js";
+import { sceneDerivedPathOf, withDerivedPaths } from "./derivedPath.js";
+import { buildSceneTree } from "./buildSceneTree.js";
+import { sceneToAdapter } from "./sceneAdapter.js";
+import { withColorOverrides } from "./colorOverrides.js";
+import { paintMissesView } from "./paintCull.js";
+import { paintBoundsFor } from "./defaultDrawOne.js";
+import { cullDrawCommands } from "@weasel-js/renderer";
+import { viewToMat3 as viewToMat3$1 } from "@weasel-js/geom";
+
 //#region src/canvas/sceneViewRender.ts
-function p(e, r = {}) {
+/**
+* Present a `Scene` as the reading surface `buildSceneTree` walks: the scene
+* adapter's own reads, under this view's layer list.
+*/
+function sceneAsHierarchy(scene, layers = {}) {
+	const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);
 	return {
-		getLayers: () => n(e.layers, r).map((e) => ({
-			id: e.id,
-			visible: e.visible,
-			parallax: e.parallax
+		getLayers: () => paintedSceneLayers(scene.layers, layers).map((l) => ({
+			id: l.id,
+			visible: l.visible,
+			parallax: l.parallax
 		})),
-		getNode: (t) => e.get(t),
-		getChildren: (t) => {
-			if (t === null) return e.roots;
-			let n = e.get(t);
-			return n && n.kind === "container" ? n.children : [];
-		},
-		getPose: (n) => t(e, e.get(n))
+		getNode,
+		getChildren,
+		getPose,
+		...composePose ? { composePose } : {}
 	};
 }
-function m(t, n, r, u, m, h, g, _) {
-	let v = o(t, r), y = g ? c(g, v) : v, b = a(t), x = (e, n, r) => {
-		let a = t.overrides.read(e.id)?.alpha ?? 1;
-		return i(y(e, n, r), n, (m ? m(e.id) : 1) * a);
-	}, S = e(t.composition) ? {
-		...p(t, h),
-		composePose: t.composition.compose
-	} : p(t, h), C = _ ? {
+/**
+* Build the DrawCommand list that `renderSceneToCanvas` would dispatch, in
+* screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,
+* the same walk `<SceneCanvas>` uses, which is what keeps hidden layers
+* unpainted and container clips applied here.
+*
+* Each node's commands go through `wrapNodeOutput` — pose rotation, then the
+* `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates
+* twice; emit unrotated geometry and let the pose drive it.
+*
+* Output is one group per **visible** layer, in scene-layer order (or
+* `layers.layerOrder`), each holding one group per node on that layer.
+*/
+function buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor, layers, colorOverrides, cull) {
+	const derivedOnly = withDerivedPaths(scene, drawOne);
+	const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;
+	const derivedPathOf = sceneDerivedPathOf(scene);
+	const wrappedDrawOne = (node, pose, v) => {
+		const overrideAlpha = scene.overrides.read(node.id)?.alpha ?? 1;
+		return wrapNodeOutput(derived(node, pose, v), pose, (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha);
+	};
+	const hierarchy = sceneAsHierarchy(scene, layers);
+	const cullRect = cull ? {
 		x: 0,
 		y: 0,
-		width: _.width,
-		height: _.height
-	} : void 0, w = C && _?.paintBounds ? l(_.paintBounds, n, C) : void 0, T = s(S, x, n, void 0, b, w), E = C ? d(T, f(n), C) : T;
-	if (u && u.length > 0) for (let e of u) E.push(e);
+		width: cull.width,
+		height: cull.height
+	} : void 0;
+	const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : void 0;
+	const tree = buildSceneTree(hierarchy, wrappedDrawOne, view, void 0, derivedPathOf, culled);
+	const children = cullRect ? cullDrawCommands(tree, viewToMat3$1(view), cullRect) : tree;
+	if (extraCommands && extraCommands.length > 0) for (const cmd of extraCommands) children.push(cmd);
 	return [{
 		kind: "group",
-		transform: f(n),
-		children: E
+		transform: viewToMat3$1(view),
+		children
 	}];
 }
-function h(e) {
-	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: o, alphaFor: s, layerVisibility: c, layerOrder: l, colorOverrides: d, cull: f } = e;
-	return m(t, n, a, o, s, {
-		layerVisibility: c,
-		layerOrder: l
-	}, d, f ? {
-		width: r,
-		height: i,
-		paintBounds: e.paintBounds ?? u(a)
+/**
+* The commands `renderSceneToCanvas` paints for one frame — everything in
+* `args` but the canvas. `<SceneViewCanvas>` paints these through its own
+* renderer lease.
+*/
+function sceneViewFrame(args) {
+	const { scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder, colorOverrides, cull } = args;
+	return buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor, {
+		layerVisibility,
+		layerOrder
+	}, colorOverrides, cull ? {
+		width,
+		height,
+		paintBounds: args.paintBounds ?? paintBoundsFor(drawOne)
 	} : void 0);
 }
-function g(e) {
-	let { canvas: t, view: n, width: i, height: a, dpr: o } = e;
-	r(t, h(e), n, {
-		width: i,
-		height: a,
-		dpr: o
+/**
+* Render one frame of `scene` at `view` into `canvas`. Where no WebGL2
+* context is available (jsdom) the call paints nothing. The canvas's renderer
+* lives until `releaseCanvasRenderer(canvas)`.
+*/
+function renderSceneToCanvas(args) {
+	const { canvas, view, width, height, dpr } = args;
+	paintCanvas(canvas, sceneViewFrame(args), view, {
+		width,
+		height,
+		dpr
 	});
 }
-//#endregion
-export { m as buildSceneViewCommands, g as renderSceneToCanvas, h as sceneViewFrame };
 
+//#endregion
+export { buildSceneViewCommands, renderSceneToCanvas, sceneViewFrame };
 //# sourceMappingURL=sceneViewRender.js.map

package/dist/canvas/sceneViewRender.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneViewRender.js","names":["viewToMat3","viewToMat3$1","sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","composesFrames","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","children","cullDrawCommands","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n */\n\nimport type { WeaselRenderer } from '@weasel-js/renderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport { composesFrames } from 'core/scene/composePose';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '@weasel-js/renderer';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The first call on a given canvas creates\n   *  its renderer and later calls reuse it;\n   *  `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene and `extraCommands` alike. */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; the element's CSS size is the caller's to set. */\n  width: number;\n  height: number;\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Commands appended after the scene-node output, wrapped in the same view\n   *  transform as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Device-pixel ratio. Defaults to `window.devicePixelRatio || 1` when\n   *  available, otherwise 1. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks. Built\n * inline rather than via `sceneToAdapter` so this module stays free of React\n * — `renderSceneToPixels` runs headless.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode: (id) => scene.get(id as NodeId),\n    getChildren: (parentId) => {\n      if (parentId === null) return scene.roots as readonly string[];\n      const node = scene.get(parentId as NodeId);\n      return node && node.kind === 'container' ? (node.children as readonly string[]) : [];\n    },\n    getPose: (id) => effectivePose(scene, scene.get(id as NodeId)!),\n  } as HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch, in\n * screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,\n * the same walk `<SceneCanvas>` uses, which is what keeps hidden layers\n * unpainted and container clips applied here.\n *\n * Each node's commands go through `wrapNodeOutput` — pose rotation, then the\n * `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates\n * twice; emit unrotated geometry and let the pose drive it.\n *\n * Output is one group per **visible** layer, in scene-layer order (or\n * `layers.layerOrder`), each holding one group per node on that layer.\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(scene);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const hierarchy = composesFrames(scene.composition)\n    ? { ...sceneAsHierarchy(scene, layers), composePose: scene.composition.compose }\n    : sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    derivedPathOf as unknown as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. Where no WebGL2\n * context is available (jsdom) the call paints nothing. The canvas's renderer\n * lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;;AAsGA,SAASE,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,OAAO;EACL,iBACEC,EAAmBC,EAAM,QAAQC,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE,UAAU,MAAOF,EAAM,IAAIG,CAAY;EACvC,cAAc,MAAa;GACzB,IAAIC,MAAa,MAAM,OAAOJ,EAAM;GACpC,IAAMK,IAAOL,EAAM,IAAII,CAAkB;GACzC,OAAOC,KAAQA,EAAK,SAAS,cAAeA,EAAK,WAAiC,CAAC;EACrF;EACA,UAAU,MAAOC,EAAcN,GAAOA,EAAM,IAAIG,CAAY,CAAE;CAChE;AACF;AAeA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAEA,GAEA,GAGA,GACe;CACf,IAAMC,IAAcC,EAAiBT,GAAOU,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAgBC,EAAmBf,CAAK,GACxCgB,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBjB,EAAM,UAAU,KAAKK,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOa,EACLP,EAAQN,GAAMc,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAAShB,EAAK,EAAE,IAAI,KAAKY,CACvC;CACF,GAEMK,IAAYC,EAAevB,EAAM,WAAW,IAC9C;EAAE,GAAGF,EAAiBE,GAAOC,CAAM;EAAG,aAAaD,EAAM,YAAY;CAAQ,IAC7EF,EAAiBE,GAAOC,CAAM,GAE5BuB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BR,GACAN,GACAY,GACA,KAAA,GACAd,GACAY,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAMjC,EAAWgC,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAII,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWtC,EAAWgC,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBO,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO7B,EACLP,GAAO4B,GAAMlB,GAASuB,GAAeZ,GAAU;EAAE;EAAiB;CAAW,GAAGT,GAChFa,IAAO;EAAE;EAAO;EAAQ,aAAaW,EAAK,eAAeC,EAAe3B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAOA,SAAgB4B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGR,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}
+{"version":3,"file":"sceneViewRender.js","names":["viewToMat3"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n */\n\nimport type { WeaselRenderer } from '@weasel-js/renderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { sceneToAdapter } from './sceneAdapter';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '@weasel-js/renderer';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The first call on a given canvas creates\n   *  its renderer and later calls reuse it;\n   *  `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene and `extraCommands` alike. */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; the element's CSS size is the caller's to set. */\n  width: number;\n  height: number;\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Commands appended after the scene-node output, wrapped in the same view\n   *  transform as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Device-pixel ratio. Defaults to `window.devicePixelRatio || 1` when\n   *  available, otherwise 1. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks: the scene\n * adapter's own reads, under this view's layer list.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode,\n    getChildren,\n    getPose,\n    ...(composePose ? { composePose } : {}),\n  };\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch, in\n * screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,\n * the same walk `<SceneCanvas>` uses, which is what keeps hidden layers\n * unpainted and container clips applied here.\n *\n * Each node's commands go through `wrapNodeOutput` — pose rotation, then the\n * `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates\n * twice; emit unrotated geometry and let the pose drive it.\n *\n * Output is one group per **visible** layer, in scene-layer order (or\n * `layers.layerOrder`), each holding one group per node on that layer.\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(scene);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const hierarchy = sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    derivedPathOf as unknown as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. Where no WebGL2\n * context is available (jsdom) the call paints nothing. The canvas's renderer\n * lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoGA,SAAS,iBACP,OACA,SAA0B,CAAC,GAC6B;CACxD,MAAM,EAAE,SAAS,aAAa,SAAS,gBAAgB,eAAe,KAAK;CAC3E,OAAO;EACL,iBACE,mBAAmB,MAAM,QAAQ,MAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAI,EAAE;GAAI,SAAS,EAAE;GAAS,UAAU,EAAE;EAAS,EAAE;EACxE;EACA;EACA;EACA,GAAI,cAAc,EAAE,YAAY,IAAI,CAAC;CACvC;AACF;;;;;;;;;;;;;;AAeA,SAAgB,uBACd,OACA,MACA,SACA,eACA,UAEA,QAEA,gBAGA,MACe;CACf,MAAM,cAAc,iBAAiB,OAAO,OAAO;CACnD,MAAM,UAAU,iBAAiB,mBAAmB,gBAAgB,WAAW,IAAI;CACnF,MAAM,gBAAgB,mBAAmB,KAAK;CAC9C,MAAM,kBACJ,MACA,MACA,MACkB;EAClB,MAAM,gBAAgB,MAAM,UAAU,KAAK,KAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAO,eACL,QAAQ,MAAM,MAAM,CAAC,GACrB,OACC,WAAW,SAAS,KAAK,EAAE,IAAI,KAAK,aACvC;CACF;CAEA,MAAM,YAAY,iBAAiB,OAAO,MAAM;CAEhD,MAAM,WAAW,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO,KAAK;EAAO,QAAQ,KAAK;CAAO,IAAI;CACjF,MAAM,SAAS,YAAY,MAAM,cAAc,gBAAgB,KAAK,aAAa,MAAM,QAAQ,IAAI;CACnG,MAAM,OAAsB,eAC1B,WACA,gBACA,MACA,QACA,eACA,MACF;CACA,MAAM,WAAW,WAAW,iBAAiB,MAAMA,aAAW,IAAI,GAAG,QAAQ,IAAI;CACjF,IAAI,iBAAiB,cAAc,SAAS,GAC1C,KAAK,MAAM,OAAO,eAAe,SAAS,KAAK,GAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWA,aAAW,IAAI;EAC1B;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,eACd,MACe;CACf,MAAM,EACJ,OAAO,MAAM,OAAO,QAAQ,SAAS,eAAe,UAAU,iBAAiB,YAC/E,gBAAgB,SACd;CACJ,OAAO,uBACL,OAAO,MAAM,SAAS,eAAe,UAAU;EAAE;EAAiB;CAAW,GAAG,gBAChF,OAAO;EAAE;EAAO;EAAQ,aAAa,KAAK,eAAe,eAAe,OAAO;CAAE,IAAI,MACvF;AACF;;;;;;AAOA,SAAgB,oBACd,MACM;CACN,MAAM,EAAE,QAAQ,MAAM,OAAO,QAAQ,QAAQ;CAC7C,YAAY,QAAQ,eAAe,IAAI,GAAG,MAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/slopsDebugLayer.js

@@ -1,61 +1,70 @@
-import { pointRegionScreenQuad as e, transformOf as t } from "../affordances/hitAffordanceRegions.js";
-import { chromeStateFrom as n, isVisibleFrom as r } from "./drawEnvelope.js";
-import { PATH_L as i, PATH_M as a, PATH_Z as o } from "@weasel-js/geom";
+import { pointRegionLive, pointRegionScreenQuad, transformOf } from "../affordances/hitAffordanceRegions.js";
+import { chromeStateFrom, isVisibleFrom } from "./drawEnvelope.js";
+import { PATH_L, PATH_M, PATH_Z } from "@weasel-js/geom";
+
 //#region src/canvas/slopsDebugLayer.ts
-var s = "rgba(255, 80, 140, 0.18)", c = "rgba(255, 80, 140, 0.55)";
-function l(l) {
+var SLOP_FILL = "rgba(255, 80, 140, 0.18)";
+var SLOP_STROKE = "rgba(255, 80, 140, 0.55)";
+function createSlopsDebugLayer(opts) {
 	return {
 		id: "slops-debug",
 		label: "Slops (debug)",
 		space: "screen",
-		draw: (u, d) => {
-			let f = n(u);
-			if (!f) return [];
-			let p = r(u), m = (e, t) => [(e - d.x) * d.scale.x, (t - d.y) * d.scale.y], h = [];
-			for (let n of l.getAffordances()) if (!p || p(n.id)) for (let r of n.regions(f)) {
-				if (r.shape.kind !== "point") continue;
-				let n = e(r.shape, t(f, r.targetId), d, m);
-				h.push({
-					kind: "path",
-					path: {
-						kind: "polygon",
-						commands: new Uint8Array([
-							a,
-							i,
-							i,
-							i,
-							o
-						]),
-						coords: new Float32Array([
-							n[0].x,
-							n[0].y,
-							n[1].x,
-							n[1].y,
-							n[2].x,
-							n[2].y,
-							n[3].x,
-							n[3].y
-						]),
-						fillRule: "nonzero"
-					},
-					fill: { paint: {
-						kind: "solid",
-						color: s
-					} },
-					stroke: {
-						paint: {
-							kind: "solid",
-							color: c
+		draw: (data, view) => {
+			const chrome = chromeStateFrom(data);
+			if (!chrome) return [];
+			const isVisible = isVisibleFrom(data);
+			const toScreen = (x, y) => [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];
+			const out = [];
+			for (const a of opts.getAffordances()) {
+				if (isVisible && !isVisible(a.id)) continue;
+				for (const region of a.regions(chrome)) {
+					if (region.shape.kind !== "point") continue;
+					const xf = transformOf(chrome, region.targetId);
+					if (!pointRegionLive(region.shape, xf, view)) continue;
+					const q = pointRegionScreenQuad(region.shape, xf, view, toScreen);
+					out.push({
+						kind: "path",
+						path: {
+							kind: "polygon",
+							commands: new Uint8Array([
+								PATH_M,
+								PATH_L,
+								PATH_L,
+								PATH_L,
+								PATH_Z
+							]),
+							coords: new Float32Array([
+								q[0].x,
+								q[0].y,
+								q[1].x,
+								q[1].y,
+								q[2].x,
+								q[2].y,
+								q[3].x,
+								q[3].y
+							]),
+							fillRule: "nonzero"
 						},
-						width: 1
-					}
-				});
+						fill: { paint: {
+							kind: "solid",
+							color: SLOP_FILL
+						} },
+						stroke: {
+							paint: {
+								kind: "solid",
+								color: SLOP_STROKE
+							},
+							width: 1
+						}
+					});
+				}
 			}
-			return h;
+			return out;
 		}
 	};
 }
-//#endregion
-export { l as createSlopsDebugLayer };
 
+//#endregion
+export { createSlopsDebugLayer };
 //# sourceMappingURL=slopsDebugLayer.js.map