@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/adapterPickSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapterPickSource.js","names":["adapterPickSource","parents","worldPose","adapter","id","derived","adapterDerivedPathOf","nodeOf","out","next","visit","childId","parentId","node","parent","gates","chain","cur","seen"],"sources":["../../src/canvas/adapterPickSource.ts"],"sourcesContent":["import { adapterDerivedPathOf } from './adapterDerivedPath';\nimport type { AdapterPickGates, PickCandidate, PickSource } from './pickWalk';\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  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 * The adapter's tree is walked depth-first, parents before children — the\n * same back-to-front order `renderOrderNodes` produces for a single layer.\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  // 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 derived = adapterDerivedPathOf(adapter);\n  const nodeOf = (id: string): PickCandidate<TPose> => {\n    const raw = adapter.getNode(id) as Partial<PickCandidate<TPose>>;\n    return { ...raw, id, pose: worldPose(id) } as PickCandidate<TPose>;\n  };\n\n  return {\n    order() {\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 adapter.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    derivedPathOf: (node: PickCandidate<TPose>) => derived(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":";;AAsBA,SAAgBA,EACd,GACA,IAA0B,CAAC,GACR;CAGnB,IAAIC,oBAAU,IAAI,IAAkC,GAI9CC,KAAa,MAChB,OAAOC,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaC,CAAE,IAAID,EAAQ,QAAQC,CAAE,GAEvFC,IAAUC,EAAqBH,CAAO,GACtCI,KAAU,OAEP;EAAE,GADGJ,EAAQ,QAAQC,CAChB;EAAK;EAAI,MAAMF,EAAUE,CAAE;CAAE;CAG3C,OAAO;EACL,QAAQ;GACN,IAAMI,IAA8B,CAAC,GAC/BC,oBAAO,IAAI,IAAkC,GAC7CC,KAAS,GAAyB,MAA8C;IACpF,KAAK,IAAMC,KAAWR,EAAQ,YAAYS,CAAQ,GAAG;KACnD,IAAMC,IAAON,EAAOI,CAAO;KAG3B,AAFIG,KAAQL,EAAK,IAAIE,GAASG,CAAM,GACpCN,EAAI,KAAKK,CAAI,GACbH,EAAMC,GAASE,CAAI;IACrB;GACF;GAGA,OAFAH,EAAM,MAAM,IAAI,GAChB,IAAUD,GACHD;EACT;EACA,GAAIO,EAAM,UAAU,EAAE,SAASA,EAAM,QAAQ,IAAI,CAAC;EAClD,GAAIA,EAAM,iBAAiB,EAAE,gBAAgBA,EAAM,eAAe,IAAI,CAAC;EACvE,GAAIA,EAAM,UAAU,EAAE,SAASA,EAAM,QAAQ,IAAI,CAAC;EAClD,SAAS,MAASb,EAAUW,EAAK,EAAE;EACnC,gBAAgB,MAA+BR,EAAQQ,EAAK,EAAE;EAC9D,UAAU,GAAM;GACd,IAAMG,IAAgC,CAAC,GACnCC,IAAMhB,EAAQ,IAAIY,EAAK,EAAE,GACvBK,oBAAO,IAAI,IAAY;GAC7B,OAAOD,KAAO,CAACC,EAAK,IAAID,EAAI,EAAE,IAG5B,AAFAC,EAAK,IAAID,EAAI,EAAE,GACfD,EAAM,KAAKC,CAAG,GACd,IAAMhB,EAAQ,IAAIgB,EAAI,EAAE;GAE1B,OAAOD;EACT;CACF;AACF"}

package/dist/canvas/affordanceAt.js

@@ -44,7 +44,7 @@ function c(e) {
 		...t.targetId === void 0 ? {} : { targetIds: [t.targetId] },
 		...t.anchor === void 0 ? {} : { anchor: t.anchor },
 		...t.fixedPoint === void 0 ? {} : { fixedPoint: t.fixedPoint },
-		...e.region.cursor === void 0 ? {} : { cursor: e.region.cursor },
+		...e.cursor === void 0 ? {} : { cursor: e.cursor },
 		...e.binding.initialScratch === void 0 ? {} : { payload: e.binding.initialScratch }
 	};
 }
@@ -57,7 +57,17 @@ function l(e, t, n) {
 		} : { body: "empty" };
 	};
 }
+function u(e, t) {
+	return {
+		kind: `layer:${e}`,
+		owner: e,
+		strength: t.strength ?? "shared",
+		...t.claimedKinds === void 0 ? {} : { claimedKinds: t.claimedKinds },
+		...t.cursor === void 0 ? {} : { cursor: t.cursor },
+		...t.initialScratch === void 0 ? {} : { payload: t.initialScratch }
+	};
+}
 //#endregion
-export { o as anchorStateFrom, s as buildAffordanceAt, l as buildClassifyTarget, a as chromeAffordances };
+export { o as anchorStateFrom, s as buildAffordanceAt, l as buildClassifyTarget, a as chromeAffordances, u as layerAffordance };
 
 //# sourceMappingURL=affordanceAt.js.map

package/dist/canvas/affordanceAt.js.map

