@weasel-js/core 1.9.4 → 1.10.0

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.region.cursor !== undefined ? { cursor: hit.region.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,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;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":"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"}
+{"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  /** 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 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.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":["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 '@weasel-js/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/** 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. */\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 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 * `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 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 → 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) ownClips = [...ancestorClips, { path: clip as Path, layer: node.layer }];\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 ? 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":";;;;;;AA2BA,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;AAkBA,SAAgBM,EAId,GACA,GACA,GAGA,GAIA,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;GAYJ,AAXA,AAKEA,IALE,OAAOD,EAAe,gBAAiB,aAElCA,EAAe,aAAaV,CAAI,IAGhCY,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;EAIA,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"}

package/dist/canvas/canvasRenderer.js

@@ -1,37 +1,38 @@
-import { WeaselRenderer as e } from "../renderer/WeaselRenderer.js";
-import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
+import { WeaselRenderer as e } from "@weasel-js/renderer";
+import { viewToMat3 as t } from "@weasel-js/geom";
+import { createEmitter as n } from "@weasel-js/registry";
 //#region src/canvas/canvasRenderer.ts
-var n = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakSet(), i = (e) => e?.map((e) => e.id).join("|") ?? "";
-function a(e, t) {
+var r = /* @__PURE__ */ new WeakMap(), i = /* @__PURE__ */ new WeakSet(), a = (e) => e?.map((e) => e.id).join("|") ?? "";
+function o(e, t) {
 	if (t) for (let n of t) try {
 		e.registerProgram(n);
 	} catch (e) {
 		console.warn(`weasel: failed to register shader "${n.id}":`, e);
 	}
 }
-function o(e) {
-	let t = n.get(e.canvas);
-	t?.delete(e.renderer), e.canvas.removeEventListener("webglcontextlost", e.onLost), e.canvas.removeEventListener("webglcontextrestored", e.onRestored), t && t.size === 0 && n.delete(e.canvas), e.renderer.dispose();
+function s(e) {
+	let t = r.get(e.canvas);
+	t?.delete(e.renderer), e.canvas.removeEventListener("webglcontextlost", e.onLost), e.canvas.removeEventListener("webglcontextrestored", e.onRestored), t && t.size === 0 && r.delete(e.canvas), e.renderer.dispose();
 }
-function s() {
-	let s = null, c = /* @__PURE__ */ new Set(), l = (t, l, u = {}) => {
-		let { width: d, height: f } = l, p = l.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), m = u.tile ?? null, h = m !== null;
-		if (s && (s.canvas !== t || s.shared !== h) && (o(s), s = null), s) (!h && (t.width !== Math.round(d * p) || t.height !== Math.round(f * p)) || s.width !== d || s.height !== f || s.dpr !== p) && (s.renderer.resize({
+function c() {
+	let c = null, l = n(), u = (t, n, u = {}) => {
+		let { width: d, height: f } = n, p = n.dpr ?? (typeof window < "u" && window.devicePixelRatio || 1), m = u.tile ?? null, h = m !== null;
+		if (c && (c.canvas !== t || c.shared !== h) && (s(c), c = null), c) (!h && (t.width !== Math.round(d * p) || t.height !== Math.round(f * p)) || c.width !== d || c.height !== f || c.dpr !== p) && (c.renderer.resize({
 			width: d,
 			height: f,
 			dpr: p
-		}), s.width = d, s.height = f, s.dpr = p), s.flattenTolerance !== u.flattenTolerance && (s.renderer.setFlattenTolerance(u.flattenTolerance), s.flattenTolerance = u.flattenTolerance);
+		}), c.width = d, c.height = f, c.dpr = p), c.flattenTolerance !== u.flattenTolerance && (c.renderer.setFlattenTolerance(u.flattenTolerance), c.flattenTolerance = u.flattenTolerance);
 		else {
-			if (r.has(t)) return null;
-			let i = t.getContext("webgl2", {
+			if (i.has(t)) return null;
+			let n = t.getContext("webgl2", {
 				preserveDrawingBuffer: !0,
 				stencil: !0
 			});
-			if (!i || typeof i.enable != "function") return null;
+			if (!n || typeof n.enable != "function") return null;
 			let a;
 			try {
 				a = new e({
-					gl: i,
+					gl: n,
 					...h ? {} : { canvas: t },
 					width: d,
 					height: f,
@@ -39,9 +40,9 @@ function s() {
 					flattenTolerance: u.flattenTolerance
 				});
 			} catch (e) {
-				return i.isContextLost?.() || (r.add(t), console.warn("weasel: this canvas cannot be painted:", e)), null;
+				return n.isContextLost?.() || (i.add(t), console.warn("weasel: this canvas cannot be painted:", e)), null;
 			}
-			let o = s = {
+			let o = c = {
 				canvas: t,
 				renderer: a,
 				shared: h,
@@ -57,49 +58,44 @@ function s() {
 					o.lost = !0;
 				},
 				onRestored: () => {
-					o.lost = !1;
-					for (let e of [...c]) e();
+					o.lost = !1, l.emit();
 				}
 			};
-			t.addEventListener("webglcontextlost", s.onLost), t.addEventListener("webglcontextrestored", s.onRestored);
-			let l = n.get(t);
-			l || (l = /* @__PURE__ */ new Set(), n.set(t, l)), l.add(a);
+			t.addEventListener("webglcontextlost", c.onLost), t.addEventListener("webglcontextrestored", c.onRestored);
+			let s = r.get(t);
+			s || (s = /* @__PURE__ */ new Set(), r.set(t, s)), s.add(a);
 		}
-		if (s.lost) return null;
-		let { renderer: g } = s, _ = i(u.shaders);
-		_ !== s.shaderKey && (a(g, u.shaders), s.shaderKey = _);
+		if (c.lost) return null;
+		let { renderer: g } = c, _ = a(u.shaders);
+		_ !== c.shaderKey && (o(g, u.shaders), c.shaderKey = _);
 		let v = m?.x ?? null, y = m?.y ?? null;
-		return (v !== s.tileX || y !== s.tileY) && (g.setTarget(m ? { origin: {
+		return (v !== c.tileX || y !== c.tileY) && (g.setTarget(m ? { origin: {
 			x: m.x,
 			y: m.y
-		} } : null), s.tileX = v, s.tileY = y), g;
+		} } : null), c.tileX = v, c.tileY = y), g;
 	};
 	return {
-		bind: l,
+		bind: u,
 		paint(e, n, r, i, a) {
-			let o = l(e, i, a);
+			let o = u(e, i, a);
 			return o ? (o.render(n, t(r), a?.render), !0) : !1;
 		},
-		subscribeRestored(e) {
-			return c.add(e), () => {
-				c.delete(e);
-			};
-		},
+		subscribeRestored: l.subscribe,
 		release() {
-			s && o(s), s = null;
+			c && s(c), c = null;
 		}
 	};
 }
-var c = /* @__PURE__ */ new WeakMap();
-function l(e, t, n, r) {
-	let i = c.get(e);
-	return i || (i = s(), c.set(e, i)), i.paint(e, t, n, r);
+var l = /* @__PURE__ */ new WeakMap();
+function u(e, t, n, r) {
+	let i = l.get(e);
+	return i || (i = c(), l.set(e, i)), i.paint(e, t, n, r);
 }
-function u(e) {
-	let t = c.get(e);
-	t && (c.delete(e), t.release());
+function d(e) {
+	let t = l.get(e);
+	t && (l.delete(e), t.release());
 }
 //#endregion
-export { s as leaseCanvasRenderer, l as paintCanvas, u as releaseCanvasRenderer };
+export { c as leaseCanvasRenderer, u as paintCanvas, d as releaseCanvasRenderer, a as shaderKeyOf };
 
 //# sourceMappingURL=canvasRenderer.js.map

package/dist/canvas/canvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"canvasRenderer.js","names":["TENANTS","REFUSED","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","restoredSubs","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","mine","fn","shaderKey","tileX","tileY","commands","viewToMat3","view","CANVAS_LEASES","paintCanvas","lease","releaseCanvasRenderer"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface — `<Canvas>`,\n * `<SceneViewCanvas>`, `<MinimapCanvas>`, `<DrawCanvas>` — holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease (the detached ones via\n * `useCanvasRenderer`): created on first paint, resized when the surface's\n * size or density changes, rebuilt when the surface moves to another element,\n * and freed on release.\n *\n * A lease holds its own renderer, so several can share one element: each\n * tenant painting a `tile` of a shared buffer gets a renderer of its own on\n * the element's one context. Release frees only what that renderer created;\n * the context itself is never lost.\n */\nimport { WeaselRenderer, type RenderOptions } from '../renderer/WeaselRenderer';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { ShaderProgramHandle } from '../renderer/shaders/registerProgram';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** Canvases whose context the renderer refused, so a redraw does not rebuild\n *  and fail again, and the reason is reported once. */\nconst REFUSED: WeakSet<HTMLCanvasElement> = new WeakSet();\n\n/** A renderer painting into the canvas, if any lease holds one. Test seam. */\nexport function cachedCanvasRenderer(canvas: HTMLCanvasElement): WeaselRenderer | undefined {\n  const set = TENANTS.get(canvas);\n  return set ? set.values().next().value : undefined;\n}\n\n/** The size and density to paint a canvas at. `dpr` defaults to\n *  `window.devicePixelRatio`, read per paint. */\nexport interface CanvasPaintSize {\n  width: number;\n  height: number;\n  dpr?: number;\n}\n\n/** How one paint reaches the canvas, beyond its size. */\nexport interface CanvasPaintOptions {\n  /** Paint a `width × height` tile of a buffer other surfaces share, at this\n   *  origin in CSS pixels. The buffer is then the caller's to size: the\n   *  renderer never resizes the element, which would have every co-tenant\n   *  resize it to its own pane. Omit to own the whole element. */\n  tile?: { x: number; y: number } | null;\n  /** `WeaselRendererOptions.flattenTolerance`, applied from this paint on. */\n  flattenTolerance?: number;\n  /** Custom programs to compile on the renderer. Compiled when the renderer\n   *  is created, and again when the set of ids changes. */\n  shaders?: readonly ShaderProgramHandle[];\n}\n\n/** A paint's options, plus what `paint` hands `WeaselRenderer.render`. */\nexport interface CanvasRenderOptions extends CanvasPaintOptions {\n  render?: RenderOptions;\n}\n\n/** A canvas renderer held for a surface's lifetime. */\nexport interface CanvasRendererLease {\n  /** Draw `commands` into `canvas` — screen-space, one unit per CSS pixel,\n   *  with `view` passed on as the frame's world→screen transform. `bind`,\n   *  then render. Returns `false` without painting where `bind` finds no\n   *  renderer. */\n  paint(\n    canvas: HTMLCanvasElement,\n    commands: DrawCommand[],\n    view: View,\n    size: CanvasPaintSize,\n    options?: CanvasRenderOptions,\n  ): boolean;\n  /** The renderer that paints `canvas` at `size`, ready to render: created on\n   *  first use, resized, and given this paint's tile, tolerance and shaders.\n   *  Frees the previous renderer first if the surface moved to another\n   *  element, or between owning it whole and painting a tile of it. `null`\n   *  where no WebGL2 context is available (jsdom, a failed context creation,\n   *  or a context that is lost for now), so a caller can skip building a frame\n   *  nobody will see. */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Run `fn` when the canvas gets a lost context back, after the renderer\n   *  has rebuilt itself on it. Nothing repaints a restored buffer on its own.\n   *  Returns an unsubscribe. */\n  subscribeRestored(fn: () => void): () => void;\n  /** Free the held renderer and every GL object it owns. A later `paint`\n   *  creates a fresh one. */\n  release(): void;\n}\n\ninterface Held {\n  canvas: HTMLCanvasElement;\n  renderer: WeaselRenderer;\n  shared: boolean;\n  lost: boolean;\n  onLost: () => void;\n  onRestored: () => void;\n  width: number;\n  height: number;\n  dpr: number;\n  tileX: number | null;\n  tileY: number | null;\n  flattenTolerance: number | undefined;\n  shaderKey: string;\n}\n\nconst shaderKeyOf = (shaders: readonly ShaderProgramHandle[] | undefined): string =>\n  shaders?.map((h) => h.id).join('|') ?? '';\n\nfunction registerShaders(renderer: WeaselRenderer, shaders: readonly ShaderProgramHandle[] | undefined): void {\n  if (!shaders) return;\n  for (const handle of shaders) {\n    try {\n      renderer.registerProgram(handle);\n    } catch (e) {\n      console.warn(`weasel: failed to register shader \"${handle.id}\":`, e);\n    }\n  }\n}\n\nfunction free(held: Held): void {\n  const set = TENANTS.get(held.canvas);\n  set?.delete(held.renderer);\n  held.canvas.removeEventListener('webglcontextlost', held.onLost);\n  held.canvas.removeEventListener('webglcontextrestored', held.onRestored);\n  if (set && set.size === 0) TENANTS.delete(held.canvas);\n  held.renderer.dispose();\n}\n\n/** Hold the renderer of the canvas a surface paints into, until released. */\nexport function leaseCanvasRenderer(): CanvasRendererLease {\n  let held: Held | null = null;\n  const restoredSubs = new Set<() => void>();\n  const bind = (canvas: HTMLCanvasElement, size: CanvasPaintSize, options: CanvasPaintOptions = {}): WeaselRenderer | null => {\n    const { width, height } = size;\n    const dpr = size.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1);\n    const tile = options.tile ?? null;\n    const shared = tile !== null;\n\n    if (held && (held.canvas !== canvas || held.shared !== shared)) {\n      free(held);\n      held = null;\n    }\n    if (!held) {\n      if (REFUSED.has(canvas)) return null;\n      const gl = canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true });\n      if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') return null;\n      let renderer: WeaselRenderer;\n      try {\n        renderer = new WeaselRenderer({\n          gl: gl as WebGL2RenderingContext,\n          ...(shared ? {} : { canvas }),\n          width, height, dpr,\n          flattenTolerance: options.flattenTolerance,\n        });\n      } catch (e) {\n        // A lost context fails to compile and may yet come back; anything\n        // else fails the same way next time.\n        if (!(gl as Partial<WebGL2RenderingContext>).isContextLost?.()) {\n          REFUSED.add(canvas);\n          console.warn('weasel: this canvas cannot be painted:', e);\n        }\n        return null;\n      }\n      // Added after the renderer's own listeners, so a subscriber runs against\n      // a renderer that has already recompiled.\n      const mine: Held = held = {\n        canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, shaderKey: '',\n        lost: false,\n        onLost: () => { mine.lost = true; },\n        onRestored: () => {\n          mine.lost = false;\n          for (const fn of [...restoredSubs]) fn();\n        },\n      };\n      canvas.addEventListener('webglcontextlost', held.onLost);\n      canvas.addEventListener('webglcontextrestored', held.onRestored);\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      // React writes the element's `width` and `height` attributes in CSS\n      // pixels on every size change, so a size that went away and came back\n      // matches the record while the buffer does not.\n      const stale = !shared\n        && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr));\n      if (stale || held.width !== width || held.height !== height || held.dpr !== dpr) {\n        held.renderer.resize({ width, height, dpr });\n        held.width = width;\n        held.height = height;\n        held.dpr = dpr;\n      }\n      if (held.flattenTolerance !== options.flattenTolerance) {\n        held.renderer.setFlattenTolerance(options.flattenTolerance);\n        held.flattenTolerance = options.flattenTolerance;\n      }\n    }\n\n    if (held.lost) return null;\n    const { renderer } = held;\n    const shaderKey = shaderKeyOf(options.shaders);\n    if (shaderKey !== held.shaderKey) {\n      registerShaders(renderer, options.shaders);\n      held.shaderKey = shaderKey;\n    }\n    const tileX = tile?.x ?? null;\n    const tileY = tile?.y ?? null;\n    if (tileX !== held.tileX || tileY !== held.tileY) {\n      renderer.setTarget(tile ? { origin: { x: tile.x, y: tile.y } } : null);\n      held.tileX = tileX;\n      held.tileY = tileY;\n    }\n    return renderer;\n  };\n  return {\n    bind,\n    paint(canvas, commands, view, size, options) {\n      const renderer = bind(canvas, size, options);\n      if (!renderer) return false;\n      renderer.render(commands, viewToMat3(view), options?.render);\n      return true;\n    },\n    subscribeRestored(fn) {\n      restoredSubs.add(fn);\n      return () => { restoredSubs.delete(fn); };\n    },\n    release() {\n      if (held) free(held);\n      held = null;\n    },\n  };\n}\n\n/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */\nconst CANVAS_LEASES: WeakMap<HTMLCanvasElement, CanvasRendererLease> = new WeakMap();\n\n/**\n * Paint `canvas` through a lease held for the element itself, for callers\n * with no component lifetime of their own (`renderSceneToCanvas`). The\n * renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function paintCanvas(\n  canvas: HTMLCanvasElement,\n  commands: DrawCommand[],\n  view: View,\n  size: CanvasPaintSize,\n): boolean {\n  let lease = CANVAS_LEASES.get(canvas);\n  if (!lease) {\n    lease = leaseCanvasRenderer();\n    CANVAS_LEASES.set(canvas, lease);\n  }\n  return lease.paint(canvas, commands, view, size);\n}\n\n/** Free the renderer `paintCanvas` holds for the canvas, and every GL object\n *  it owns. The next paint creates a fresh one. Renderers a surface component\n *  holds are that component's to free, on unmount. */\nexport function releaseCanvasRenderer(canvas: HTMLCanvasElement): void {\n  const lease = CANVAS_LEASES.get(canvas);\n  if (!lease) return;\n  CANVAS_LEASES.delete(canvas);\n  lease.release();\n}\n"],"mappings":"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"}
+{"version":3,"file":"canvasRenderer.js","names":["viewToMat3","viewToMat3$1","TENANTS","REFUSED","shaderKeyOf","shaders","h","registerShaders","handle","free","set","held","leaseCanvasRenderer","restored","createEmitter","bind","size","dpr","tile","options","shared","canvas","width","height","gl","renderer","WeaselRenderer","mine","shaderKey","tileX","tileY","commands","view","CANVAS_LEASES","paintCanvas","lease","releaseCanvasRenderer"],"sources":["../../src/canvas/canvasRenderer.ts"],"sourcesContent":["/**\n * The one renderer lifetime in core. Every on-screen surface holds its\n * `WeaselRenderer` through a `leaseCanvasRenderer` lease.\n *\n * A lease holds its own renderer, so several can share one element: each\n * tenant painting a `tile` of a shared buffer gets a renderer of its own on\n * the element's one context. Release frees only what that renderer created;\n * the context itself is never lost.\n */\nimport { WeaselRenderer, type RenderOptions } from '@weasel-js/renderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport { createEmitter } from '@weasel-js/registry';\n\n/** The live renderers painting into each element, across every lease. */\nconst TENANTS: WeakMap<HTMLCanvasElement, Set<WeaselRenderer>> = new WeakMap();\n\n/** Canvases whose context the renderer refused, so a redraw does not rebuild\n *  and fail again, and the reason is reported once. */\nconst REFUSED: WeakSet<HTMLCanvasElement> = new WeakSet();\n\n/** A renderer painting into the canvas, if any lease holds one. Test seam. */\nexport function cachedCanvasRenderer(canvas: HTMLCanvasElement): WeaselRenderer | undefined {\n  const set = TENANTS.get(canvas);\n  return set ? set.values().next().value : undefined;\n}\n\n/** The size and density to paint a canvas at. `dpr` defaults to\n *  `window.devicePixelRatio`, read per paint. */\nexport interface CanvasPaintSize {\n  width: number;\n  height: number;\n  dpr?: number;\n}\n\n/** How one paint reaches the canvas, beyond its size. */\nexport interface CanvasPaintOptions {\n  /** Paint a `width × height` tile of a buffer other surfaces share, at this\n   *  origin in CSS pixels. The buffer is then the caller's to size: the\n   *  renderer never resizes the element, which would have every co-tenant\n   *  resize it to its own pane. Omit to own the whole element. */\n  tile?: { x: number; y: number } | null;\n  /** `WeaselRendererOptions.flattenTolerance`, applied from this paint on. */\n  flattenTolerance?: number;\n  /** Custom programs to compile on the renderer. Compiled when the renderer\n   *  is created, and again when the set of ids changes. */\n  shaders?: readonly ShaderProgramHandle[];\n}\n\n/** A paint's options, plus what `paint` hands `WeaselRenderer.render`. */\nexport interface CanvasRenderOptions extends CanvasPaintOptions {\n  render?: RenderOptions;\n}\n\n/** A canvas renderer held for a surface's lifetime. */\nexport interface CanvasRendererLease {\n  /** Draw `commands` into `canvas` — screen-space, one unit per CSS pixel,\n   *  with `view` passed on as the frame's world→screen transform. `bind`,\n   *  then render. Returns `false` without painting where `bind` finds no\n   *  renderer. */\n  paint(\n    canvas: HTMLCanvasElement,\n    commands: DrawCommand[],\n    view: View,\n    size: CanvasPaintSize,\n    options?: CanvasRenderOptions,\n  ): boolean;\n  /** The renderer that paints `canvas` at `size`, ready to render: created on\n   *  first use, resized, and given this paint's tile, tolerance, and shaders.\n   *  Frees the previous renderer first if the surface moved to another\n   *  element, or between owning it whole and painting a tile of it. `null`\n   *  where no WebGL2 context is available (jsdom, a failed context creation,\n   *  or a context that is lost for now). */\n  bind(canvas: HTMLCanvasElement, size: CanvasPaintSize, options?: CanvasPaintOptions): WeaselRenderer | null;\n  /** Run `fn` when the canvas gets a lost context back, after the renderer\n   *  has rebuilt itself on it. Nothing repaints a restored buffer on its own.\n   *  Returns an unsubscribe. */\n  subscribeRestored(fn: () => void): () => void;\n  /** Free the held renderer and every GL object it owns. A later `paint`\n   *  creates a fresh one. */\n  release(): void;\n}\n\ninterface Held {\n  canvas: HTMLCanvasElement;\n  renderer: WeaselRenderer;\n  shared: boolean;\n  lost: boolean;\n  onLost: () => void;\n  onRestored: () => void;\n  width: number;\n  height: number;\n  dpr: number;\n  tileX: number | null;\n  tileY: number | null;\n  flattenTolerance: number | undefined;\n  shaderKey: string;\n}\n\n/** Identifies a set of custom programs by their ids, in order. */\nexport const shaderKeyOf = (shaders: readonly ShaderProgramHandle[] | undefined): string =>\n  shaders?.map((h) => h.id).join('|') ?? '';\n\nfunction registerShaders(renderer: WeaselRenderer, shaders: readonly ShaderProgramHandle[] | undefined): void {\n  if (!shaders) return;\n  for (const handle of shaders) {\n    try {\n      renderer.registerProgram(handle);\n    } catch (e) {\n      console.warn(`weasel: failed to register shader \"${handle.id}\":`, e);\n    }\n  }\n}\n\nfunction free(held: Held): void {\n  const set = TENANTS.get(held.canvas);\n  set?.delete(held.renderer);\n  held.canvas.removeEventListener('webglcontextlost', held.onLost);\n  held.canvas.removeEventListener('webglcontextrestored', held.onRestored);\n  if (set && set.size === 0) TENANTS.delete(held.canvas);\n  held.renderer.dispose();\n}\n\n/** Hold the renderer of the canvas a surface paints into, until released. */\nexport function leaseCanvasRenderer(): CanvasRendererLease {\n  let held: Held | null = null;\n  const restored = createEmitter();\n  const bind = (canvas: HTMLCanvasElement, size: CanvasPaintSize, options: CanvasPaintOptions = {}): WeaselRenderer | null => {\n    const { width, height } = size;\n    const dpr = size.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1);\n    const tile = options.tile ?? null;\n    const shared = tile !== null;\n\n    if (held && (held.canvas !== canvas || held.shared !== shared)) {\n      free(held);\n      held = null;\n    }\n    if (!held) {\n      if (REFUSED.has(canvas)) return null;\n      const gl = canvas.getContext('webgl2', { preserveDrawingBuffer: true, stencil: true });\n      if (!gl || typeof (gl as Partial<WebGL2RenderingContext>).enable !== 'function') return null;\n      let renderer: WeaselRenderer;\n      try {\n        renderer = new WeaselRenderer({\n          gl: gl as WebGL2RenderingContext,\n          ...(shared ? {} : { canvas }),\n          width, height, dpr,\n          flattenTolerance: options.flattenTolerance,\n        });\n      } catch (e) {\n        // A lost context fails to compile and may yet come back; anything\n        // else fails the same way next time.\n        if (!(gl as Partial<WebGL2RenderingContext>).isContextLost?.()) {\n          REFUSED.add(canvas);\n          console.warn('weasel: this canvas cannot be painted:', e);\n        }\n        return null;\n      }\n      // Added after the renderer's own listeners, so a subscriber runs against\n      // a renderer that has already recompiled.\n      const mine: Held = held = {\n        canvas, renderer, shared, width, height, dpr, tileX: null, tileY: null,\n        flattenTolerance: options.flattenTolerance, shaderKey: '',\n        lost: false,\n        onLost: () => { mine.lost = true; },\n        onRestored: () => {\n          mine.lost = false;\n          restored.emit();\n        },\n      };\n      canvas.addEventListener('webglcontextlost', held.onLost);\n      canvas.addEventListener('webglcontextrestored', held.onRestored);\n      let set = TENANTS.get(canvas);\n      if (!set) { set = new Set(); TENANTS.set(canvas, set); }\n      set.add(renderer);\n    } else {\n      // React writes the element's `width` and `height` attributes in CSS\n      // pixels on every size change, so a size that went away and came back\n      // matches the record while the buffer does not.\n      const stale = !shared\n        && (canvas.width !== Math.round(width * dpr) || canvas.height !== Math.round(height * dpr));\n      if (stale || held.width !== width || held.height !== height || held.dpr !== dpr) {\n        held.renderer.resize({ width, height, dpr });\n        held.width = width;\n        held.height = height;\n        held.dpr = dpr;\n      }\n      if (held.flattenTolerance !== options.flattenTolerance) {\n        held.renderer.setFlattenTolerance(options.flattenTolerance);\n        held.flattenTolerance = options.flattenTolerance;\n      }\n    }\n\n    if (held.lost) return null;\n    const { renderer } = held;\n    const shaderKey = shaderKeyOf(options.shaders);\n    if (shaderKey !== held.shaderKey) {\n      registerShaders(renderer, options.shaders);\n      held.shaderKey = shaderKey;\n    }\n    const tileX = tile?.x ?? null;\n    const tileY = tile?.y ?? null;\n    if (tileX !== held.tileX || tileY !== held.tileY) {\n      renderer.setTarget(tile ? { origin: { x: tile.x, y: tile.y } } : null);\n      held.tileX = tileX;\n      held.tileY = tileY;\n    }\n    return renderer;\n  };\n  return {\n    bind,\n    paint(canvas, commands, view, size, options) {\n      const renderer = bind(canvas, size, options);\n      if (!renderer) return false;\n      renderer.render(commands, viewToMat3(view), options?.render);\n      return true;\n    },\n    subscribeRestored: restored.subscribe,\n    release() {\n      if (held) free(held);\n      held = null;\n    },\n  };\n}\n\n/** Leases held on a canvas's behalf by `paintCanvas`, one per element. */\nconst CANVAS_LEASES: WeakMap<HTMLCanvasElement, CanvasRendererLease> = new WeakMap();\n\n/**\n * Paint `canvas` through a lease held for the element itself, for callers\n * with no component lifetime of their own. The renderer lives until\n * `releaseCanvasRenderer(canvas)`.\n */\nexport function paintCanvas(\n  canvas: HTMLCanvasElement,\n  commands: DrawCommand[],\n  view: View,\n  size: CanvasPaintSize,\n): boolean {\n  let lease = CANVAS_LEASES.get(canvas);\n  if (!lease) {\n    lease = leaseCanvasRenderer();\n    CANVAS_LEASES.set(canvas, lease);\n  }\n  return lease.paint(canvas, commands, view, size);\n}\n\n/** Free the renderer `paintCanvas` holds for the canvas, and every GL object\n *  it owns. The next paint creates a fresh one. Renderers a surface component\n *  holds are that component's to free, on unmount. */\nexport function releaseCanvasRenderer(canvas: HTMLCanvasElement): void {\n  const lease = CANVAS_LEASES.get(canvas);\n  if (!lease) return;\n  CANVAS_LEASES.delete(canvas);\n  lease.release();\n}\n"],"mappings":"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"}

package/dist/canvas/colorOverrides.js.map

@@ -1 +1 @@
-{"version":3,"file":"colorOverrides.js","names":["clock","withColorOverrides","registry","node","drawOne","pose","view","ctx","tMs","now","channel","base"],"sources":["../../src/canvas/colorOverrides.ts"],"sourcesContent":["/**\n * The render walk's half of animated vertex colors: handing a node's live\n * color overrides to its painter. The overrides live in an animator's\n * `ColorOverrideRegistry`, which `tweenVertexColors` and its siblings write.\n */\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\n\nconst clock = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now());\n\n/**\n * Wrap a `drawOne` so a node with a live color override reaches its painter\n * with {@link NodePaintCtx.vertexColors}. Both scene walks wrap here, and\n * `createPathLayer` resolves through the same `ColorOverrideRegistry.resolve`.\n *\n * A node nothing overrides passes the caller's `ctx` through untouched, so\n * the common case allocates nothing.\n */\nexport function withColorOverrides<TData, TLayer extends string, TPose>(\n  registry: ColorOverrideRegistry,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  now: () => number = clock,\n): SceneViewDrawOne<TData, TLayer, TPose> {\n  return (node, pose, view, ctx) => {\n    if (!registry.has(node.id)) return drawOne(node, pose, view, ctx);\n    const tMs = now();\n    return drawOne(node, pose, view, {\n      ...ctx,\n      vertexColors: (channel, base) => registry.resolve(node.id, channel, base, tMs),\n    });\n  };\n}\n"],"mappings":";AAQA,IAAMA,UAAuB,OAAO,cAAgB,MAAc,YAAY,IAAI,IAAI,KAAK,IAAI;AAU/F,SAAgBC,EACd,GACA,GACA,IAAoBD,GACoB;CACxC,QAAQ,GAAM,GAAM,GAAM,MAAQ;EAChC,IAAI,CAACE,EAAS,IAAIC,EAAK,EAAE,GAAG,OAAOC,EAAQD,GAAME,GAAMC,GAAMC,CAAG;EAChE,IAAMC,IAAMC,EAAI;EAChB,OAAOL,EAAQD,GAAME,GAAMC,GAAM;GAC/B,GAAGC;GACH,eAAe,GAAS,MAASL,EAAS,QAAQC,EAAK,IAAIO,GAASC,GAAMH,CAAG;EAC/E,CAAC;CACH;AACF"}
+{"version":3,"file":"colorOverrides.js","names":["clock","withColorOverrides","registry","node","drawOne","pose","view","ctx","tMs","now","channel","base"],"sources":["../../src/canvas/colorOverrides.ts"],"sourcesContent":["/**\n * The render walk's half of animated vertex colors: handing a node's live\n * color overrides to its painter. The overrides live in an animator's\n * `ColorOverrideRegistry`, which `tweenVertexColors` and its siblings write.\n */\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { SceneViewDrawOne } from './NodeShape';\n\nconst clock = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now());\n\n/**\n * Wrap a `drawOne` so a node with a live color override reaches its painter\n * with {@link NodePaintCtx.vertexColors}. Both scene walks wrap here, and\n * `createPathLayer` resolves through the same `ColorOverrideRegistry.resolve`.\n *\n * A node nothing overrides passes the caller's `ctx` through untouched, so\n * the common case allocates nothing.\n */\nexport function withColorOverrides<TData, TLayer extends string, TPose>(\n  registry: ColorOverrideRegistry,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  now: () => number = clock,\n): SceneViewDrawOne<TData, TLayer, TPose> {\n  return (node, pose, view, ctx) => {\n    if (!registry.has(node.id)) return drawOne(node, pose, view, ctx);\n    const tMs = now();\n    return drawOne(node, pose, view, {\n      ...ctx,\n      vertexColors: (channel, base) => registry.resolve(node.id, channel, base, tMs),\n    });\n  };\n}\n"],"mappings":";AAQA,IAAMA,UAAuB,OAAO,cAAgB,MAAc,YAAY,IAAI,IAAI,KAAK,IAAI;AAU/F,SAAgBC,EACd,GACA,GACA,IAAoBD,GACoB;CACxC,QAAQ,GAAM,GAAM,GAAM,MAAQ;EAChC,IAAI,CAACE,EAAS,IAAIC,EAAK,EAAE,GAAG,OAAOC,EAAQD,GAAME,GAAMC,GAAMC,CAAG;EAChE,IAAMC,IAAMC,EAAI;EAChB,OAAOL,EAAQD,GAAME,GAAMC,GAAM;GAC/B,GAAGC;GACH,eAAe,GAAS,MAASL,EAAS,QAAQC,EAAK,IAAIO,GAASC,GAAMH,CAAG;EAC/E,CAAC;CACH;AACF"}