@@ -1 +1 @@
-{"version":3,"file":"affordanceAt.js","names":["chromeAffordances","sizes","targetSizesPx","opts","createRotationAffordance","rotateBandPx","rotationBadge","createCornerResizeAffordance","getAnchorState","createPathAnchorAffordances","anchorHitRadius","anchorStateFrom","dep","getRegistry","toCamera","id","buildAffordanceAt","affordances","wx","wy","hit","hitAffordanceRegions","getChromeState","getView","getIsVisible","toAffordanceHit","scratch","buildClassifyTarget","hitId","pickBest","getSelection","kindOfNode"],"sources":["../../src/canvas/affordanceAt.ts"],"sourcesContent":["/**\n * affordanceAt — the dispatcher-side affordance classifier.\n *\n * Answers \"what piece of selection chrome is under this world point?\" and\n * returns an `AffordanceHit`, which `GestureDispatcherMounter` packs onto\n * `InputEvent.pointerdown.affordance` so `resizeAction` / `rotateAction` /\n * `editAnchorsAction` can guard on affordance kind, and which the hover-cursor\n * pump reads `cursor` off of.\n *\n * It used to answer that question with its own geometry: its own corner\n * table, its own rotate-ring ellipse, its own anchor walk — all duplicating\n * the `Affordance` region declarations in `src/affordances/`, which had a\n * hit-tester of their own that nothing reached for kit chrome. Two\n * implementations of one question, and the declarative one was the dead\n * branch, which is why `AffordanceRegion.cursor` could be declared and set\n * and never consumed.\n *\n * Now this assembles the kit's affordances and runs the one shared walk\n * (`hitAffordanceRegions`). What remains here is the assembly and the\n * region-hit → `AffordanceHit` mapping.\n */\n\nimport type { BodyClassification } from '@weasel-js/gestures';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { View } from 'core/viewport/view';\nimport type { AffordanceHit } from '@weasel-js/routing';\nimport type { Affordance, CommonAffordanceScratch } from 'affordances/types';\nimport { hitAffordanceRegions, type AffordanceRegionHit } from 'affordances/hitAffordanceRegions';\nimport { createCornerResizeAffordance } from 'affordances/cornerResize';\nimport { createRotationAffordance } from 'affordances/rotationHandle';\nimport { createPathAnchorAffordances, type AnchorState } from 'affordances/pathAnchors';\nimport { targetSizesPx } from 'core/device/targets';\n\nexport type { AnchorState };\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/** What decides the kit's chrome affordances — their sizes and which ones\n *  exist. Shared by the hit-test and the slops overlay, which draws them. */\nexport interface ChromeAffordanceOptions {\n  /** Pointer-size multiplier from the live `DeviceProfile`. Every default\n   *  below is resolved through {@link targetSizesPx} at this scale, so the\n   *  grab zone tracks the painted chrome on a coarse pointer. Default 1. */\n  targetScale?: number;\n  /** Corner-handle hit radius in screen px. Overrides the device-scaled default. */\n  handleHitRadius?: number;\n  /** Anchor / control hit radius in screen px. Overrides the device-scaled default. */\n  anchorHitRadius?: number;\n  /** Minimum rotate-band thickness outside the selection AABB, in screen px.\n   *  Overrides the device-scaled default. */\n  rotateBandPx?: number;\n  /** The rotate badge the selection overlay paints (`rotationBadgeOf`), so\n   *  it can be grabbed where it is drawn. Omitted or null, only the rotate\n   *  ring is hit-tested. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Anchor-editing state. When omitted, anchors aren't hit-tested. */\n  getAnchorState?: () => AnchorState | null;\n}\n\nexport interface BuildAffordanceAtOptions extends ChromeAffordanceOptions {\n  /** Live ChromeState at call time — current selection plus effective bounds,\n   *  including in-flight move/resize ghost poses. */\n  getChromeState: () => ChromeState;\n  /** Live view. Needed because region hit radii and the rotate band are\n   *  declared in screen pixels and resolved against the current scale. */\n  getView: () => View;\n  /** The affordances to walk, when the caller built them itself to share\n   *  them (`chromeAffordances`). Otherwise built from these options. */\n  affordances?: readonly Affordance[];\n  /** Chrome-caps resolver. Keeps the hit-test and the renderer agreeing on\n   *  which chrome is live (resize handles gated by\n   *  `'selection.resize-handles'`, rotation by `'selection.rotation-handle'`,\n   *  anchors by `'path-edit.anchors'`). Omitting defaults to always-visible. */\n  getIsVisible?: () => (id: string) => boolean;\n}\n\n/**\n * The kit's selection chrome as affordances, bottom → top: rotate ring (and\n * badge), corner handles, then anchors and their controls — a corner handle\n * beats the rotate band it sits inside, and a control handle beats everything.\n */\nexport function chromeAffordances(opts: ChromeAffordanceOptions = {}): Affordance[] {\n  const sizes = targetSizesPx(opts.targetScale);\n  const {\n    handleHitRadius = sizes.handle,\n    anchorHitRadius = sizes.anchor,\n    rotateBandPx = sizes.rotationDistance,\n    getAnchorState,\n    rotationBadge,\n  } = opts;\n  return [\n    createRotationAffordance({\n      bandPx: rotateBandPx,\n      paint: null,\n      ...(rotationBadge\n        ? { handle: { distancePx: rotationBadge.distancePx, hitRadiusPx: rotationBadge.sizePx } }\n        : {}),\n    }),\n    createCornerResizeAffordance({ handleHitRadius }),\n    ...(getAnchorState\n      ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius })\n      : []),\n  ];\n}\n\n/**\n * Read anchor-editing state off a dep registry, for\n * {@link BuildAffordanceAtOpts.getAnchorState}. Returns `null` while no\n * `editAnchors` dep is registered — nothing is in anchor-edit mode, so\n * anchors are not hit-tested.\n */\nexport function anchorStateFrom(\n  getRegistry: () => { get(name: 'editAnchors'): EditAnchorsDep | undefined } | null,\n  /** The editable path in the world the hit-test is asked in. A node on a\n   *  parallax plane stores its path in the plane's world; the surface carries\n   *  it into the asking camera's. Default: unchanged. */\n  toCamera?: (id: string, path: unknown) => unknown,\n): () => AnchorState | null {\n  return () => {\n    const dep = getRegistry()?.get('editAnchors');\n    if (!dep) return null;\n    return {\n      editingId: dep.editingId ?? null,\n      // The hit-test reads world-coord anchor positions, so route through\n      // `getEditablePath`: both pose-as-polygon and `data.path` consumers\n      // resolve correctly.\n      getPose: (id) => (toCamera ? toCamera(id, dep.getEditablePath(id)) : dep.getEditablePath(id)),\n    };\n  };\n}\n\n/**\n * Build the `affordanceAt` thunk for `GestureDispatcherMounter`.\n *\n * Returns `(worldPoint) => AffordanceHit | null`. The point is **world-space**;\n * callers convert from client coords first.\n *\n * Priority runs anchors → controls → resize handles → rotate ring, top to\n * bottom, matching how the chrome paints: a corner handle beats the rotate\n * band it sits inside, and a control handle beats everything.\n */\nexport function buildAffordanceAt(\n  opts: BuildAffordanceAtOptions,\n): (worldPoint: { x: number; y: number }) => AffordanceHit | null {\n  const { getChromeState, getView, getIsVisible } = opts;\n  const affordances = opts.affordances ?? chromeAffordances(opts);\n\n  return function affordanceAt({ x: wx, y: wy }) {\n    const hit = hitAffordanceRegions(\n      affordances,\n      wx,\n      wy,\n      getChromeState(),\n      getView(),\n      getIsVisible?.(),\n    );\n    return hit ? toAffordanceHit(hit) : null;\n  };\n}\n\n/**\n * Region hit → `AffordanceHit`.\n *\n * `hitKind` is the routing discriminator; the handful of scratch fields named\n * by {@link CommonAffordanceScratch} are lifted onto the hit because the\n * actions that consume them read them there. Everything else in scratch rides\n * along untouched as `payload`.\n */\nfunction toAffordanceHit(hit: AffordanceRegionHit): AffordanceHit {\n  const scratch = (hit.binding.initialScratch ?? {}) as CommonAffordanceScratch;\n  return {\n    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,\n    owner: hit.affordanceId,\n    strength: 'shared',\n    ...(scratch.targetId !== undefined ? { targetIds: [scratch.targetId] } : {}),\n    ...(scratch.anchor !== undefined ? { anchor: scratch.anchor } : {}),\n    ...(scratch.fixedPoint !== undefined ? { fixedPoint: scratch.fixedPoint } : {}),\n    ...(hit.region.cursor !== undefined ? { cursor: hit.region.cursor } : {}),\n    ...(hit.binding.initialScratch !== undefined ? { payload: hit.binding.initialScratch } : {}),\n  } as AffordanceHit;\n}\n\n// ---------------------------------------------------------------------------\n// classifyTarget helper\n// ---------------------------------------------------------------------------\n\n/**\n * Classify a world-space point against the current selection:\n * - `'empty'`: no scene body hit.\n * - `'selected-body'`: hit a node that is currently selected.\n * - `'unselected-body'`: hit a node that is NOT selected.\n *\n * The caller supplies the hit-test function (already wired from\n * `useSceneSelectTool.pickEvery`).\n *\n * @param kindOfNode - Optional resolver from a hit node id to its semantic\n *   kind. `<SceneCanvas>` defaults it to the `data.kind` convention the kit\n *   already reads in `deps/textEdit` and the shape-tool inserts; consumers\n *   whose nodes name their kind elsewhere override it. Omitting it leaves\n *   `kind` undefined, which makes every `kind:` TargetSpec form no-match.\n */\nexport function buildClassifyTarget(\n  getSelection: () => readonly string[],\n  pickBest: (wx: number, wy: number) => string | null,\n  kindOfNode?: (id: string) => string | undefined,\n): (worldPoint: { x: number; y: number }) => BodyClassification {\n  return function classifyTarget({ x: wx, y: wy }) {\n    const hitId = pickBest(wx, wy);\n    if (!hitId) return { body: 'empty' };\n    const sel = getSelection();\n    return {\n      body: sel.includes(hitId) ? 'selected-body' : 'unselected-body',\n      kind: kindOfNode?.(hitId),\n    };\n  };\n}\n"],"mappings":";;;;;;AAoFA,SAAgBA,EAAkB,IAAgC,CAAC,GAAiB;CAClF,IAAMC,IAAQC,EAAcC,EAAK,WAAW,GACtC,EACJ,qBAAkBF,EAAM,QACxB,qBAAkBA,EAAM,QACxB,kBAAeA,EAAM,kBACrB,mBACA,qBACEE;CACJ,OAAO;EACLC,EAAyB;GACvB,QAAQC;GACR,OAAO;GACP,GAAIC,IACA,EAAE,QAAQ;IAAE,YAAYA,EAAc;IAAY,aAAaA,EAAc;GAAO,EAAE,IACtF,CAAC;EACP,CAAC;EACDC,EAA6B,EAAE,mBAAgB,CAAC;EAChD,GAAIC,IACAC,EAA4BD,GAAgB,EAAE,WAAWE,EAAgB,CAAC,IAC1E,CAAC;CACP;AACF;AAQA,SAAgBC,EACd,GAIA,GAC0B;CAC1B,aAAa;EACX,IAAMC,IAAMC,EAAY,CAAC,EAAE,IAAI,aAAa;EAE5C,OADKD,IACE;GACL,WAAWA,EAAI,aAAa;GAI5B,UAAU,MAAQE,IAAWA,EAASC,GAAIH,EAAI,gBAAgBG,CAAE,CAAC,IAAIH,EAAI,gBAAgBG,CAAE;EAC7F,IAPiB;CAQnB;AACF;AAYA,SAAgBC,EACd,GACgE;CAChE,IAAM,EAAE,mBAAgB,YAAS,oBAAiBb,GAC5Cc,IAAcd,EAAK,eAAeH,EAAkBG,CAAI;CAE9D,OAAO,SAAsB,EAAE,GAAGe,GAAI,GAAGC,KAAM;EAC7C,IAAMC,IAAMC,EACVJ,GACAC,GACAC,GACAG,EAAe,GACfC,EAAQ,GACRC,IAAe,CACjB;EACA,OAAOJ,IAAMK,EAAgBL,CAAG,IAAI;CACtC;AACF;AAUA,SAASK,EAAgB,GAAyC;CAChE,IAAMC,IAAWN,EAAI,QAAQ,kBAAkB,CAAC;CAChD,OAAO;EACL,MAAMA,EAAI,OAAO,WAAW,GAAGA,EAAI,aAAa,GAAGA,EAAI;EACvD,OAAOA,EAAI;EACX,UAAU;EACV,GAAIM,EAAQ,aAAa,KAAA,IAAgD,CAAC,IAArC,EAAE,WAAW,CAACA,EAAQ,QAAQ,EAAE;EACrE,GAAIA,EAAQ,WAAW,KAAA,IAAyC,CAAC,IAA9B,EAAE,QAAQA,EAAQ,OAAO;EAC5D,GAAIA,EAAQ,eAAe,KAAA,IAAiD,CAAC,IAAtC,EAAE,YAAYA,EAAQ,WAAW;EACxE,GAAIN,EAAI,OAAO,WAAW,KAAA,IAA4C,CAAC,IAAjC,EAAE,QAAQA,EAAI,OAAO,OAAO;EAClE,GAAIA,EAAI,QAAQ,mBAAmB,KAAA,IAAsD,CAAC,IAA3C,EAAE,SAASA,EAAI,QAAQ,eAAe;CACvF;AACF;AAqBA,SAAgBO,EACd,GACA,GACA,GAC8D;CAC9D,OAAO,SAAwB,EAAE,GAAGT,GAAI,GAAGC,KAAM;EAC/C,IAAMS,IAAQC,EAASX,GAAIC,CAAE;EAG7B,OAFKS,IAEE;GACL,MAFUE,EAEJ,CAAA,CAAI,SAASF,CAAK,IAAI,kBAAkB;GAC9C,MAAMG,IAAaH,CAAK;EAC1B,IALmB,EAAE,MAAM,QAAQ;CAMrC;AACF"}
+{"version":3,"file":"affordanceAt.js","names":["chromeAffordances","sizes","targetSizesPx","opts","createRotationAffordance","rotateBandPx","rotationBadge","createCornerResizeAffordance","getAnchorState","createPathAnchorAffordances","anchorHitRadius","anchorStateFrom","dep","getRegistry","toCamera","id","buildAffordanceAt","affordances","wx","wy","hit","hitAffordanceRegions","getChromeState","getView","getIsVisible","toAffordanceHit","scratch","buildClassifyTarget","hitId","pickBest","getSelection","kindOfNode","layerAffordance","layerId","claim"],"sources":["../../src/canvas/affordanceAt.ts"],"sourcesContent":["/**\n * The dispatcher-side affordance classifier: answers \"what piece of selection\n * chrome is under this world point?\" by assembling the kit's affordances and\n * running the one shared walk (`hitAffordanceRegions`).\n */\n\nimport type { BodyClassification } from '@weasel-js/gestures';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport type { View } from 'core/viewport/view';\nimport type { AffordanceHit } from '@weasel-js/routing';\nimport type { Affordance, CommonAffordanceScratch, LayerHit } from 'affordances/types';\nimport { hitAffordanceRegions, type AffordanceRegionHit } from 'affordances/hitAffordanceRegions';\nimport { createCornerResizeAffordance } from 'affordances/cornerResize';\nimport { createRotationAffordance } from 'affordances/rotationHandle';\nimport { createPathAnchorAffordances, type AnchorState } from 'affordances/pathAnchors';\nimport { targetSizesPx } from 'core/device/targets';\n\nexport type { AnchorState };\n\n/** What decides the kit's chrome affordances — their sizes and which ones\n *  exist. Shared by the hit-test and the slops overlay, which draws them. */\nexport interface ChromeAffordanceOptions {\n  /** Pointer-size multiplier from the live `DeviceProfile`. Every default\n   *  below is resolved through {@link targetSizesPx} at this scale, so the\n   *  grab zone tracks the painted chrome on a coarse pointer. Default 1. */\n  targetScale?: number;\n  /** Corner-handle hit radius in screen px. Overrides the device-scaled default. */\n  handleHitRadius?: number;\n  /** Anchor / control hit radius in screen px. Overrides the device-scaled default. */\n  anchorHitRadius?: number;\n  /** Minimum rotate-band thickness outside the selection AABB, in screen px.\n   *  Overrides the device-scaled default. */\n  rotateBandPx?: number;\n  /** The rotate badge the selection overlay paints (`rotationBadgeOf`), so\n   *  it can be grabbed where it is drawn. Omitted or null, only the rotate\n   *  ring is hit-tested. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Anchor-editing state. When omitted, anchors aren't hit-tested. */\n  getAnchorState?: () => AnchorState | null;\n}\n\nexport interface BuildAffordanceAtOptions extends ChromeAffordanceOptions {\n  /** Live ChromeState at call time — current selection plus effective bounds,\n   *  including in-flight move/resize ghost poses. */\n  getChromeState: () => ChromeState;\n  /** Live view. Needed because region hit radii and the rotate band are\n   *  declared in screen pixels and resolved against the current scale. */\n  getView: () => View;\n  /** The affordances to walk, when the caller built them itself to share\n   *  them (`chromeAffordances`). Otherwise built from these options. */\n  affordances?: readonly Affordance[];\n  /** Chrome-caps resolver. Keeps the hit-test and the renderer agreeing on\n   *  which chrome is live (resize handles gated by\n   *  `'selection.resize-handles'`, rotation by `'selection.rotation-handle'`,\n   *  anchors by `'path-edit.anchors'`). Omitting defaults to always-visible. */\n  getIsVisible?: () => (id: string) => boolean;\n}\n\n/**\n * The kit's selection chrome as affordances, bottom → top: rotate ring (and\n * badge), corner handles, then anchors and their controls — a corner handle\n * beats the rotate band it sits inside, and a control handle beats everything.\n */\nexport function chromeAffordances(opts: ChromeAffordanceOptions = {}): Affordance[] {\n  const sizes = targetSizesPx(opts.targetScale);\n  const {\n    handleHitRadius = sizes.handle,\n    anchorHitRadius = sizes.anchor,\n    rotateBandPx = sizes.rotationDistance,\n    getAnchorState,\n    rotationBadge,\n  } = opts;\n  return [\n    createRotationAffordance({\n      bandPx: rotateBandPx,\n      paint: null,\n      ...(rotationBadge\n        ? { handle: { distancePx: rotationBadge.distancePx, hitRadiusPx: rotationBadge.sizePx } }\n        : {}),\n    }),\n    createCornerResizeAffordance({ handleHitRadius }),\n    ...(getAnchorState\n      ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius })\n      : []),\n  ];\n}\n\n/**\n * Read anchor-editing state off a dep registry, for\n * {@link ChromeAffordanceOptions.getAnchorState}. Returns `null` while no\n * `editAnchors` dep is registered, so anchors are not hit-tested.\n */\nexport function anchorStateFrom(\n  getRegistry: () => { get(name: 'editAnchors'): EditAnchorsDep | undefined } | null,\n  /** The editable path in the world the hit-test is asked in. A node on a\n   *  parallax plane stores its path in the plane's world; the surface carries\n   *  it into the asking camera's. Default: unchanged. */\n  toCamera?: (id: string, path: unknown) => unknown,\n): () => AnchorState | null {\n  return () => {\n    const dep = getRegistry()?.get('editAnchors');\n    if (!dep) return null;\n    return {\n      editingId: dep.editingId ?? null,\n      // The hit-test reads world-coord anchor positions, so route through\n      // `getEditablePath`: both pose-as-polygon and `data.path` consumers\n      // resolve correctly.\n      getPose: (id) => (toCamera ? toCamera(id, dep.getEditablePath(id)) : dep.getEditablePath(id)),\n    };\n  };\n}\n\n/**\n * Build the `affordanceAt` thunk for `GestureDispatcherMounter`. The point is\n * **world-space**; callers convert from client coords first. Priority follows\n * the order of {@link chromeAffordances}, topmost first.\n */\nexport function buildAffordanceAt(\n  opts: BuildAffordanceAtOptions,\n): (worldPoint: { x: number; y: number }) => AffordanceHit | null {\n  const { getChromeState, getView, getIsVisible } = opts;\n  const affordances = opts.affordances ?? chromeAffordances(opts);\n\n  return function affordanceAt({ x: wx, y: wy }) {\n    const hit = hitAffordanceRegions(\n      affordances,\n      wx,\n      wy,\n      getChromeState(),\n      getView(),\n      getIsVisible?.(),\n    );\n    return hit ? toAffordanceHit(hit) : null;\n  };\n}\n\n/**\n * Region hit → `AffordanceHit`. The scratch fields named by\n * {@link CommonAffordanceScratch} are lifted onto the hit because the actions\n * that consume them read them there; the whole scratch rides along as `payload`.\n */\nfunction toAffordanceHit(hit: AffordanceRegionHit): AffordanceHit {\n  const scratch = (hit.binding.initialScratch ?? {}) as CommonAffordanceScratch;\n  return {\n    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,\n    owner: hit.affordanceId,\n    strength: 'shared',\n    ...(scratch.targetId !== undefined ? { targetIds: [scratch.targetId] } : {}),\n    ...(scratch.anchor !== undefined ? { anchor: scratch.anchor } : {}),\n    ...(scratch.fixedPoint !== undefined ? { fixedPoint: scratch.fixedPoint } : {}),\n    ...(hit.cursor !== undefined ? { cursor: hit.cursor } : {}),\n    ...(hit.binding.initialScratch !== undefined ? { payload: hit.binding.initialScratch } : {}),\n  } as AffordanceHit;\n}\n\n/**\n * Classify a world-space point against the current selection: `'empty'`,\n * `'selected-body'`, or `'unselected-body'`.\n *\n * @param kindOfNode - Resolver from a hit node id to its semantic kind.\n *   Omitting it leaves `kind` undefined, which makes every `kind:` TargetSpec\n *   form no-match.\n */\nexport function buildClassifyTarget(\n  getSelection: () => readonly string[],\n  pickBest: (wx: number, wy: number) => string | null,\n  kindOfNode?: (id: string) => string | undefined,\n): (worldPoint: { x: number; y: number }) => BodyClassification {\n  return function classifyTarget({ x: wx, y: wy }) {\n    const hitId = pickBest(wx, wy);\n    if (!hitId) return { body: 'empty' };\n    const sel = getSelection();\n    return {\n      body: sel.includes(hitId) ? 'selected-body' : 'unselected-body',\n      kind: kindOfNode?.(hitId),\n    };\n  };\n}\n\n/** A registered layer's claim on a point, as the affordance the dispatcher\n *  routes: its kind names the layer, and it carries what the layer's hit-test\n *  resolved. */\nexport function layerAffordance(layerId: string, claim: LayerHit): AffordanceHit {\n  return {\n    kind: `layer:${layerId}`,\n    owner: layerId,\n    strength: claim.strength ?? 'shared',\n    ...(claim.claimedKinds !== undefined ? { claimedKinds: claim.claimedKinds } : {}),\n    ...(claim.cursor !== undefined ? { cursor: claim.cursor } : {}),\n    ...(claim.initialScratch !== undefined ? { payload: claim.initialScratch } : {}),\n  };\n}\n"],"mappings":";;;;;;AAgEA,SAAgBA,EAAkB,IAAgC,CAAC,GAAiB;CAClF,IAAMC,IAAQC,EAAcC,EAAK,WAAW,GACtC,EACJ,qBAAkBF,EAAM,QACxB,qBAAkBA,EAAM,QACxB,kBAAeA,EAAM,kBACrB,mBACA,qBACEE;CACJ,OAAO;EACLC,EAAyB;GACvB,QAAQC;GACR,OAAO;GACP,GAAIC,IACA,EAAE,QAAQ;IAAE,YAAYA,EAAc;IAAY,aAAaA,EAAc;GAAO,EAAE,IACtF,CAAC;EACP,CAAC;EACDC,EAA6B,EAAE,mBAAgB,CAAC;EAChD,GAAIC,IACAC,EAA4BD,GAAgB,EAAE,WAAWE,EAAgB,CAAC,IAC1E,CAAC;CACP;AACF;AAOA,SAAgBC,EACd,GAIA,GAC0B;CAC1B,aAAa;EACX,IAAMC,IAAMC,EAAY,CAAC,EAAE,IAAI,aAAa;EAE5C,OADKD,IACE;GACL,WAAWA,EAAI,aAAa;GAI5B,UAAU,MAAQE,IAAWA,EAASC,GAAIH,EAAI,gBAAgBG,CAAE,CAAC,IAAIH,EAAI,gBAAgBG,CAAE;EAC7F,IAPiB;CAQnB;AACF;AAOA,SAAgBC,EACd,GACgE;CAChE,IAAM,EAAE,mBAAgB,YAAS,oBAAiBb,GAC5Cc,IAAcd,EAAK,eAAeH,EAAkBG,CAAI;CAE9D,OAAO,SAAsB,EAAE,GAAGe,GAAI,GAAGC,KAAM;EAC7C,IAAMC,IAAMC,EACVJ,GACAC,GACAC,GACAG,EAAe,GACfC,EAAQ,GACRC,IAAe,CACjB;EACA,OAAOJ,IAAMK,EAAgBL,CAAG,IAAI;CACtC;AACF;AAOA,SAASK,EAAgB,GAAyC;CAChE,IAAMC,IAAWN,EAAI,QAAQ,kBAAkB,CAAC;CAChD,OAAO;EACL,MAAMA,EAAI,OAAO,WAAW,GAAGA,EAAI,aAAa,GAAGA,EAAI;EACvD,OAAOA,EAAI;EACX,UAAU;EACV,GAAIM,EAAQ,aAAa,KAAA,IAAgD,CAAC,IAArC,EAAE,WAAW,CAACA,EAAQ,QAAQ,EAAE;EACrE,GAAIA,EAAQ,WAAW,KAAA,IAAyC,CAAC,IAA9B,EAAE,QAAQA,EAAQ,OAAO;EAC5D,GAAIA,EAAQ,eAAe,KAAA,IAAiD,CAAC,IAAtC,EAAE,YAAYA,EAAQ,WAAW;EACxE,GAAIN,EAAI,WAAW,KAAA,IAAqC,CAAC,IAA1B,EAAE,QAAQA,EAAI,OAAO;EACpD,GAAIA,EAAI,QAAQ,mBAAmB,KAAA,IAAsD,CAAC,IAA3C,EAAE,SAASA,EAAI,QAAQ,eAAe;CACvF;AACF;AAUA,SAAgBO,EACd,GACA,GACA,GAC8D;CAC9D,OAAO,SAAwB,EAAE,GAAGT,GAAI,GAAGC,KAAM;EAC/C,IAAMS,IAAQC,EAASX,GAAIC,CAAE;EAG7B,OAFKS,IAEE;GACL,MAFUE,EAEJ,CAAA,CAAI,SAASF,CAAK,IAAI,kBAAkB;GAC9C,MAAMG,IAAaH,CAAK;EAC1B,IALmB,EAAE,MAAM,QAAQ;CAMrC;AACF;AAKA,SAAgBI,EAAgB,GAAiB,GAAgC;CAC/E,OAAO;EACL,MAAM,SAASC;EACf,OAAOA;EACP,UAAUC,EAAM,YAAY;EAC5B,GAAIA,EAAM,iBAAiB,KAAA,IAAmD,CAAC,IAAxC,EAAE,cAAcA,EAAM,aAAa;EAC1E,GAAIA,EAAM,WAAW,KAAA,IAAuC,CAAC,IAA5B,EAAE,QAAQA,EAAM,OAAO;EACxD,GAAIA,EAAM,mBAAmB,KAAA,IAAgD,CAAC,IAArC,EAAE,SAASA,EAAM,eAAe;CAC3E;AACF"}

package/dist/canvas/buildSceneLayer.js

@@ -1,91 +1,111 @@
-import { viewToMat3 as e } from "../renderer/math/viewToMat3.js";
-import { cullDrawCommands as t } from "../renderer/cullDrawCommands.js";
-import { sceneLayerKey as n } from "./sceneLayerPaint.js";
-import { wrapNodeOutput as r } from "./wrapNodeOutput.js";
-import { buildSceneTree as i } from "./buildSceneTree.js";
-import { paintMissesView as a } from "./paintCull.js";
+import { sceneLayerKey as e } from "./sceneLayerPaint.js";
+import { wrapNodeOutput as t } from "./wrapNodeOutput.js";
+import { adapterDerivedPathOf as n } from "./adapterDerivedPath.js";
+import { buildSceneTree as r } from "./buildSceneTree.js";
+import { paintMissesView as i } from "./paintCull.js";
+import { debugSinkFrom as a } from "./drawEnvelope.js";
+import { cullDrawCommands as o, viewToMat3 as s } from "@weasel-js/renderer";
 //#region src/canvas/buildSceneLayer.ts
-function o(n, o, s, c, l, u) {
-	let d = n.toPose ?? ((e) => o ? o.getPose(e.id) : e), f = n.drawOne, p = n.postProcess, m = n.cull ? (n, r, i) => t(n, e(r), {
+function c(e, t, r) {
+	let i = e.drawOne;
+	if (e.derivedPathOf !== void 0 || !i || !t) return e;
+	let a = n(e.toPose === void 0 ? t : {
+		getNode: (e) => t.getNode(e),
+		getPose: (e) => {
+			let n = t.getNode(e);
+			return n ? r(n) : t.getPose(e);
+		},
+		getChildren: (e) => t.getChildren(e)
+	});
+	return {
+		derivedPathOf: (e) => a(e.id),
+		drawOne: (e, t, n, r) => e.dependsOn === void 0 ? i(e, t, n, r) : i(e, t, n, {
+			...r,
+			derivedPath: a(e.id)
+		})
+	};
+}
+function l(e, n, l, u, d) {
+	let f = e.toPose ?? ((e) => n ? n.getPose(e.id) : e), { drawOne: p, derivedPathOf: m } = c(e, n, f), h = e.postProcess, g = e.cull ? (e, t, n) => o(e, s(t), {
 		x: 0,
 		y: 0,
-		width: i.width,
-		height: i.height
-	}) : (e) => e, h = n.cull ? n.paintBounds : void 0, g = (e, t) => h ? a(h, e, {
+		width: n.width,
+		height: n.height
+	}) : (e) => e, _ = e.cull ? e.paintBounds : void 0, v = (e, t) => _ ? i(_, e, {
 		x: 0,
 		y: 0,
 		width: t.width,
 		height: t.height
 	}) : void 0;
 	return {
-		id: u?.id ?? "scene",
-		label: u ? `Scene: ${u.forLayer}` : "Scene",
-		draw: (e, t, a) => {
-			let h = l(), _ = o;
-			if (_ && n.objects === void 0 && typeof _.getLayers == "function" && typeof _.getNode == "function" && typeof _.getChildren == "function" && f) {
-				let e = (e, t, i) => {
-					if (h && h.has(e.id)) return [];
-					let a = f(e, t, i);
-					if (s) {
-						let n = c ? c(e.id) : null;
-						n && s.recordBounds(e.id, n);
-						let r = t.x ?? (n ? n.x : 0), i = t.y ?? (n ? n.y : 0);
-						s.recordOrigin(e.id, {
-							x: r,
+		id: d?.id ?? "scene",
+		label: d ? `Scene: ${d.forLayer}` : "Scene",
+		draw: (i, o, s) => {
+			let c = a(i), _ = u(), y = n;
+			if (y && e.objects === void 0 && p) {
+				let n = (n, r, i) => {
+					if (_ && _.has(n.id)) return [];
+					let a = p(n, r, i);
+					if (c) {
+						let e = l ? l(n.id) : null;
+						e && c.recordBounds(n.id, e);
+						let t = r.x ?? (e ? e.x : 0), i = r.y ?? (e ? e.y : 0);
+						c.recordOrigin(n.id, {
+							x: t,
 							y: i
 						});
 					}
-					return r(a, t, n.alphaFor ? n.alphaFor(e.id) : 1);
-				}, o = n.toPose ? {
-					..._,
+					return t(a, r, e.alphaFor ? e.alphaFor(n.id) : 1);
+				}, i = e.toPose ? {
+					...y,
 					getPose: (e) => {
-						let t = _.getNode(e);
-						return t ? d(t) : _.getPose(e);
+						let t = y.getNode(e);
+						return t ? f(t) : y.getPose(e);
 					}
-				} : _, l = i(o, e, t, u?.forLayer, n.derivedPathOf, g(t, a));
-				return m(p ? p(l, t, a) : l, t, a);
+				} : y, a = r(i, n, o, d?.forLayer, m, v(o, s));
+				return g(h ? h(a, o, s) : a, o, s);
 			}
-			let v = n.objects ?? o?.getNodes() ?? [], y = [], b = g(t, a);
-			for (let e of v) {
-				if (h && h.has(e.id)) continue;
-				let i = d(e);
-				if (f && !b?.(e, i)) {
-					let a = f(e, i, t), o = r(a, i, n.alphaFor ? n.alphaFor(e.id) : 1);
-					for (let e of o) y.push(e);
+			let b = e.objects ?? [], x = [], S = v(o, s);
+			for (let n of b) {
+				if (_ && _.has(n.id)) continue;
+				let r = f(n);
+				if (p && !S?.(n, r)) {
+					let i = p(n, r, o), a = t(i, r, e.alphaFor ? e.alphaFor(n.id) : 1);
+					for (let e of a) x.push(e);
 				}
-				if (s) {
-					let t = c ? c(e.id) : null;
-					t && s.recordBounds(e.id, {
-						x: t.x,
-						y: t.y,
-						width: t.width,
-						height: t.height
+				if (c) {
+					let e = l ? l(n.id) : null;
+					e && c.recordBounds(n.id, {
+						x: e.x,
+						y: e.y,
+						width: e.width,
+						height: e.height
 					});
-					let n = i.x ?? (t ? t.x : 0), r = i.y ?? (t ? t.y : 0);
-					s.recordOrigin(e.id, {
-						x: n,
-						y: r
+					let t = r.x ?? (e ? e.x : 0), i = r.y ?? (e ? e.y : 0);
+					c.recordOrigin(n.id, {
+						x: t,
+						y: i
 					});
 				}
 			}
-			return m(p ? p(y, t, a) : y, t, a);
+			return g(h ? h(x, o, s) : x, o, s);
 		}
 	};
 }
-function s(e, t, r, i, a) {
-	let s = e.objects === void 0 && typeof t?.getLayers == "function" ? t.getLayers().map((e) => e.id) : null;
-	return !s || s.length === 0 ? [{
+function u(t, n, r, i) {
+	let a = t.objects === void 0 && n ? n.getLayers().map((e) => e.id) : null;
+	return !a || a.length === 0 ? [{
 		key: "scene",
-		layer: o(e, t, r, i, a)
-	}] : s.map((s) => ({
-		key: n(s),
-		layer: o(e, t, r, i, a, {
-			id: n(s),
-			forLayer: s
+		layer: l(t, n, r, i)
+	}] : a.map((a) => ({
+		key: e(a),
+		layer: l(t, n, r, i, {
+			id: e(a),
+			forLayer: a
 		})
 	}));
 }
 //#endregion
-export { o as buildSceneLayer, s as buildSceneLayers };
+export { l as buildSceneLayer, u as buildSceneLayers };
 
 //# sourceMappingURL=buildSceneLayer.js.map

package/dist/canvas/buildSceneLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildSceneLayer.js","names":["buildSceneLayer","toPose","cfg","adapter","obj","drawOne","postProcess","finish","cullDrawCommands","cmds","viewToMat3","view","dims","paintBounds","culledIn","paintMissesView","slot","hidden","hideIds","a","filteredDrawOne","pose","v","debugSink","b","boundsOfFn","ox","oy","wrapNodeOutput","hierarchicalAdapter","id","tree","buildSceneTree","objects","children","culled","wrapped","cmd","buildSceneLayers","sceneLayerIds","l","sceneLayerKey"],"sources":["../../src/canvas/buildSceneLayer.ts"],"sourcesContent":["/**\n * The scene slot: how `<Canvas>` turns an adapter's nodes into render layers.\n * One layer for a flat adapter, one per scene layer for a hierarchical one.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { MoveAdapter, ResizeAdapter, RotateAdapter } from 'core/adapters/types';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { View } from 'core/viewport/view';\nimport type { DebugSink } from '../debug/types';\nimport { cullDrawCommands, viewToMat3, type DrawCommand } from '../renderer';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport type { NodePaintCtx } from './NodeShape';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { sceneLayerKey } from './sceneLayerPaint';\nimport { wrapNodeOutput } from './wrapNodeOutput';\n\n/**\n * The scene-tree reading methods Canvas feature-detects at draw time, as an\n * *optional* mixin. A `SceneCanvasAdapter` supplies them; flat / bare-Canvas\n * adapters don't. `getPose` already lives on the base move adapter, so only the\n * three tree-walk methods are added here.\n */\ntype OptionalSceneHierarchy<TNode, TPose> = Partial<\n  Pick<HierarchicalAdapter<TNode, TPose>, 'getLayers' | 'getNode' | 'getChildren'>\n>;\n\n/** The full adapter shape Canvas threads through layers + gesture hooks: the\n *  move/resize/rotate intersection plus the optional scene-tree methods. */\nexport type CanvasAdapter<TNode extends { id: string }, TPose> = MoveAdapter<TNode, TPose> &\n  ResizeAdapter<TNode, TPose> &\n  RotateAdapter<TNode, TPose> &\n  OptionalSceneHierarchy<TNode, TPose>;\n\n/** Scene slot config — describes how to draw one object with its effective pose. */\nexport interface SceneSlotConfig<TNode extends { id: string }, TPose> {\n  /** Override `adapter.getNodes()` for the object iteration. */\n  objects?: TNode[];\n  /** Project an object to its committed pose. Defaults to `adapter.getPose(obj.id)`. */\n  toPose?: (obj: TNode) => TPose;\n  /** Draw a single object as a `DrawCommand` tree. `ctx` carries what only a\n   *  scene-aware caller can supply (a node's derived path); `<SceneCanvas>`\n   *  fills it in, bare `<Canvas>` never does. */\n  drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];\n  /** The path a container derives from its dependencies' poses, for the clip\n   *  it imposes on its subtree. The other half of what only a scene-aware\n   *  caller can supply — `drawOne`'s `ctx` carries the derived path a node\n   *  *paints*, this one the clip it *imposes*. */\n  derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;\n  /** Default ghost alpha for the move-overlay slot. Default 0.85. */\n  ghostAlpha?: number;\n  /**\n   * Optional per-id alpha multiplier. When supplied, each node's emitted\n   * `DrawCommand[]` is wrapped in a `{ kind: 'group', alpha }` when the\n   * returned value is not 1. The scoping-dim integration supplies this to\n   * dim non-active nodes during a mode transition.\n   *\n   * Defaults to `() => 1` (no effect).\n   */\n  alphaFor?: (id: string) => number;\n  /**\n   * Optional post-processor for the scene slot's emitted commands. Called\n   * with the final world-space `DrawCommand[]` each time a scene canvas\n   * layer draws (after per-node rotation wrapping and `alphaFor`); the\n   * return value replaces the array handed to the renderer. When the scene\n   * slot is split into per-scene-layer canvas layers (`scene:<layerId>`),\n   * it runs once per layer. Identity by default.\n   *\n   * Commands are world-space — `drawLayers` applies the view transform\n   * afterward, so e.g. a `clip` path in a wrapping group is authored in\n   * world coordinates. Note clip nesting is capped at 7 levels; a wrapping\n   * group with `clip` consumes one.\n   *\n   * The move-overlay ghost (drag preview) is not post-processed.\n   */\n  postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Skip what cannot reach the view. A node `paintBounds` places outside the\n   * `dims` rectangle under `view` is not painted at all; then, after\n   * `postProcess`, `cullDrawCommands` drops any remaining command that cannot\n   * reach it — see there for what it can and cannot bound. So `postProcess`\n   * sees an empty group where a culled node would have painted.\n   *\n   * Off by default because it makes the layer's world-space output depend on\n   * the view: anything that draws this layer once and shows the result under\n   * another view — a cache keyed without `view`, a consumer re-wrapping the\n   * commands — would show the first view's cull.\n   */\n  cull?: boolean;\n  /**\n   * Where `drawOne`'s output for a node can reach, in the frame it paints in\n   * — before the pose rotation the slot wraps it in. `null` for a node it\n   * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a\n   * node whose box misses the view, so it must enclose everything `drawOne`\n   * paints: a box too small makes a node vanish before it leaves the screen.\n   *\n   * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is\n   * `defaultDrawOne`. Omit it with any other `drawOne` and culling only\n   * trims commands after painting.\n   */\n  paintBounds?: PaintBoundsFn<TNode, TPose>;\n}\n\n/**\n * Build the scene layer. Tool ghosts (in-flight drag/resize/rotate poses) are\n * published via the active tool's `previewPose`/`previewIds` and rendered on\n * top of this layer (see SceneCanvas's preview-ghost layer); we draw committed\n * poses here, and `hideIds()` lets us skip the committed paint of ids the\n * active tool is currently ghosting so the source doesn't show through.\n */\nexport function buildSceneLayer<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n  /** When set, the returned layer carries this `id` and paints ONLY the named\n   *  scene layer (the rest are walked for ancestor clips). Used to split the\n   *  scene slot into per-scene-layer, individually-orderable canvas layers\n   *  (`scene:<layerId>`) so consumers can interleave custom layers between\n   *  them. Omit for the single bundled `scene` layer. */\n  slot?: { id: string; forLayer: string },\n): RenderLayer<unknown> {\n  const toPose =\n    cfg.toPose ??\n    ((obj: TNode) => (adapter ? adapter.getPose(obj.id) : (obj as unknown as TPose)));\n  const drawOne = cfg.drawOne;\n  const postProcess = cfg.postProcess;\n  const finish = cfg.cull\n    ? (cmds: DrawCommand[], view: View, dims: Dims): DrawCommand[] =>\n      cullDrawCommands(cmds, viewToMat3(view), { x: 0, y: 0, width: dims.width, height: dims.height })\n    : (cmds: DrawCommand[]): DrawCommand[] => cmds;\n  const paintBounds = cfg.cull ? cfg.paintBounds : undefined;\n  const culledIn = (view: View, dims: Dims) => paintBounds\n    ? paintMissesView(paintBounds, view, { x: 0, y: 0, width: dims.width, height: dims.height })\n    : undefined;\n  return {\n    id: slot?.id ?? 'scene',\n    label: slot ? `Scene: ${slot.forLayer}` : 'Scene',\n    draw: (_data, view, dims) => {\n      const hidden = hideIds();\n      const a = adapter;\n      if (\n        a &&\n        cfg.objects === undefined &&\n        typeof a.getLayers === 'function' &&\n        typeof a.getNode === 'function' &&\n        typeof a.getChildren === 'function' &&\n        drawOne\n      ) {\n        const filteredDrawOne = (obj: TNode, pose: TPose, v: View): DrawCommand[] => {\n          if (hidden && hidden.has(obj.id)) return [];\n          const cmds = drawOne(obj, pose, v);\n          if (debugSink) {\n            const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n            if (b) debugSink.recordBounds(obj.id, b);\n            const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n            const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n            debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n          }\n          return wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n        };\n        // Honor cfg.toPose on the hierarchical path by shimming getPose on the\n        // adapter so buildSceneTree routes through it instead of the raw adapter.\n        const hierarchicalAdapter = cfg.toPose\n          ? {\n              ...a,\n              getPose: (id: string) => {\n                const obj = a.getNode!(id);\n                return obj ? toPose(obj) : a.getPose(id);\n              },\n            }\n          : a;\n        // World-space commands; drawLayers wraps in viewToMat3 automatically.\n        const tree = buildSceneTree(\n          hierarchicalAdapter as Parameters<typeof buildSceneTree>[0],\n          filteredDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n          view,\n          slot?.forLayer,\n          cfg.derivedPathOf as Parameters<typeof buildSceneTree>[4],\n          culledIn(view, dims) as Parameters<typeof buildSceneTree>[5],\n        );\n        return finish(postProcess ? postProcess(tree, view, dims) : tree, view, dims);\n      }\n      // Flat fallback — keep existing body verbatim. (Per-layer slotting only\n      // applies on the hierarchical path; a flat adapter has no scene layers,\n      // so the `scene:<layer>` split is a no-op and we emit the whole scene.)\n      const objects = cfg.objects ?? adapter?.getNodes() ?? [];\n      const children: DrawCommand[] = [];\n      const culled = culledIn(view, dims);\n      for (const obj of objects) {\n        if (hidden && hidden.has(obj.id)) continue;\n        const pose: TPose = toPose(obj);\n        if (drawOne && !culled?.(obj, pose)) {\n          const cmds = drawOne(obj, pose, view);\n          const wrapped = wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n          for (const cmd of wrapped) children.push(cmd);\n        }\n        if (debugSink) {\n          const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n          if (b) debugSink.recordBounds(obj.id, { x: b.x, y: b.y, width: b.width, height: b.height });\n          const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n          const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n          debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n        }\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return finish(postProcess ? postProcess(children, view, dims) : children, view, dims);\n    },\n  };\n}\n\n/**\n * Build the scene slot as one canvas layer **per scene layer** — keyed\n * `scene:<layerId>` — when the adapter is hierarchical (exposes `getLayers`).\n * This lets consumers interleave custom layers *between* scene layers via the\n * standard slot anchoring (`before: 'scene:plantings'`). Each per-layer canvas\n * layer re-runs the scene walk for its own layer only (others are still walked\n * for ancestor clips). Falls back to a single `scene` layer for flat adapters\n * or adapters with no declared layers.\n */\nexport function buildSceneLayers<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n): Array<{ key: string; layer: RenderLayer<unknown> }> {\n  const sceneLayerIds =\n    cfg.objects === undefined && typeof adapter?.getLayers === 'function'\n      ? adapter.getLayers().map((l) => l.id)\n      : null;\n  if (!sceneLayerIds || sceneLayerIds.length === 0) {\n    return [{ key: 'scene', layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds) }];\n  }\n  return sceneLayerIds.map((id) => ({\n    key: sceneLayerKey(id),\n    layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds, {\n      id: sceneLayerKey(id),\n      forLayer: id,\n    }),\n  }));\n}\n"],"mappings":";;;;;;;AA8GA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GAMA,GACsB;CACtB,IAAMC,IACJC,EAAI,YACF,MAAgBC,IAAUA,EAAQ,QAAQC,EAAI,EAAE,IAAKA,IACnDC,IAAUH,EAAI,SACdI,IAAcJ,EAAI,aAClBK,IAASL,EAAI,QACd,GAAqB,GAAY,MAClCM,EAAiBC,GAAMC,EAAWC,CAAI,GAAG;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,KAC9F,MAAuCH,GACtCI,IAAcX,EAAI,OAAOA,EAAI,cAAc,KAAA,GAC3CY,KAAY,GAAY,MAAeD,IACzCE,EAAgBF,GAAaF,GAAM;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOC,EAAK;EAAO,QAAQA,EAAK;CAAO,CAAC,IACzF,KAAA;CACJ,OAAO;EACL,IAAII,GAAM,MAAM;EAChB,OAAOA,IAAO,UAAUA,EAAK,aAAa;EAC1C,OAAO,GAAO,GAAM,MAAS;GAC3B,IAAMC,IAASC,EAAQ,GACjBC,IAAIhB;GACV,IACEgB,KACAjB,EAAI,YAAY,KAAA,KAChB,OAAOiB,EAAE,aAAc,cACvB,OAAOA,EAAE,WAAY,cACrB,OAAOA,EAAE,eAAgB,cACzBd,GACA;IACA,IAAMe,KAAmB,GAAY,GAAa,MAA2B;KAC3E,IAAIH,KAAUA,EAAO,IAAIb,EAAI,EAAE,GAAG,OAAO,CAAC;KAC1C,IAAMK,IAAOJ,EAAQD,GAAKiB,GAAMC,CAAC;KACjC,IAAIC,GAAW;MACb,IAAMC,IAAIC,IAAaA,EAAWrB,EAAI,EAAE,IAAI;MAC5C,AAAIoB,KAAGD,EAAU,aAAanB,EAAI,IAAIoB,CAAC;MACvC,IAAME,IAAML,EAAwB,MAAMG,IAAIA,EAAE,IAAI,IAC9CG,IAAMN,EAAwB,MAAMG,IAAIA,EAAE,IAAI;MACpD,EAAU,aAAapB,EAAI,IAAI;OAAE,GAAGsB;OAAI,GAAGC;MAAG,CAAC;KACjD;KACA,OAAOC,EAAenB,GAAMY,GAAMnB,EAAI,WAAWA,EAAI,SAASE,EAAI,EAAE,IAAI,CAAC;IAC3E,GAGMyB,IAAsB3B,EAAI,SAC5B;KACE,GAAGiB;KACH,UAAU,MAAe;MACvB,IAAMf,IAAMe,EAAE,QAASW,CAAE;MACzB,OAAO1B,IAAMH,EAAOG,CAAG,IAAIe,EAAE,QAAQW,CAAE;KACzC;IACF,IACAX,GAEEY,IAAOC,EACXH,GACAT,GACAT,GACAK,GAAM,UACNd,EAAI,eACJY,EAASH,GAAMC,CAAI,CACrB;IACA,OAAOL,EAAOD,IAAcA,EAAYyB,GAAMpB,GAAMC,CAAI,IAAImB,GAAMpB,GAAMC,CAAI;GAC9E;GAIA,IAAMqB,IAAU/B,EAAI,WAAWC,GAAS,SAAS,KAAK,CAAC,GACjD+B,IAA0B,CAAC,GAC3BC,IAASrB,EAASH,GAAMC,CAAI;GAClC,KAAK,IAAMR,KAAO6B,GAAS;IACzB,IAAIhB,KAAUA,EAAO,IAAIb,EAAI,EAAE,GAAG;IAClC,IAAMiB,IAAcpB,EAAOG,CAAG;IAC9B,IAAIC,KAAW,CAAC8B,IAAS/B,GAAKiB,CAAI,GAAG;KACnC,IAAMZ,IAAOJ,EAAQD,GAAKiB,GAAMV,CAAI,GAC9ByB,IAAUR,EAAenB,GAAMY,GAAMnB,EAAI,WAAWA,EAAI,SAASE,EAAI,EAAE,IAAI,CAAC;KAClF,KAAK,IAAMiC,KAAOD,GAAS,EAAS,KAAKC,CAAG;IAC9C;IACA,IAAId,GAAW;KACb,IAAMC,IAAIC,IAAaA,EAAWrB,EAAI,EAAE,IAAI;KAC5C,AAAIoB,KAAGD,EAAU,aAAanB,EAAI,IAAI;MAAE,GAAGoB,EAAE;MAAG,GAAGA,EAAE;MAAG,OAAOA,EAAE;MAAO,QAAQA,EAAE;KAAO,CAAC;KAC1F,IAAME,IAAML,EAAwB,MAAMG,IAAIA,EAAE,IAAI,IAC9CG,IAAMN,EAAwB,MAAMG,IAAIA,EAAE,IAAI;KACpD,EAAU,aAAapB,EAAI,IAAI;MAAE,GAAGsB;MAAI,GAAGC;KAAG,CAAC;IACjD;GACF;GAEA,OAAOpB,EAAOD,IAAcA,EAAY4B,GAAUvB,GAAMC,CAAI,IAAIsB,GAAUvB,GAAMC,CAAI;EACtF;CACF;AACF;AAWA,SAAgB0B,EACd,GACA,GACA,GACA,GACA,GACqD;CACrD,IAAMC,IACJrC,EAAI,YAAY,KAAA,KAAa,OAAOC,GAAS,aAAc,aACvDA,EAAQ,UAAU,CAAC,CAAC,KAAK,MAAMqC,EAAE,EAAE,IACnC;CAIN,OAHI,CAACD,KAAiBA,EAAc,WAAW,IACtC,CAAC;EAAE,KAAK;EAAS,OAAOvC,EAAgBE,GAAKC,GAASoB,GAAWE,GAAYP,CAAO;CAAE,CAAC,IAEzFqB,EAAc,KAAK,OAAQ;EAChC,KAAKE,EAAcX,CAAE;EACrB,OAAO9B,EAAgBE,GAAKC,GAASoB,GAAWE,GAAYP,GAAS;GACnE,IAAIuB,EAAcX,CAAE;GACpB,UAAUA;EACZ,CAAC;CACH,EAAE;AACJ"}
+{"version":3,"file":"buildSceneLayer.js","names":["withAdapterDerivedPaths","drawOne","cfg","adapter","pathOf","adapterDerivedPathOf","id","obj","toPose","pose","view","ctx","buildSceneLayer","postProcess","finish","cullDrawCommands","cmds","viewToMat3","dims","paintBounds","culledIn","paintMissesView","slot","debugSink","debugSinkFrom","data","hidden","hideIds","a","filteredDrawOne","v","b","boundsOfFn","ox","oy","wrapNodeOutput","hierarchicalAdapter","tree","buildSceneTree","derivedPathOf","objects","children","culled","wrapped","cmd","buildSceneLayers","sceneLayerIds","l","sceneLayerKey"],"sources":["../../src/canvas/buildSceneLayer.ts"],"sourcesContent":["/**\n * The scene slot: an adapter's tree as render layers, one per scene layer.\n */\nimport type { Path } from '@weasel-js/geom';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { View } from 'core/viewport/view';\nimport { cullDrawCommands, viewToMat3, type DrawCommand } from '@weasel-js/renderer';\nimport { adapterDerivedPathOf } from './adapterDerivedPath';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { debugSinkFrom } from './drawEnvelope';\nimport type { NodePaintCtx } from './NodeShape';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { sceneLayerKey } from './sceneLayerPaint';\nimport { wrapNodeOutput } from './wrapNodeOutput';\n\n/** Scene slot config — describes how to draw one object with its effective pose. */\nexport interface SceneSlotConfig<TNode extends { id: string }, TPose> {\n  /** Paint these, in this order, in place of the adapter's tree: one flat run with no\n   *  scene layers, no container clips, and no pose composition. */\n  objects?: TNode[];\n  /** The pose an object is painted at. Defaults to `adapter.getPose(obj.id)`. `<SceneCanvas>`\n   *  hands it each node as the scene shows it, its `pose` an override's or a derived one,\n   *  and carries an override's `path` into the box it answers; return a pose placed from\n   *  `obj.pose`, or a drag in flight and a rig's motion do not show in this view. */\n  toPose?: (obj: TNode) => TPose;\n  /** Draw a single object as a `DrawCommand` tree. `ctx` carries a derived\n   *  node's path: `<SceneCanvas>` resolves it from the scene, and\n   *  `buildSceneLayer` called without one from its adapter. */\n  drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];\n  /** The path a container derives from its dependencies' poses, for the clip\n   *  it imposes on its subtree — `drawOne`'s `ctx` carries the derived path a\n   *  node *paints*, this one the clip it *imposes*. A scene-aware caller\n   *  supplies it; left out, both are resolved off the adapter. */\n  derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;\n  /** Default ghost alpha for the move-overlay slot. Default 0.85. */\n  ghostAlpha?: number;\n  /** Per-id alpha multiplier. A node's emitted `DrawCommand[]` is wrapped in a\n   *  `{ kind: 'group', alpha }` when the returned value is not 1. */\n  alphaFor?: (id: string) => number;\n  /**\n   * Post-processor for the scene slot's emitted commands: called with the final\n   * world-space `DrawCommand[]` each time a scene canvas layer draws (after per-node\n   * rotation wrapping and `alphaFor`), once per layer when the slot is split into\n   * `scene:<layerId>` layers. Its return value replaces the array handed to the renderer.\n   *\n   * Commands are world-space — `drawLayers` applies the view transform afterward. Clip\n   * nesting is capped at 7 levels; a wrapping group with `clip` consumes one. The\n   * move-overlay ghost (drag preview) is not post-processed.\n   */\n  postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Skip what cannot reach the view. A node `paintBounds` places outside the\n   * `dims` rectangle under `view` is not painted at all; then, after\n   * `postProcess`, `cullDrawCommands` drops any remaining command that cannot\n   * reach it — see there for what it can and cannot bound. So `postProcess`\n   * sees an empty group where a culled node would have painted.\n   *\n   * Off by default because it makes the layer's world-space output depend on\n   * the view: anything that draws this layer once and shows the result under\n   * another view — a cache keyed without `view`, a consumer re-wrapping the\n   * commands — would show the first view's cull.\n   */\n  cull?: boolean;\n  /**\n   * Where `drawOne`'s output for a node can reach, in the frame it paints in\n   * — before the pose rotation the slot wraps it in. `null` for a node it\n   * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a\n   * node whose box misses the view, so it must enclose everything `drawOne`\n   * paints: a box too small makes a node vanish before it leaves the screen.\n   *\n   * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is\n   * `defaultDrawOne`. Omit it with any other `drawOne` and culling only\n   * trims commands after painting.\n   */\n  paintBounds?: PaintBoundsFn<TNode, TPose>;\n}\n\n/**\n * `cfg`'s `drawOne` and clip lookup, resolving derived paths off the adapter\n * when nothing scene-aware filled `derivedPathOf` in.\n */\nfunction withAdapterDerivedPaths<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  toPose: (obj: TNode) => TPose,\n): Pick<SceneSlotConfig<TNode, TPose>, 'drawOne' | 'derivedPathOf'> {\n  const drawOne = cfg.drawOne;\n  if (cfg.derivedPathOf !== undefined || !drawOne || !adapter) return cfg;\n  const pathOf = adapterDerivedPathOf<TPose>(cfg.toPose === undefined ? adapter : {\n    getNode: (id) => adapter.getNode(id),\n    getPose: (id) => {\n      const obj = adapter.getNode(id);\n      return obj ? toPose(obj) : adapter.getPose(id);\n    },\n    getChildren: (id) => adapter.getChildren(id),\n  });\n  return {\n    derivedPathOf: (obj) => pathOf(obj.id),\n    drawOne: (obj, pose, view, ctx) => ((obj as { dependsOn?: unknown }).dependsOn === undefined\n      ? drawOne(obj, pose, view, ctx)\n      : drawOne(obj, pose, view, { ...ctx, derivedPath: pathOf(obj.id) })),\n  };\n}\n\n/**\n * Build the scene layer, which draws committed poses. `hideIds()` skips the committed paint\n * of ids the active tool is currently ghosting so the source doesn't show through. With a\n * debug sink on its draw envelope, it records each node's bounds and origin there.\n */\nexport function buildSceneLayer<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n  /** When set, the returned layer carries this `id` and paints ONLY the named\n   *  scene layer (the rest are walked for ancestor clips). Omit for the single\n   *  bundled `scene` layer. */\n  slot?: { id: string; forLayer: string },\n): RenderLayer<unknown> {\n  const toPose =\n    cfg.toPose ??\n    ((obj: TNode) => (adapter ? adapter.getPose(obj.id) : (obj as unknown as TPose)));\n  const { drawOne, derivedPathOf } = withAdapterDerivedPaths(cfg, adapter, toPose);\n  const postProcess = cfg.postProcess;\n  const finish = cfg.cull\n    ? (cmds: DrawCommand[], view: View, dims: Dims): DrawCommand[] =>\n      cullDrawCommands(cmds, viewToMat3(view), { x: 0, y: 0, width: dims.width, height: dims.height })\n    : (cmds: DrawCommand[]): DrawCommand[] => cmds;\n  const paintBounds = cfg.cull ? cfg.paintBounds : undefined;\n  const culledIn = (view: View, dims: Dims) => paintBounds\n    ? paintMissesView(paintBounds, view, { x: 0, y: 0, width: dims.width, height: dims.height })\n    : undefined;\n  return {\n    id: slot?.id ?? 'scene',\n    label: slot ? `Scene: ${slot.forLayer}` : 'Scene',\n    draw: (data, view, dims) => {\n      const debugSink = debugSinkFrom(data);\n      const hidden = hideIds();\n      const a = adapter;\n      if (a && cfg.objects === undefined && drawOne) {\n        const filteredDrawOne = (obj: TNode, pose: TPose, v: View): DrawCommand[] => {\n          if (hidden && hidden.has(obj.id)) return [];\n          const cmds = drawOne(obj, pose, v);\n          if (debugSink) {\n            const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n            if (b) debugSink.recordBounds(obj.id, b);\n            const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n            const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n            debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n          }\n          return wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n        };\n        // Honor cfg.toPose on the hierarchical path by shimming getPose on the\n        // adapter so buildSceneTree routes through it instead of the raw adapter.\n        const hierarchicalAdapter = cfg.toPose\n          ? {\n              ...a,\n              getPose: (id: string) => {\n                const obj = a.getNode(id);\n                return obj ? toPose(obj) : a.getPose(id);\n              },\n            }\n          : a;\n        // World-space commands; drawLayers wraps in viewToMat3 automatically.\n        const tree = buildSceneTree(\n          hierarchicalAdapter as unknown as Parameters<typeof buildSceneTree>[0],\n          filteredDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n          view,\n          slot?.forLayer,\n          derivedPathOf as Parameters<typeof buildSceneTree>[4],\n          culledIn(view, dims) as Parameters<typeof buildSceneTree>[5],\n        );\n        return finish(postProcess ? postProcess(tree, view, dims) : tree, view, dims);\n      }\n      // `cfg.objects`: the caller's own list, which has no scene layers to split by.\n      const objects = cfg.objects ?? [];\n      const children: DrawCommand[] = [];\n      const culled = culledIn(view, dims);\n      for (const obj of objects) {\n        if (hidden && hidden.has(obj.id)) continue;\n        const pose: TPose = toPose(obj);\n        if (drawOne && !culled?.(obj, pose)) {\n          const cmds = drawOne(obj, pose, view);\n          const wrapped = wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n          for (const cmd of wrapped) children.push(cmd);\n        }\n        if (debugSink) {\n          const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n          if (b) debugSink.recordBounds(obj.id, { x: b.x, y: b.y, width: b.width, height: b.height });\n          const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n          const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n          debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n        }\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return finish(postProcess ? postProcess(children, view, dims) : children, view, dims);\n    },\n  };\n}\n\n/**\n * The scene slot as one canvas layer **per scene layer** — keyed `scene:<layerId>` — so\n * consumers can interleave custom layers *between* scene layers via the standard slot\n * anchoring (`before: 'scene:plantings'`). A single `scene` layer when `cfg.objects` replaces\n * the tree, or the adapter declares no layers.\n */\nexport function buildSceneLayers<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: HierarchicalAdapter<TNode, TPose> | undefined,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n): Array<{ key: string; layer: RenderLayer<unknown> }> {\n  const sceneLayerIds =\n    cfg.objects === undefined && adapter ? adapter.getLayers().map((l) => l.id) : null;\n  if (!sceneLayerIds || sceneLayerIds.length === 0) {\n    return [{ key: 'scene', layer: buildSceneLayer(cfg, adapter, boundsOfFn, hideIds) }];\n  }\n  return sceneLayerIds.map((id) => ({\n    key: sceneLayerKey(id),\n    layer: buildSceneLayer(cfg, adapter, boundsOfFn, hideIds, {\n      id: sceneLayerKey(id),\n      forLayer: id,\n    }),\n  }));\n}\n"],"mappings":"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"}

package/dist/canvas/buildSceneTree.js

@@ -1,51 +1,73 @@
 import { deriveParallaxView as e, planeMap as t } from "../core/viewport/parallax.js";
 import { definesFrame as n } from "../core/scene/effectivePose.js";
 import { clipCarrier as r, planeTransform as i } from "./planeClips.js";
-import { findShapeSilhouette as a } from "./NodeShape.js";
-import { scenePlaneOf as o } from "./pickWalk.js";
+import { splitOverChildren as a } from "./overChildren.js";
+import { findShapeSilhouette as o } from "./NodeShape.js";
+import { scenePlaneOf as s } from "./pickWalk.js";
+import { mat3 as c } from "@weasel-js/geom";
 //#region src/canvas/buildSceneTree.ts
-function s(e, t, n, r) {
+function l(e, t, n, r) {
 	let i = {
 		kind: "group",
 		children: e
 	};
-	for (let e = t.length - 1; e >= 0; e--) i = {
-		kind: "group",
-		children: [i],
-		clip: r(t[e].path, t[e].layer, n)
-	};
+	for (let e = t.length - 1; e >= 0; e--) {
+		let a = t[e];
+		i = "copy" in a ? {
+			kind: "group",
+			children: [i],
+			transform: c.fromAffine(a.copy)
+		} : {
+			kind: "group",
+			children: [i],
+			clip: r(a.path, a.layer, n)
+		};
+	}
 	return i;
 }
-function c(c, l, u, d, f, p) {
-	let m = c.getLayers(), h = /* @__PURE__ */ new Map();
-	for (let e of m) e.visible && h.set(e.id, []);
-	let g = null;
-	for (let t of m) t.parallax && (g ??= /* @__PURE__ */ new Map()).set(t.id, e(u, t.parallax));
-	let _ = c.composePose?.bind(c), v = r(g ? o(m, u) : null);
-	function y(e, t, r) {
-		let i = c.getNode(e);
-		if (!i) return;
-		let o = c.getPose(e), m = _ && r !== null ? _(r, o) : o, b = d === void 0 || i.layer === d ? h.get(i.layer) : void 0, x = g?.get(i.layer) ?? u, S = b && !p?.(i, m, x) ? l(i, m, x) : [], C = t, w = i;
-		if (w.kind === "container") {
+function u(c, u, d, f, p, m) {
+	let h = c.getLayers(), g = /* @__PURE__ */ new Map();
+	for (let e of h) e.visible && g.set(e.id, []);
+	let _ = null;
+	for (let t of h) t.parallax && (_ ??= /* @__PURE__ */ new Map()).set(t.id, e(d, t.parallax));
+	let v = c.composePose?.bind(c), y = r(_ ? s(h, d) : null);
+	function b(e, t, r, i) {
+		let s = c.getNode(e);
+		if (!s) return;
+		let h = c.getPose(e), x = v && r !== null ? v(r, h) : h, S = f === void 0 || s.layer === f ? g.get(s.layer) : void 0, C = _?.get(s.layer) ?? d, { under: w, over: T } = a(S && (i || !m?.(s, x, C)) ? u(s, x, C) : []), E = t, D = null, O = s;
+		if (O.kind === "container") {
 			let e;
-			e = typeof w.clipFromPose == "function" ? w.clipFromPose(m) : a(i, m, { derivedPath: f?.(i, m) }), e && (C = [...t, {
+			e = typeof O.clipFromPose == "function" ? O.clipFromPose(x) : o(s, x, { derivedPath: p?.(s, x) }), e && (D = {
 				path: e,
-				layer: i.layer
-			}]);
+				layer: s.layer
+			}, E = [...t, D]);
+		}
+		S && S.push(E.length > 0 ? l(w, E, s.layer, y) : {
+			kind: "group",
+			children: w
+		});
+		let k = n(s) ? x : r, A = c.getChildren(e);
+		for (let e of A) b(e, E, k, i);
+		let j = typeof O.copiesFromPose == "function" ? O.copiesFromPose(x, s) : null;
+		for (let e of j ?? []) {
+			let n = [
+				...t,
+				{ copy: e },
+				...D ? [D] : []
+			];
+			for (let e of A) b(e, n, k, !0);
 		}
-		b && b.push(C.length > 0 ? s(S, C, i.layer, v) : {
+		S && T.length > 0 && S.push(E.length > 0 ? l(T, E, s.layer, y) : {
 			kind: "group",
-			children: S
+			children: T
 		});
-		let T = n(i) ? m : r;
-		for (let t of c.getChildren(e)) y(t, C, T);
 	}
-	for (let e of c.getChildren(null)) y(e, [], null);
-	let b = [];
-	for (let e of m) {
-		if (!e.visible || d !== void 0 && e.id !== d) continue;
-		let n = h.get(e.id) ?? [], r = e.parallax ? i(t(u, e.parallax), null) : void 0;
-		b.push(r ? {
+	for (let e of c.getChildren(null)) b(e, [], null, !1);
+	let x = [];
+	for (let e of h) {
+		if (!e.visible || f !== void 0 && e.id !== f) continue;
+		let n = g.get(e.id) ?? [], r = e.parallax ? i(t(d, e.parallax), null) : void 0;
+		x.push(r ? {
 			kind: "group",
 			transform: r,
 			children: n
@@ -54,9 +76,9 @@ function c(c, l, u, d, f, p) {
 			children: n
 		});
 	}
-	return b;
+	return x;
 }
 //#endregion
-export { c as buildSceneTree };
+export { u as buildSceneTree };
 
 //# sourceMappingURL=buildSceneTree.js.map

package/dist/canvas/buildSceneTree.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildSceneTree.js","names":["wrapInClips","node","cmds","i","clips","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","bucket","forLayer","v","self","culled","drawOne","ownClips","ancestorClips","maybeContainer","clip","findShapeSilhouette","derivedPathOf","childFrame","definesFrame","cid","rootId","out","layer","children","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '../renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport type { Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\n\n/**\n * The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter`\n * satisfies this; flat (non-hierarchical) adapters don't. Canvas exposes these\n * as *optional* methods on `CanvasProps.adapter` (see `OptionalSceneHierarchy`)\n * and feature-detects them at draw time.\n */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in. */\ninterface ChainClip { path: Path; layer: string }\n\n/** Wrap `cmds` in one nested group per clip so the renderer intersects them.\n *  Outermost group carries the ancestor-most clip; innermost holds `cmds`. */\nfunction wrapInClips(\n  cmds: DrawCommand[],\n  clips: readonly ChainClip[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = clips.length - 1; i >= 0; i--) {\n    node = { kind: 'group', children: [node], clip: carry(clips[i].path, clips[i].layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the\n * bucket for **that node's own `layer`** — not its parent's. So a child whose\n * `layer` differs from its parent (e.g. a planting tagged into a top-most\n * `plantings` layer while remaining a scene child of its container) draws in\n * its own layer's pass, on top of every container body, while staying a tree\n * child for hit-testing / move / reparent.\n *\n * Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * **Positioning** is world-space: `drawOne` returns world-coord commands (the\n * caller wraps the whole thing in the view transform). Because a node may be\n * drawn outside its parent's group, the tree nesting cannot carry geometry as\n * renderer state; instead the walk folds each node's pose into its parent's\n * frame on the way down and hands the painter a **world** pose. Clips are\n * accumulated the same way and are world-space for the same reason — each in\n * its container's plane, carried into the plane of the node it clips.\n *\n * With no `composePose` on the adapter the fold is the identity, every node\n * paints at its stored pose, and this is the absolute-pose behavior the kit\n * shipped before frames existed.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the\n * view derived for it, and its group carries the transform from its world to\n * the camera's, so the caller's single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. Used to render\n   *  scene layers as separate, individually-orderable canvas slots. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses. Only a\n   *  scene-backed caller can answer — deriving needs the dependencies' poses —\n   *  so the bare-adapter path omits it and a derived container contributes no\n   *  clip there, exactly as before. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  // A hidden layer gets no bucket, and a node with no bucket is not painted.\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) if (l.visible) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainClip[],\n    parentFrame: TPose | null,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const bucket = forLayer === undefined || node.layer === forLayer\n      ? buckets.get(node.layer) : undefined;\n    const v = planeViews?.get(node.layer) ?? view;\n    const self = bucket && !culled?.(node, pose, v) ? drawOne(node, pose, v) : [];\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    const maybeContainer = node as { kind?: string; clipFromPose?: (pose: TPose) => unknown };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → fall back to the painter silhouette for the\n        // container's shape kind. Built-ins give rect-fallback containers\n        // their own AABB as a clip; consumer painters can provide arbitrary\n        // closed shapes (ellipse, polygon, …) without per-node wiring.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) ownClips = [...ancestorClips, { path: clip as Path, layer: node.layer }];\n    }\n\n    // Emit this node's own paint into its own layer's bucket, clipped by the\n    // accumulated chain (ancestors + own). Every node emits a wrapper group\n    // even with empty paint, keeping the per-node tree shape stable.\n    if (bucket) {\n      bucket.push(ownClips.length > 0 ? wrapInClips(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, childFrame);\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":";;;;;;AAgCA,SAASA,EACP,GACA,GACA,GACA,GACa;CACb,IAAIC,IAAyB;EAAE,MAAM;EAAS,UAAUC;CAAK;CAC7D,KAAK,IAAIC,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KACrC,IAAO;EAAE,MAAM;EAAS,UAAU,CAACF,CAAI;EAAG,MAAMI,EAAMD,EAAMD,EAAE,CAAC,MAAMC,EAAMD,EAAE,CAAC,OAAOG,CAAO;CAAE;CAEhG,OAAOL;AACT;AA4BA,SAAgBM,EAId,GACA,GACA,GAIA,GAKA,GAGA,GACe;CACf,IAAMC,IAASC,EAAQ,UAAU,GAE3BC,oBAAU,IAAI,IAA2B;CAC/C,KAAK,IAAMC,KAAKH,GAAQ,AAAIG,EAAE,WAASD,EAAQ,IAAIC,EAAE,IAAI,CAAC,CAAC;CAC3D,IAAIC,IAAuC;CAC3C,KAAK,IAAMD,KAAKH,GACd,AAAIG,EAAE,aAAW,sBAAe,IAAI,IAAI,EAAA,CAAG,IAAIA,EAAE,IAAIE,EAAmBC,GAAMH,EAAE,QAAQ,CAAC;CAG3F,IAAMI,IAAUN,EAAQ,aAAa,KAAKA,CAAO,GAC3CJ,IAAQW,EAAYJ,IAAaK,EAAaT,GAAQM,CAAI,IAAI,IAAI;CAExE,SAASI,EACP,GACA,GACA,GACM;EACN,IAAMjB,IAAOQ,EAAQ,QAAQU,CAAE;EAC/B,IAAI,CAAClB,GAAM;EACX,IAAMmB,IAAQX,EAAQ,QAAQU,CAAE,GAG1BE,IAAON,KAAWO,MAAgB,OAAOP,EAAQO,GAAaF,CAAK,IAAIA,GAGvEG,IAASC,MAAa,KAAA,KAAavB,EAAK,UAAUuB,IACpDd,EAAQ,IAAIT,EAAK,KAAK,IAAI,KAAA,GACxBwB,IAAIb,GAAY,IAAIX,EAAK,KAAK,KAAKa,GACnCY,IAAOH,KAAU,CAACI,IAAS1B,GAAMoB,GAAMI,CAAC,IAAIG,EAAQ3B,GAAMoB,GAAMI,CAAC,IAAI,CAAC,GAGxEI,IAAWC,GACTC,IAAiB9B;EACvB,IAAI8B,EAAe,SAAS,aAAa;GACvC,IAAIC;GAeJ,AAdA,AAQEA,IARE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAaV,CAAI,IAMhCY,EACLhC,GACAoB,GACA,EAAE,aAAaa,IAAgBjC,GAAMoB,CAAI,EAAE,CAC7C,GAEEW,MAAM,IAAW,CAAC,GAAGF,GAAe;IAAE,MAAME;IAAc,OAAO/B,EAAK;GAAM,CAAC;EACnF;EAKA,AAAIsB,KACFA,EAAO,KAAKM,EAAS,SAAS,IAAI7B,EAAY0B,GAAMG,GAAU5B,EAAK,OAAOI,CAAK,IAAI;GAAE,MAAM;GAAS,UAAUqB;EAAK,CAAC;EAItH,IAAMS,IAAaC,EAAanC,CAAa,IAAIoB,IAAOC;EACxD,KAAK,IAAMe,KAAO5B,EAAQ,YAAYU,CAAE,GAAG,EAAMkB,GAAKR,GAAUM,CAAU;CAC5E;CAEA,KAAK,IAAMG,KAAU7B,EAAQ,YAAY,IAAI,GAAG,EAAM6B,GAAQ,CAAC,GAAG,IAAI;CAEtE,IAAMC,IAAqB,CAAC;CAC5B,KAAK,IAAMC,KAAShC,GAAQ;EAE1B,IADI,CAACgC,EAAM,WACPhB,MAAa,KAAA,KAAagB,EAAM,OAAOhB,GAAU;EACrD,IAAMiB,IAAW/B,EAAQ,IAAI8B,EAAM,EAAE,KAAK,CAAC,GACrCE,IAAYF,EAAM,WAAWG,EAAeC,EAAS9B,GAAM0B,EAAM,QAAQ,GAAG,IAAI,IAAI,KAAA;EAC1F,EAAI,KAAKE,IAAY;GAAE,MAAM;GAAS;GAAW;EAAS,IAAI;GAAE,MAAM;GAAS;EAAS,CAAC;CAC3F;CACA,OAAOH;AACT"}
+{"version":3,"file":"buildSceneTree.js","names":["wrapInChain","node","cmds","i","chain","e","mat3","carry","toLayer","buildSceneTree","layers","adapter","buckets","l","planeViews","deriveParallaxView","view","compose","clipCarrier","scenePlaneOf","visit","id","local","pose","parentFrame","bucket","forLayer","v","self","splitOverChildren","copied","culled","drawOne","ownClips","ancestorClips","ownClip","maybeContainer","clip","findShapeSilhouette","derivedPathOf","childFrame","definesFrame","children","cid","copies","copy","over","rootId","out","layer","transform","planeTransform","planeMap"],"sources":["../../src/canvas/buildSceneTree.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport { findShapeSilhouette } from './NodeShape';\nimport type { Node } from 'core/scene/types';\nimport { mat3, type Affine, type Path } from '@weasel-js/geom';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport { deriveParallaxView, planeMap, type ParallaxOpts } from 'core/viewport/parallax';\nimport { scenePlaneOf } from './pickWalk';\nimport { clipCarrier, planeTransform } from './planeClips';\nimport { splitOverChildren } from './overChildren';\n\n/** The scene-tree reading surface `buildSceneTree` walks. A `SceneCanvasAdapter` is one. */\nexport interface HierarchicalAdapter<TNode, TPose> {\n  getLayers(): readonly { id: string; visible: boolean; parallax?: ParallaxOpts }[];\n  getNode(id: string): TNode | undefined;\n  getChildren(parentId: string | null): readonly string[];\n  getPose(id: string): TPose;\n  /** Folds a child's local pose into its parent's frame. Absent means the\n   *  scene stores absolute poses and a parent contributes no transform —\n   *  see `PoseComposition`. */\n  composePose?(parent: TPose, child: TPose): TPose;\n}\n\n/** A clip on the chain, with the layer whose world it is drawn in, or the\n *  transform of a copy a container draws — see `ContainerNode.copiesFromPose`. */\ntype ChainEntry = { path: Path; layer: string } | { copy: Affine };\n\n/** Wrap `cmds` in one nested group per chain entry, so the renderer intersects\n *  the clips and applies each copy's transform to everything inside it.\n *  Outermost group carries the ancestor-most entry; innermost holds `cmds`. */\nfunction wrapInChain(\n  cmds: DrawCommand[],\n  chain: readonly ChainEntry[],\n  toLayer: string,\n  carry: ReturnType<typeof clipCarrier>,\n): DrawCommand {\n  let node: GroupDrawCommand = { kind: 'group', children: cmds };\n  for (let i = chain.length - 1; i >= 0; i--) {\n    const e = chain[i];\n    node = 'copy' in e\n      ? { kind: 'group', children: [node], transform: mat3.fromAffine(e.copy) }\n      : { kind: 'group', children: [node], clip: carry(e.path, e.layer, toLayer) };\n  }\n  return node;\n}\n\n/**\n * Walk the adapter's scene tree once and emit each node's own paint into the bucket for\n * **that node's own `layer`** — not its parent's. So a child whose `layer` differs from its\n * parent draws in its own layer's pass while staying a tree child for hit-testing / move /\n * reparent. Output is one group per visible layer, in adapter (`getLayers`) order.\n *\n * A node paints before its children. What its `drawOne` wraps in `overChildren` paints after\n * them instead, in the node's own layer.\n *\n * `drawOne` returns world-coord commands. Because a node may be drawn outside its parent's\n * group, the tree nesting cannot carry geometry as renderer state; the walk folds each node's\n * pose into its parent's frame on the way down and hands the painter a **world** pose. Clips\n * are accumulated the same way — each in its container's plane, carried into the plane of the\n * node it clips. With no `composePose` on the adapter the fold is the identity.\n *\n * A layer carrying `parallax` is a plane: its painters and its cull see the view derived for\n * it, and its group carries the transform from its world to the camera's, so the caller's\n * single camera wrap still lands it right.\n */\nexport function buildSceneTree<\n  TNode extends { id: string; layer: string },\n  TPose,\n>(\n  adapter: HierarchicalAdapter<TNode, TPose>,\n  drawOne: (obj: TNode, pose: TPose, view: View) => DrawCommand[],\n  view: View,\n  /** When set, only nodes on this layer paint (others are still walked for\n   *  ancestor clips) and only this layer's group is returned. */\n  forLayer?: string,\n  /** The path a container computes from its dependencies' poses: the scene's\n   *  lookup, or `adapterDerivedPathOf` for an adapter with no scene. Left out,\n   *  a derived container contributes no clip. */\n  derivedPathOf?: (node: TNode, pose: TPose) => Path | null,\n  /** True for a node whose paint cannot be seen — see `paintMissesView`. Its\n   *  painter is not called; its clip and its children are walked as usual. */\n  culled?: (node: TNode, pose: TPose, view: View) => boolean,\n): DrawCommand[] {\n  const layers = adapter.getLayers();\n  // A hidden layer gets no bucket, and a node with no bucket is not painted.\n  const buckets = new Map<string, DrawCommand[]>();\n  for (const l of layers) if (l.visible) buckets.set(l.id, []);\n  let planeViews: Map<string, View> | null = null;\n  for (const l of layers) {\n    if (l.parallax) (planeViews ??= new Map()).set(l.id, deriveParallaxView(view, l.parallax));\n  }\n\n  const compose = adapter.composePose?.bind(adapter);\n  const carry = clipCarrier(planeViews ? scenePlaneOf(layers, view) : null);\n\n  function visit(\n    id: string,\n    ancestorClips: readonly ChainEntry[],\n    parentFrame: TPose | null,\n    /** Under a copy: the pose is not where it paints, so the cull cannot judge it. */\n    copied: boolean,\n  ): void {\n    const node = adapter.getNode(id);\n    if (!node) return;\n    const local = adapter.getPose(id);\n    // Fold once, on the way down: O(1) per node where walking the parent chain\n    // per node would be O(depth).\n    const pose = compose && parentFrame !== null ? compose(parentFrame, local) : local;\n    // Skip the (potentially expensive) painter for nodes we won't emit; their\n    // clip still extends the chain for descendants below.\n    const bucket = forLayer === undefined || node.layer === forLayer\n      ? buckets.get(node.layer) : undefined;\n    const v = planeViews?.get(node.layer) ?? view;\n    const { under: self, over } = splitOverChildren(\n      bucket && (copied || !culled?.(node, pose, v)) ? drawOne(node, pose, v) : [],\n    );\n\n    // Extend the clip chain with this node's own clip when it is a container.\n    let ownClips = ancestorClips;\n    let ownClip: ChainEntry | null = null;\n    const maybeContainer = node as {\n      kind?: string;\n      clipFromPose?: (pose: TPose) => unknown;\n      copiesFromPose?: (pose: TPose, node: unknown) => readonly Affine[] | null;\n    };\n    if (maybeContainer.kind === 'container') {\n      let clip: unknown;\n      if (typeof maybeContainer.clipFromPose === 'function') {\n        // Explicit per-node clip wins — no fallback to the painter silhouette.\n        clip = maybeContainer.clipFromPose(pose);\n      } else {\n        // No explicit clip → the painter silhouette for the container's shape kind.\n        clip = findShapeSilhouette(\n          node as unknown as Node<unknown, string, TPose>,\n          pose,\n          { derivedPath: derivedPathOf?.(node, pose) },\n        );\n      }\n      if (clip) {\n        ownClip = { path: clip as Path, layer: node.layer };\n        ownClips = [...ancestorClips, ownClip];\n      }\n    }\n\n    // Every node emits a wrapper group even with empty paint, keeping the per-node tree\n    // shape stable.\n    if (bucket) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(self, ownClips, node.layer, carry) : { kind: 'group', children: self });\n    }\n\n    // An envelope's children share its own parent's frame.\n    const childFrame = definesFrame(node as never) ? pose : parentFrame;\n    const children = adapter.getChildren(id);\n    for (const cid of children) visit(cid, ownClips, childFrame, copied);\n\n    // A copy is a copy of the clipped content, so its transform encloses the\n    // container's own clip and sits inside every clip above it.\n    const copies = typeof maybeContainer.copiesFromPose === 'function'\n      ? maybeContainer.copiesFromPose(pose, node) : null;\n    for (const copy of copies ?? []) {\n      const chain: ChainEntry[] = [...ancestorClips, { copy }, ...(ownClip ? [ownClip] : [])];\n      for (const cid of children) visit(cid, chain, childFrame, true);\n    }\n\n    if (bucket && over.length > 0) {\n      bucket.push(ownClips.length > 0 ? wrapInChain(over, ownClips, node.layer, carry) : { kind: 'group', children: over });\n    }\n  }\n\n  for (const rootId of adapter.getChildren(null)) visit(rootId, [], null, false);\n\n  const out: DrawCommand[] = [];\n  for (const layer of layers) {\n    if (!layer.visible) continue;\n    if (forLayer !== undefined && layer.id !== forLayer) continue;\n    const children = buckets.get(layer.id) ?? [];\n    const transform = layer.parallax ? planeTransform(planeMap(view, layer.parallax), null) : undefined;\n    out.push(transform ? { kind: 'group', transform, children } : { kind: 'group', children });\n  }\n  return out;\n}\n"],"mappings":"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"}