@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/sceneAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneAdapter.js","names":["sceneToAdapter","visibleLayers","out","layer","scene","sel","options","getSelection","setSelection","d","AUTO_POSE_DESCRIPTOR","poseBounds","visualBoundsViaDescriptor","p","poseDescriptorForNode","node","translate","translatePoseViaDescriptor","dx","dy","composition","composes","pickOpts","pickOptsFor","view","regionPickOptions","clipboardEnv","adapter","id","frameAtOrAbove","asNodeId","visible","nid","effectivePose","n","definesFrame","composeWorldPose","g","before","after","pose","descIds","collect","cid","rootId","cn","parentId","i","ids","l","declared","label","applyOpsTo","ops","index","pickability","fnFieldsOfNode","layout","hitTestArea","rect","hitTestLassoPolygon","polygon","mode","created","bounds","snapshotSceneSelection","pasteSceneSnapshot","clipboard","offset","ctx","useSceneAdapter","useMemo","selection","commitInsert","insertLayer","layouts","poseDescriptor","cascadeContainerPose","poseComposition"],"sources":["../../src/canvas/sceneAdapter.ts"],"sourcesContent":["/**\n * Synthesize a `<Canvas>`-compatible adapter from a `Scene` primitive.\n *\n * The Scene owns nodes/poses/parenting and auto-records ops on every mutation.\n * `<SceneCanvas>` calls `sceneToAdapter(scene)` and forwards the result to\n * `<Canvas>`'s `adapter` prop. Selection and hit-testing are not part of the\n * Scene model — Canvas's internal `useSelection` and pose-derived pickEvery\n * cover those.\n *\n * Pose semantics match the rest of the kit: `getPose` / `setPose` return /\n * write **local** coordinates (relative to parent). The Scene stores pose on\n * each node directly; world composition (when needed) is the renderer's job\n * via `composeWorldPose`, not the adapter's.\n */\nimport { useMemo } from 'react';\nimport type {\n  AreaSelectAdapter,\n  ClipboardSnapshot,\n  InsertAdapter,\n  PasteCtx,\n  LassoHitMode,\n  LassoSelectAdapter,\n  RegionPickView,\n  LayerEnumerableAdapter,\n  MoveAdapter,\n  ResizeAdapter,\n  RotateAdapter,\n} from 'core/adapters/types';\nimport type { LayoutStrategy } from '../layout/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene } from 'core/scene/types';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport { fnFieldsOfNode } from 'core/scene/nodeFnFields';\nimport { pickability } from 'core/scene/pickability';\nimport { asNodeId } from 'core/scene/types';\nimport { applyOpsTo } from 'core/applyOps';\nimport { hitTestArea, hitTestLassoPolygon, regionPickOptions } from 'canvas/deps/hitTestArea';\nimport type { ScenePickSourceOptions } from 'canvas/pickWalk';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { composeWorldPose, frameAtOrAbove, type PoseComposition } from 'features/groups/composePose';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\nimport { pasteSceneSnapshot, snapshotSceneSelection, type SceneClipboardEnv } from './sceneClipboard';\n\n/** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /\n *  `setSelection`. Matches `useSelection().adapterMethods` plus an imperative\n *  read; pass `useSelection()` itself or `selection.adapterMethods`. */\nexport interface SceneAdapterSelection {\n  get?(): string[];\n  set?(ids: string[]): void;\n  getSelection?(): string[];\n  setSelection?(ids: string[]): void;\n}\n\n/** Sibling z-order surface used by reorder ops. Inlined here (rather than\n *  pulled from `core/ops/reorder` to avoid import cycles); the `null` parent\n *  channel addresses the root sibling list. */\n/** @internal */\ninterface ReorderAdapter {\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** Everything the interaction layer can ask of a scene, as one type: the\n *  move, resize, rotate, selection, layer and reorder contracts combined.\n *  `<SceneCanvas>` synthesizes one of these, which is why most consumers never\n *  touch an adapter directly. */\nexport type SceneCanvasAdapter<TData, TLayer extends string, TPose> =\n  & MoveAdapter<Node<TData, TLayer, TPose>, TPose>\n  & ResizeAdapter<Node<TData, TLayer, TPose>, TPose>\n  & RotateAdapter<Node<TData, TLayer, TPose>, TPose>\n  & AreaSelectAdapter\n  & LassoSelectAdapter\n  & LayerEnumerableAdapter<TLayer>\n  & ReorderAdapter\n  & Partial<InsertAdapter<Node<TData, TLayer, TPose>>>\n  // Tighten the parts that are optional on the underlying adapter contracts\n  // but unconditionally provided by a scene-backed adapter. Anything that\n  // routes scene mutations through this adapter (kit InsertOps, hierarchical\n  // hooks like useNest, etc.) can rely on these being present.\n  & {\n      getParent(id: string): string | null;\n      /** The node's pose with every ancestor's frame folded in. Equal to\n       *  `getPose` unless a `poseComposition` is configured. */\n      getWorldPose(id: string): TPose;\n      /** Whether `id`'s pose is a frame its children are expressed in — see\n       *  `definesFrame`. */\n      definesFrame(id: string): boolean;\n      /** Present only when a composing strategy is configured; the render\n       *  walk feature-detects it. */\n      composePose?(parent: TPose, child: TPose): TPose;\n      getSelection(): string[];\n      setSelection(ids: string[]): void;\n      insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;\n      removeNode(id: string): void;\n      /** Replace a node's `data` — what a `setData` op writes through. */\n      setData(id: string, data: TData): void;\n      /** Swap a container's layout — what a `setLayout` op writes through. */\n      setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;\n      getRemovalClosure(ids: readonly string[]): string[];\n      applyOps(ops: Op[], label?: string): void;\n      snapshotSelection(ids: string[]): ClipboardSnapshot;\n      commitPaste(\n        clipboard: ClipboardSnapshot,\n        offset: { dx: number; dy: number },\n        ctx?: PasteCtx,\n      ): Node<TData, TLayer, TPose>[];\n      getPasteOffset(clipboard: ClipboardSnapshot): { dx: number; dy: number };\n    };\n\n/** Optional extras for the synthesized adapter. Pass `commitInsert` to wire\n *  the insert gesture into a Scene-owned canvas; the returned object becomes\n *  a leaf on the layer named by `layer` (default `'default'`). */\nexport interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {\n  /** Factory for new objects. Returning `null` aborts the insert. */\n  commitInsert?: (bounds: Bounds) => {\n    pose: TPose;\n    data: TData;\n    id?: string;\n  } | null;\n  /** Layer to place inserted nodes on. Defaults to the trivial-form layer. */\n  insertLayer?: TLayer;\n  /** Selection source for `AreaSelectAdapter.getSelection` / `setSelection`.\n   *  Pass the result of `useSelection()` (or its `adapterMethods`). When\n   *  omitted, `getSelection` returns `[]` and `setSelection` is a noop —\n   *  fine for read-only or selection-less canvases, but the marquee gesture\n   *  won't update any external selection state. */\n  selection?: SceneAdapterSelection;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Layout strategies keyed by container node id, for containers whose\n   *  scene node declares none (`ContainerNode.layout` wins). `move` runs its\n   *  layout-aware pass on them; for inserts, deletes and resizes to reach\n   *  them too, install them with `useLayoutArrivals`. Pass either a static\n   *  map, or a `getLayout(id)` function for dynamic resolution. */\n  layouts?:\n    | Record<string, LayoutStrategy<TPose>>\n    | ((containerId: string) => LayoutStrategy<TPose> | null);\n  /** When true, `setPose` on a container translates every descendant by the\n   *  same delta, through the pose descriptor. Scene v1 stores absolute poses,\n   *  so without it children stay behind. */\n  cascadeContainerPose?: boolean;\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model, where a parent contributes no transform. Supplying a\n   *  composing strategy makes a container's pose a **frame**: rotating the\n   *  container rotates its contents, and `setPose` on it must not also\n   *  translate them, so it cannot be combined with `cascadeContainerPose`. */\n  poseComposition?: PoseComposition<TPose>;\n}\n\n/** Derive the adapter for a scene. Reads go straight to the scene; writes are\n *  ops applied through its history, so anything done through the adapter is\n *  undoable. */\nexport function sceneToAdapter<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  options: SceneToAdapterOptions<TData, TLayer, TPose> = {},\n): SceneCanvasAdapter<TData, TLayer, TPose> {\n  const visibleLayers = (): Set<TLayer> => {\n    const out = new Set<TLayer>();\n    for (const layer of scene.layers) {\n      if (layer.visible) out.add(layer.id);\n    }\n    return out;\n  };\n\n  const sel = options.selection;\n  const getSelection = sel?.getSelection ?? sel?.get ?? (() => [] as string[]);\n  const setSelection = sel?.setSelection ?? sel?.set ?? (() => {});\n  const d = (options.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const poseBounds = (p: TPose, node: unknown): Bounds =>\n    visualBoundsViaDescriptor(p, poseDescriptorForNode(d, node));\n  const translate = (p: TPose, dx: number, dy: number, node?: unknown): TPose =>\n    translatePoseViaDescriptor(\n      p, dx, dy, node === undefined ? d : poseDescriptorForNode(d, node),\n    );\n\n  const composition = options.poseComposition;\n  const composes = composition !== undefined && composition.closure !== 'identity';\n  const pickOpts: ScenePickSourceOptions<unknown> = composition\n    ? { poseComposition: composition as PoseComposition<unknown> }\n    : {};\n  // The asking view's layer gate and camera, over the adapter's own options.\n  const pickOptsFor = (view: RegionPickView | undefined): ScenePickSourceOptions<unknown> =>\n    (view ? { ...pickOpts, ...regionPickOptions(view, undefined, undefined) } : pickOpts);\n  if (composes && options.cascadeContainerPose) {\n    throw new Error(\n      'sceneToAdapter: poseComposition and cascadeContainerPose contradict each other. ' +\n      'Under a composing strategy a child\\'s pose is already relative to its parent, so ' +\n      'the cascade would move every descendant twice. Drop cascadeContainerPose.',\n    );\n  }\n\n  const clipboardEnv: SceneClipboardEnv<TData, TLayer, TPose> = {\n    scene,\n    composes,\n    worldPoseOf: (id) => adapter.getWorldPose(id),\n    frameAtOrAbove: (id) => frameAtOrAbove(adapter, id),\n    poseBounds,\n    translate,\n  };\n\n  const adapter: SceneCanvasAdapter<TData, TLayer, TPose> = {\n    getNode(id) {\n      return scene.get(asNodeId(id));\n    },\n    getNodes() {\n      const visible = visibleLayers();\n      const out: Node<TData, TLayer, TPose>[] = [];\n      for (const n of scene.renderOrderNodes()) {\n        if (visible.has(n.layer)) out.push(n);\n      }\n      return out;\n    },\n    getPose(id) {\n      const nid = asNodeId(id);\n      const n = scene.get(nid);\n      if (!n) throw new Error(`sceneToAdapter: unknown node \"${id}\"`);\n      return effectivePose(scene, n);\n    },\n    getParent(id) {\n      const n = scene.get(asNodeId(id));\n      return n?.parent ?? null;\n    },\n    definesFrame(id) {\n      const n = scene.get(asNodeId(id));\n      return n === undefined || definesFrame(n);\n    },\n    getWorldPose(id) {\n      if (!composes) return adapter.getPose(id);\n      return composeWorldPose(adapter, id, composition!.compose);\n    },\n    // Only present when it would do something: the render walk skips the fold\n    // entirely when this is absent, which is the absolute-pose path.\n    ...(composes ? { composePose: composition!.compose } : {}),\n    setPose(id, pose) {\n      // Container cascade (opt-in): under scene v1's absolute-pose semantics,\n      // moving a container needs to translate every descendant by the same\n      // delta so children visually stay attached. The whole cascade lands as\n      // one scene.batch so undo collapses to a single step.\n      if (options.cascadeContainerPose) {\n        const node = scene.get(asNodeId(id));\n        if (node && node.kind === 'container') {\n          const g = poseDescriptorForNode(d, node);\n          const before = g.getBounds(node.pose);\n          const after = g.getBounds(pose);\n          const dx = after.x - before.x;\n          const dy = after.y - before.y;\n          if (dx !== 0 || dy !== 0) {\n            const descIds: string[] = [];\n            const collect = (rootId: string): void => {\n              for (const cid of scene.childrenOf(asNodeId(rootId))) {\n                descIds.push(cid);\n                collect(cid);\n              }\n            };\n            collect(id);\n            scene.batch('move container', () => {\n              scene.setPose(asNodeId(id), pose);\n              for (const cid of descIds) {\n                const cn = scene.get(asNodeId(cid));\n                if (!cn) continue;\n                scene.setPose(asNodeId(cid), translate(cn.pose, dx, dy, cn));\n              }\n            });\n            return;\n          }\n        }\n      }\n      scene.setPose(asNodeId(id), pose);\n    },\n    setParent(id, parentId) {\n      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId));\n    },\n    getChildren(id) {\n      // Reorder ops call this with parentId === null to mean \"root siblings.\"\n      // The kit's existing callers always pass a string, so this widening is\n      // additive — falls through to scene.childrenOf for the typed path and\n      // returns scene.roots for the null path.\n      if (id === null) return [...scene.roots];\n      return [...scene.childrenOf(asNodeId(id))];\n    },\n    setChildOrder(parentId, ids) {\n      // Batched reorder: each scene.reorder call is its own kit:move log\n      // entry, but scene.batch wraps them into one undo unit + one notify.\n      scene.batch('Reorder', () => {\n        for (let i = 0; i < ids.length; i++) {\n          // Skip ids that are already in the target slot to avoid useless\n          // log entries.\n          const current = parentId === null\n            ? scene.roots\n            : scene.childrenOf(asNodeId(parentId));\n          if (current[i] === ids[i]) continue;\n          scene.reorder(asNodeId(ids[i]), i);\n        }\n      });\n    },\n    getLayers() {\n      return scene.layers.map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax }));\n    },\n    getLayout(id) {\n      const declared = scene.layoutOf(asNodeId(id));\n      if (declared !== null || !options.layouts) return declared;\n      return typeof options.layouts === 'function'\n        ? options.layouts(id)\n        : options.layouts[id] ?? null;\n    },\n    // Unified applyOps: when a label is supplied the ops are wrapped in a\n    // batch checkpoint (history-aware path used by Move/Resize/Rotate/Insert/\n    // Delete tools). When a journal is active (via scene's getActiveJournal\n    // option), scene.applyBatch routes to the journal instead of recording a\n    // new parent-history entry. Without a label the ops are applied transiently\n    // via applyOpsTo (AreaSelectAdapter contract — no checkpoint).\n    applyOps(ops: Op[], label?: string) {\n      if (label !== undefined) {\n        scene.applyBatch(ops, label, this);\n      } else {\n        applyOpsTo(this, ops);\n      }\n    },\n    // Node-mutation surface used by kit InsertOps / DeleteOps (e.g.\n    // useNest wrapping the selection in a new container node, or its\n    // inverse). Re-adds via the full structural spec so the round-trip\n    // survives undo/redo; removes by id.\n    insertNode(node: Node<TData, TLayer, TPose>, index?: number) {\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(index !== undefined ? { index } : {}),\n        ...(node.parent !== null ? { parent: node.parent } : {}),\n        // Derivation travels with the node, or undo of a delete brings an\n        // edge back as a static path that never follows its endpoints again.\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...pickability(node),\n        ...fnFieldsOfNode(node),\n      });\n    },\n    removeNode(id: string) {\n      scene.remove(asNodeId(id));\n    },\n    setData(id: string, data: TData) {\n      scene.update(asNodeId(id), { data });\n    },\n    setLayout(id: string, layout: LayoutStrategy<TPose> | string | null) {\n      scene.setLayout(asNodeId(id), layout);\n    },\n    getRemovalClosure(ids: readonly string[]): string[] {\n      return [...scene.removalClosure(ids.map(asNodeId))];\n    },\n    // AreaSelectAdapter surface — included unconditionally so plain\n    // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the\n    // marquee gesture. `applyOps` (above) dispatches transiently when called\n    // without a label, matching the AreaSelectAdapter contract.\n    getSelection,\n    setSelection,\n    // The live marquee's and lasso's own hit-tests. Containers come back:\n    // this adapter's consumer has nothing to fold children into them.\n    hitTestArea(rect: Bounds, view?: RegionPickView) {\n      return hitTestArea(\n        scene,\n        rect,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    hitTestLasso(polygon, mode: LassoHitMode, view?: RegionPickView) {\n      return hitTestLassoPolygon(\n        scene,\n        polygon,\n        mode,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    // commitInsert (gesture-time leaf insert) is opt-in: present only when\n    // `options.commitInsert` is. The full insertNode/removeNode mutators\n    // above are always present so kit-side InsertOp / DeleteOp round-trip\n    // through scene.add / scene.remove regardless.\n    //\n    // Contract: this is a pure factory — it constructs a Node spec but does\n    // NOT touch the scene. `useInsert`'s onEnd dispatches an `InsertOp`\n    // whose apply() calls `adapter.insertNode` → `scene.add`, which is the\n    // sole insertion path. Calling `scene.add` here too would double-insert,\n    // and the second add throws on id collision (silently dropping the\n    // gesture's pointer-up cleanup and breaking the next drag).\n    ...(options.commitInsert\n      ? {\n          commitInsert: (bounds: { x: number; y: number; width: number; height: number }) => {\n            const created = options.commitInsert!(bounds);\n            if (!created) return null;\n            const layer = (options.insertLayer ?? ('default' as TLayer));\n            const id = created.id === undefined ? scene.mintId() : asNodeId(created.id);\n            return {\n              kind: 'leaf',\n              id,\n              layer,\n              pose: created.pose,\n              data: created.data,\n              parent: null,\n            } as Node<TData, TLayer, TPose>;\n          },\n        }\n      : {}),\n    // Clipboard seam (`useClipboardOps` / the paste ingestion path).\n    snapshotSelection(ids: string[]): ClipboardSnapshot {\n      return snapshotSceneSelection(clipboardEnv, ids);\n    },\n    commitPaste(\n      clipboard: ClipboardSnapshot,\n      offset: { dx: number; dy: number },\n      ctx?: PasteCtx,\n    ): Node<TData, TLayer, TPose>[] {\n      return pasteSceneSnapshot(clipboardEnv, clipboard, offset, ctx);\n    },\n    // Constant cascade: the hook re-snapshots the just-created items, so\n    // repeated pastes stack +12/+12 each time.\n    getPasteOffset(): { dx: number; dy: number } {\n      return { dx: 12, dy: 12 };\n    },\n  };\n\n  return adapter;\n}\n\n/**\n * React-hook wrapper around `sceneToAdapter`. Memoizes on every option, so\n * the adapter keeps its identity across renders unless one of them changes.\n */\nexport function useSceneAdapter<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  options: SceneToAdapterOptions<TData, TLayer, TPose> = {},\n): SceneCanvasAdapter<TData, TLayer, TPose> {\n  const {\n    selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition,\n  } = options;\n  return useMemo(\n    () => sceneToAdapter(scene, {\n      selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition,\n    }),\n    [scene, selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition],\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"sceneAdapter.js","names":["sceneToAdapter","visibleLayers","out","layer","scene","sel","options","getSelection","setSelection","d","AUTO_POSE_DESCRIPTOR","poseBounds","visualBoundsViaDescriptor","p","poseDescriptorForNode","node","translate","translatePoseViaDescriptor","dx","dy","composition","composes","composesFrames","pickOpts","pickOptsFor","view","regionPickOptions","cascade","cascadingSetPose","clipboardEnv","adapter","id","frameAtOrAbove","sceneMutators","visible","nid","asNodeId","effectivePose","n","definesFrame","composeWorldPose","pose","scenePoseTarget","descriptor","carried","containerCascade","l","listener","label","applyOpsTo","ops","hitTestArea","rect","hitTestLassoPolygon","polygon","mode","created","bounds","snapshotSceneSelection","ids","pasteSceneSnapshot","clipboard","offset","ctx"],"sources":["../../src/canvas/sceneAdapter.ts"],"sourcesContent":["/**\n * Synthesize a `<Canvas>`-compatible adapter from a `Scene` primitive.\n * `getPose` / `setPose` return / write **local** coordinates (relative to\n * parent); world composition is the renderer's job via `composeWorldPose`.\n */\nimport type {\n  AreaSelectAdapter,\n  ClipboardSnapshot,\n  InsertAdapter,\n  PasteCtx,\n  LassoHitMode,\n  LassoSelectAdapter,\n  RegionPickView,\n  LayerEnumerableAdapter,\n  MoveAdapter,\n  ResizeAdapter,\n  RotateAdapter,\n} from 'core/adapters/types';\nimport type { LayoutStrategy } from '../layout/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene } from 'core/scene/types';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport { sceneMutators } from 'core/scene/sceneMutators';\nimport { asNodeId } from 'core/scene/types';\nimport { applyOpsTo } from 'core/applyOps';\nimport { hitTestArea, hitTestLassoPolygon, regionPickOptions } from 'canvas/deps/hitTestArea';\nimport type { ScenePickSourceOptions } from 'canvas/pickWalk';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { composesFrames, composeWorldPose, frameAtOrAbove } from 'core/scene/composePose';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\nimport { scenePoseTarget } from '../animation/poseTarget';\nimport { cascadingSetPose, containerCascade } from './poseCascade';\nimport { pasteSceneSnapshot, snapshotSceneSelection, type SceneClipboardEnv } from './sceneClipboard';\n\n/** Minimal selection contract `sceneToAdapter` needs to wire `getSelection` /\n *  `setSelection`. Matches `useSelection().adapterMethods` plus an imperative\n *  read; pass `useSelection()` itself or `selection.adapterMethods`. */\nexport interface SceneAdapterSelection {\n  get?(): string[];\n  set?(ids: string[]): void;\n  getSelection?(): string[];\n  setSelection?(ids: string[]): void;\n}\n\n/** Sibling z-order surface used by reorder ops. Inlined here (rather than\n *  pulled from `core/ops/reorder` to avoid import cycles); the `null` parent\n *  channel addresses the root sibling list. */\n/** @internal */\ninterface ReorderAdapter {\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** Everything the interaction layer can ask of a scene, as one type: the\n *  move, resize, rotate, selection, layer and reorder contracts combined.\n *  `<SceneCanvas>` synthesizes one of these, which is why most consumers never\n *  touch an adapter directly. */\nexport type SceneCanvasAdapter<TData, TLayer extends string, TPose> =\n  & MoveAdapter<Node<TData, TLayer, TPose>, TPose>\n  & ResizeAdapter<Node<TData, TLayer, TPose>, TPose>\n  & RotateAdapter<Node<TData, TLayer, TPose>, TPose>\n  & AreaSelectAdapter\n  & LassoSelectAdapter\n  & LayerEnumerableAdapter<TLayer>\n  & ReorderAdapter\n  & Partial<InsertAdapter<Node<TData, TLayer, TPose>>>\n  // Optional on the underlying adapter contracts, but unconditionally\n  // provided by a scene-backed adapter.\n  & {\n      getParent(id: string): string | null;\n      getLayers: NonNullable<LayerEnumerableAdapter<TLayer>['getLayers']>;\n      /** The node's pose with every ancestor's frame folded in. Equal to\n       *  `getPose` unless the scene composes poses. */\n      getWorldPose(id: string): TPose;\n      /** Whether `id`'s pose is a frame its children are expressed in — see\n       *  `definesFrame`. */\n      definesFrame(id: string): boolean;\n      /** Present only when a composing strategy is configured; the render\n       *  walk feature-detects it. */\n      composePose?(parent: TPose, child: TPose): TPose;\n      getSelection(): string[];\n      setSelection(ids: string[]): void;\n      insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;\n      removeNode(id: string): void;\n      /** Replace a node's `data` — what a `setData` op writes through. */\n      setData(id: string, data: TData): void;\n      /** Swap a container's layout — what a `setLayout` op writes through. */\n      setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;\n      /** Move a node to another layer — what a `setLayer` op writes through. */\n      setLayer(id: string, layer: TLayer): void;\n      getRemovalClosure(ids: readonly string[]): string[];\n      applyOps(ops: Op[], label?: string): void;\n      snapshotSelection(ids: string[]): ClipboardSnapshot;\n      commitPaste(\n        clipboard: ClipboardSnapshot,\n        offset: { dx: number; dy: number },\n        ctx?: PasteCtx,\n      ): Node<TData, TLayer, TPose>[];\n      getPasteOffset(clipboard: ClipboardSnapshot): { dx: number; dy: number };\n    };\n\n/** Optional extras for the synthesized adapter. Pass `commitInsert` to wire\n *  the insert gesture into a Scene-owned canvas; the returned object becomes\n *  a leaf on the layer named by `layer` (default `'default'`). */\nexport interface SceneToAdapterOptions<TData, TLayer extends string, TPose> {\n  /** Factory for new objects. Returning `null` aborts the insert. */\n  commitInsert?: (bounds: Bounds) => {\n    pose: TPose;\n    data: TData;\n    id?: string;\n  } | null;\n  /** Layer to place inserted nodes on. Defaults to the trivial-form layer. */\n  insertLayer?: TLayer;\n  /** Selection source: the result of `useSelection()` (or its\n   *  `adapterMethods`). When omitted, `getSelection` returns `[]` and\n   *  `setSelection` is a noop, so the marquee gesture updates nothing. */\n  selection?: SceneAdapterSelection;\n  /** How to read and rewrite this scene's poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n}\n\n/** Derive the adapter for a scene. Reads go straight to the scene; writes are\n *  ops applied through its history, so anything done through the adapter is\n *  undoable.\n *\n *  Moving a container carries its contents either way the scene composes\n *  poses. Under a frame (`scene.composition`) the one pose written moves them.\n *  Under the absolute-pose model `setPose` on a container translates every\n *  descendant by the same delta, and a batch that poses descendants too undoes\n *  exactly only when it goes through this adapter's `applyOps`. */\nexport function sceneToAdapter<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  options: SceneToAdapterOptions<TData, TLayer, TPose> = {},\n): SceneCanvasAdapter<TData, TLayer, TPose> {\n  const visibleLayers = (): Set<TLayer> => {\n    const out = new Set<TLayer>();\n    for (const layer of scene.layers) {\n      if (layer.visible) out.add(layer.id);\n    }\n    return out;\n  };\n\n  const sel = options.selection;\n  const getSelection = sel?.getSelection ?? sel?.get ?? (() => [] as string[]);\n  const setSelection = sel?.setSelection ?? sel?.set ?? (() => {});\n  const d = (options.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const poseBounds = (p: TPose, node: unknown): Bounds =>\n    visualBoundsViaDescriptor(p, poseDescriptorForNode(d, node));\n  const translate = (p: TPose, dx: number, dy: number, node?: unknown): TPose =>\n    translatePoseViaDescriptor(\n      p, dx, dy, node === undefined ? d : poseDescriptorForNode(d, node),\n    );\n\n  const composition = scene.composition;\n  const composes = composesFrames(composition);\n  const pickOpts: ScenePickSourceOptions<unknown> = {};\n  // The asking view's layer gate and camera, over the adapter's own options.\n  const pickOptsFor = (view: RegionPickView | undefined): ScenePickSourceOptions<unknown> =>\n    (view ? { ...pickOpts, ...regionPickOptions(view, undefined) } : pickOpts);\n\n  const cascade = composes ? null : { setPose: cascadingSetPose(scene, d) };\n\n  const clipboardEnv: SceneClipboardEnv<TData, TLayer, TPose> = {\n    scene,\n    composes,\n    worldPoseOf: (id) => adapter.getWorldPose(id),\n    frameAtOrAbove: (id) => frameAtOrAbove(adapter, id),\n    poseBounds,\n    translate,\n  };\n\n  const adapter: SceneCanvasAdapter<TData, TLayer, TPose> = {\n    ...sceneMutators(scene),\n    // What is shown, where the mutators' other users read the document:\n    // visible layers only, and the effective pose.\n    getNodes() {\n      const visible = visibleLayers();\n      const out: Node<TData, TLayer, TPose>[] = [];\n      for (const n of scene.renderOrderNodes()) {\n        if (visible.has(n.layer)) out.push(n);\n      }\n      return out;\n    },\n    getPose(id) {\n      const nid = asNodeId(id);\n      const n = scene.get(nid);\n      if (!n) throw new Error(`sceneToAdapter: unknown node \"${id}\"`);\n      return effectivePose(scene, n);\n    },\n    definesFrame(id) {\n      const n = scene.get(asNodeId(id));\n      return n === undefined || definesFrame(n);\n    },\n    getWorldPose(id) {\n      if (!composes) return adapter.getPose(id);\n      return composeWorldPose(adapter, id, composition.compose);\n    },\n    // Only present when it would do something: the render walk skips the fold\n    // entirely when this is absent, which is the absolute-pose path.\n    ...(composes ? { composePose: composition.compose } : {}),\n    ...(cascade ? { setPose: (id: string, pose: TPose) => cascade.setPose(asNodeId(id), pose) } : {}),\n    poseTarget(id, descriptor) {\n      if (cascade === null || scene.get(asNodeId(id))?.kind !== 'container') {\n        return scenePoseTarget(scene, id, descriptor ?? d);\n      }\n      // Its descendants hold poses of their own: a commit moves them, and they are shown beside it.\n      const carried = containerCascade(scene, asNodeId(id), d, (pose) => adapter.setPose(id, pose));\n      return scenePoseTarget(scene, id, descriptor ?? d, carried);\n    },\n    getLayers: () => scene.layers.map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    subscribeLayers: (listener) => scene.subscribe(listener),\n    getLayout: (id) => scene.layoutOf(asNodeId(id)),\n    // With a label the ops are one batch checkpoint; without one they are\n    // applied transiently, with no checkpoint (the AreaSelectAdapter contract).\n    applyOps(ops: Op[], label?: string) {\n      if (label !== undefined) {\n        scene.applyBatch(ops, label, this);\n      } else {\n        applyOpsTo(this, ops);\n      }\n    },\n    getSelection,\n    setSelection,\n    // The live marquee's and lasso's own hit-tests. Containers come back:\n    // this adapter's consumer has nothing to fold children into them.\n    hitTestArea(rect: Bounds, view?: RegionPickView) {\n      return hitTestArea(\n        scene,\n        rect,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    hitTestLasso(polygon, mode: LassoHitMode, view?: RegionPickView) {\n      return hitTestLassoPolygon(\n        scene,\n        polygon,\n        mode,\n        pickOptsFor(view),\n        d as PoseDescriptor<unknown>,\n        { includeContainers: true },\n      );\n    },\n    // A pure factory: it constructs a Node spec but does NOT touch the scene.\n    // The `InsertOp` → `adapter.insertNode` → `scene.add` path is the sole\n    // insertion path. Calling `scene.add` here too would double-insert, and\n    // the second add throws on id collision.\n    ...(options.commitInsert\n      ? {\n          commitInsert: (bounds: { x: number; y: number; width: number; height: number }) => {\n            const created = options.commitInsert!(bounds);\n            if (!created) return null;\n            const layer = (options.insertLayer ?? ('default' as TLayer));\n            const id = created.id === undefined ? scene.mintId() : asNodeId(created.id);\n            return {\n              kind: 'leaf',\n              id,\n              layer,\n              pose: created.pose,\n              data: created.data,\n              parent: null,\n            } as Node<TData, TLayer, TPose>;\n          },\n        }\n      : {}),\n    // Clipboard seam (`useClipboardOps` / the paste ingestion path).\n    snapshotSelection(ids: string[]): ClipboardSnapshot {\n      return snapshotSceneSelection(clipboardEnv, ids);\n    },\n    commitPaste(\n      clipboard: ClipboardSnapshot,\n      offset: { dx: number; dy: number },\n      ctx?: PasteCtx,\n    ): Node<TData, TLayer, TPose>[] {\n      return pasteSceneSnapshot(clipboardEnv, clipboard, offset, ctx);\n    },\n    // Constant cascade: the hook re-snapshots the just-created items, so\n    // repeated pastes stack +12/+12 each time.\n    getPasteOffset(): { dx: number; dy: number } {\n      return { dx: 12, dy: 12 };\n    },\n  };\n\n  return adapter;\n}\n"],"mappings":";;;;;;;;;;;;AAwIA,SAAgBA,EACd,GACA,IAAuD,CAAC,GACd;CAC1C,IAAMC,UAAmC;EACvC,IAAMC,oBAAM,IAAI,IAAY;EAC5B,KAAK,IAAMC,KAASC,EAAM,QACxB,AAAID,EAAM,WAASD,EAAI,IAAIC,EAAM,EAAE;EAErC,OAAOD;CACT,GAEMG,IAAMC,EAAQ,WACdC,IAAeF,GAAK,gBAAgBA,GAAK,cAAc,CAAC,IACxDG,IAAeH,GAAK,gBAAgBA,GAAK,cAAc,CAAC,IACxDI,IAAKH,EAAQ,kBAAkBI,GAC/BC,KAAc,GAAU,MAC5BC,EAA0BC,GAAGC,EAAsBL,GAAGM,CAAI,CAAC,GACvDC,KAAa,GAAU,GAAY,GAAY,MACnDC,EACEJ,GAAGK,GAAIC,GAAIJ,MAAS,KAAA,IAAYN,IAAIK,EAAsBL,GAAGM,CAAI,CACnE,GAEIK,IAAchB,EAAM,aACpBiB,IAAWC,EAAeF,CAAW,GACrCG,IAA4C,CAAC,GAE7CC,KAAe,MAClBC,IAAO;EAAE,GAAGF;EAAU,GAAGG,EAAkBD,GAAM,KAAA,CAAS;CAAE,IAAIF,GAE7DI,IAAUN,IAAW,OAAO,EAAE,SAASO,EAAiBxB,GAAOK,CAAC,EAAE,GAElEoB,IAAwD;EAC5D;EACA;EACA,cAAc,MAAOC,EAAQ,aAAaC,CAAE;EAC5C,iBAAiB,MAAOC,EAAeF,GAASC,CAAE;EAClD;EACA;CACF,GAEMD,IAAoD;EACxD,GAAGG,EAAc7B,CAAK;EAGtB,WAAW;GACT,IAAM8B,IAAUjC,EAAc,GACxBC,IAAoC,CAAC;GAC3C,KAAK,IAAM,KAAKE,EAAM,iBAAiB,GACrC,AAAI8B,EAAQ,IAAI,EAAE,KAAK,KAAGhC,EAAI,KAAK,CAAC;GAEtC,OAAOA;EACT;EACA,QAAQ,GAAI;GACV,IAAMiC,IAAMC,EAASL,CAAE,GACjB,IAAI3B,EAAM,IAAI+B,CAAG;GACvB,IAAI,CAAC,GAAG,MAAU,MAAM,iCAAiCJ,EAAG,EAAE;GAC9D,OAAOM,EAAcjC,GAAO,CAAC;EAC/B;EACA,aAAa,GAAI;GACf,IAAMkC,IAAIlC,EAAM,IAAIgC,EAASL,CAAE,CAAC;GAChC,OAAOO,MAAM,KAAA,KAAaC,EAAaD,CAAC;EAC1C;EACA,aAAa,GAAI;GAEf,OADKjB,IACEmB,EAAiBV,GAASC,GAAIX,EAAY,OAAO,IADlCU,EAAQ,QAAQC,CAAE;EAE1C;EAGA,GAAIV,IAAW,EAAE,aAAaD,EAAY,QAAQ,IAAI,CAAC;EACvD,GAAIO,IAAU,EAAE,UAAU,GAAY,MAAgBA,EAAQ,QAAQS,EAASL,CAAE,GAAGU,CAAI,EAAE,IAAI,CAAC;EAC/F,WAAW,GAAI,GAAY;GACzB,IAAId,MAAY,QAAQvB,EAAM,IAAIgC,EAASL,CAAE,CAAC,CAAC,EAAE,SAAS,aACxD,OAAOW,EAAgBtC,GAAO2B,GAAIY,KAAclC,CAAC;GAGnD,IAAMmC,IAAUC,EAAiBzC,GAAOgC,EAASL,CAAE,GAAGtB,IAAI,MAASqB,EAAQ,QAAQC,GAAIU,CAAI,CAAC;GAC5F,OAAOC,EAAgBtC,GAAO2B,GAAIY,KAAclC,GAAGmC,CAAO;EAC5D;EACA,iBAAiBxC,EAAM,OAAO,KAAK,OAAO;GAAE,IAAI0C,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACjG,kBAAkB,MAAa1C,EAAM,UAAU2C,CAAQ;EACvD,YAAY,MAAO3C,EAAM,SAASgC,EAASL,CAAE,CAAC;EAG9C,SAAS,GAAW,GAAgB;GAClC,AAAIiB,MAAU,KAAA,IAGZC,EAAW,MAAMC,CAAG,IAFpB9C,EAAM,WAAW8C,GAAKF,GAAO,IAAI;EAIrC;EACA;EACA;EAGA,YAAY,GAAc,GAAuB;GAC/C,OAAOG,EACL/C,GACAgD,GACA5B,EAAYC,CAAI,GAChBhB,GACA,EAAE,mBAAmB,GAAK,CAC5B;EACF;EACA,aAAa,GAAS,GAAoB,GAAuB;GAC/D,OAAO4C,EACLjD,GACAkD,GACAC,GACA/B,EAAYC,CAAI,GAChBhB,GACA,EAAE,mBAAmB,GAAK,CAC5B;EACF;EAKA,GAAIH,EAAQ,eACR,EACE,eAAe,MAAoE;GACjF,IAAMkD,IAAUlD,EAAQ,aAAcmD,CAAM;GAC5C,IAAI,CAACD,GAAS,OAAO;GACrB,IAAMrD,IAASG,EAAQ,eAAgB;GAEvC,OAAO;IACL,MAAM;IACN,IAHSkD,EAAQ,OAAO,KAAA,IAAYpD,EAAM,OAAO,IAAIgC,EAASoB,EAAQ,EAAE;IAIxE;IACA,MAAMA,EAAQ;IACd,MAAMA,EAAQ;IACd,QAAQ;GACV;EACF,EACF,IACA,CAAC;EAEL,kBAAkB,GAAkC;GAClD,OAAOE,EAAuB7B,GAAc8B,CAAG;EACjD;EACA,YACE,GACA,GACA,GAC8B;GAC9B,OAAOC,EAAmB/B,GAAcgC,GAAWC,GAAQC,CAAG;EAChE;EAGA,iBAA6C;GAC3C,OAAO;IAAE,IAAI;IAAI,IAAI;GAAG;EAC1B;CACF;CAEA,OAAOjC;AACT"}

package/dist/canvas/sceneClipboard.js

@@ -1,7 +1,7 @@
 import { definesFrame as e } from "../core/scene/effectivePose.js";
 import { asNodeId as t } from "../core/scene/types.js";
 import { NODE_FN_FIELDS as n, createNodeFnFields as r, fnFieldsOfNode as i, fnKeysOf as a } from "../core/scene/nodeFnFields.js";
-import { pickability as o } from "../core/scene/pickability.js";
+import { statedFields as o } from "../core/scene/statedFields.js";
 //#region src/canvas/sceneClipboard.ts
 function s(e) {
 	return Array.isArray(e) ? [...e] : typeof e == "object" && e ? { ...e } : e;

package/dist/canvas/sceneClipboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneClipboard.js","names":["copyField","value","dependencyList","item","snapshotSceneSelection","env","fnFields","createNodeFnFields","scene","idSet","ids","taken","items","poseFor","n","isRoot","frame","capture","id","asNodeId","pickability","fnFieldsOfNode","fnKeysOf","cid","a","isLive","member","restoredFnFields","out","registry","spec","NODE_FN_FIELDS","key","fn","omissions","present","src","changed","omission","deps","missing","dep","fns","pasteSceneSnapshot","all","clipboard","omitted","ctx","idMap","byId","ridesPastedFrame","p","definesFrame","dx","offset","dy","minX","minY","b","c"],"sources":["../../src/canvas/sceneClipboard.ts"],"sourcesContent":["/**\n * The scene adapter's clipboard seam: what a copy captures and what a paste\n * mints from it.\n *\n * `snapshotSceneSelection` captures adapter-shaped node copies;\n * `pasteSceneSnapshot` is a pure factory — it mints fresh nodes and never\n * touches the scene. Insertion happens through the caller's InsertOps (one per\n * created node, parents before children), which is what makes a whole paste a\n * single undo entry.\n *\n * A snapshot item carries its node's function fields twice: live, for a paste\n * in the same session, and as the scene's registry keys, for a snapshot that\n * crossed JSON on the way back.\n */\nimport type { ClipboardSnapshot, PasteCtx, PasteOmission } from 'core/adapters/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport {\n  NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, type FnBearingNode,\n} from 'core/scene/nodeFnFields';\nimport { pickability } from 'core/scene/pickability';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\n\n/** What the seam needs from the adapter it serves. */\nexport interface SceneClipboardEnv<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Whether a stored pose is relative to its container's frame. */\n  composes: boolean;\n  worldPoseOf(id: string): TPose;\n  /** The nearest frame-defining container at or above `id`. */\n  frameAtOrAbove(id: string | null): string | null;\n  poseBounds(pose: TPose, node: unknown): Bounds;\n  translate(pose: TPose, dx: number, dy: number, node?: unknown): TPose;\n}\n\n// Spread-level copy per the clipboard contract: mutating a snapshot's\n// pose/data/children must not touch the scene.\nfunction copyField<T>(value: T): T {\n  if (Array.isArray(value)) return [...value] as T;\n  if (value !== null && typeof value === 'object') return { ...(value as object) } as T;\n  return value;\n}\n\ntype Item<TData, TLayer extends string, TPose> =\n  Node<TData, TLayer, TPose> & Record<string, unknown>;\n\nconst dependencyList = (item: { dependsOn?: readonly NodeId[] | 'children' }): readonly NodeId[] =>\n  (Array.isArray(item.dependsOn) ? item.dependsOn : []);\n\nexport function snapshotSceneSelection<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  ids: string[],\n): ClipboardSnapshot {\n  const { scene } = env;\n  const fnFields = createNodeFnFields<TPose>(scene.registry as never);\n  const idSet = new Set(ids);\n  const taken = new Set<string>();\n  const items: Node<TData, TLayer, TPose>[] = [];\n  // A stored pose is relative to its frame, and a node whose frame is not\n  // copied with it lands somewhere else entirely on paste. Capture those in\n  // world coordinates: every root, and under an envelope root, the nodes\n  // sharing the frame the root left behind.\n  const poseFor = (n: Node<TData, TLayer, TPose>, isRoot: boolean): TPose => {\n    if (!env.composes) return n.pose;\n    if (isRoot) return env.worldPoseOf(n.id);\n    const frame = env.frameAtOrAbove(n.parent);\n    return frame !== null && taken.has(frame) ? n.pose : env.worldPoseOf(n.id);\n  };\n\n  // DFS from one snapshot root: push the node, then its subtree —\n  // parents-before-children, so paste can re-insert in array order.\n  const capture = (id: string, isRoot = false): void => {\n    if (taken.has(id)) return;\n    const n = scene.get(asNodeId(id));\n    if (!n) return;\n    taken.add(id);\n    items.push({\n      kind: n.kind,\n      id: n.id,\n      layer: n.layer,\n      parent: n.parent,\n      pose: copyField(poseFor(n, isRoot)),\n      data: copyField(n.data),\n      ...(n.kind === 'container' ? { children: [...n.children] } : {}),\n      ...pickability(n),\n      ...(n.dependsOn !== undefined ? { dependsOn: copyField(n.dependsOn) } : {}),\n      ...fnFieldsOfNode(n),\n      ...fnKeysOf(fnFields, n as unknown as FnBearingNode, 'jsonKey'),\n    } as Node<TData, TLayer, TPose>);\n    if (n.kind === 'container') {\n      for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);\n    }\n  };\n  for (const id of ids) {\n    // Dedupe: an id whose ancestor is also selected is already covered\n    // by that ancestor's subtree walk.\n    if (scene.ancestorsOf(asNodeId(id)).some((a) => idSet.has(a))) continue;\n    capture(id, true);\n  }\n  return { items };\n}\n\n// JSON drops a function, and turns a layout strategy into an object with no\n// methods on it: neither is something a pasted node can run.\nconst isLive = (value: unknown): boolean =>\n  typeof value === 'function'\n  || (typeof value === 'object' && value !== null\n    && Object.values(value).some((member) => typeof member === 'function'));\n\n/**\n * The item's function fields: for each, what its registry key names in this\n * scene, else the live one it carries, else nothing.\n */\nfunction restoredFnFields<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  item: Item<TData, TLayer, TPose>,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  const registry = scene.registry as Record<string, Record<string, unknown> | undefined>;\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && item.kind !== 'container') continue;\n    const key = item[spec.jsonKey];\n    const registered = typeof key === 'string' ? registry[spec.field]?.[key] : undefined;\n    const fn = registered ?? (isLive(item[spec.field]) ? item[spec.field] : undefined);\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out;\n}\n\n/**\n * Which items a paste leaves out, and why. A node deriving from an id list is\n * pasted only with everything it depends on, since a copy still naming the\n * originals would follow them rather than the copies beside it; and only with\n * a derivation to run, since without one it is a placeholder that paints\n * nothing. Leaving one out can strand another, so this runs to a fixed point.\n */\nfunction omissions<TData, TLayer extends string, TPose>(\n  src: readonly Item<TData, TLayer, TPose>[],\n  fns: ReadonlyMap<string, Record<string, unknown>>,\n): Map<string, PasteOmission> {\n  const out = new Map<string, PasteOmission>();\n  const present = new Set(src.map((item) => item.id as string));\n  for (let changed = true; changed;) {\n    changed = false;\n    for (const item of src) {\n      if (out.has(item.id)) continue;\n      let omission: PasteOmission | undefined;\n      const deps = dependencyList(item);\n      const missing = deps.filter((dep) => !present.has(dep));\n      const fn = fns.get(item.id)!;\n      if (item.parent !== null && out.has(item.parent)) {\n        omission = { id: item.id, reason: 'container-not-pasted' };\n      } else if (missing.length > 0) {\n        omission = { id: item.id, reason: 'dependency-not-copied', missing };\n      } else if (deps.length > 0 && fn.derivePath === undefined && fn.derivePose === undefined) {\n        omission = { id: item.id, reason: 'derivation-not-registered' };\n      }\n      if (omission === undefined) continue;\n      out.set(item.id, omission);\n      present.delete(item.id);\n      changed = true;\n    }\n  }\n  return out;\n}\n\nexport function pasteSceneSnapshot<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  clipboard: ClipboardSnapshot,\n  offset: { dx: number; dy: number },\n  ctx?: PasteCtx,\n): Node<TData, TLayer, TPose>[] {\n  // Snapshot items are adapter-shaped node copies: what the snapshot captures,\n  // and what this returns (`useClipboardOps` feeds `created` back in as the\n  // next cascade source).\n  const all = clipboard.items as Item<TData, TLayer, TPose>[];\n  if (all.length === 0) return [];\n  const fns = new Map(all.map((item) => [item.id as string, restoredFnFields(env.scene, item)]));\n  const omitted = omissions(all, fns);\n  if (ctx?.onOmit) for (const item of all) {\n    const omission = omitted.get(item.id);\n    if (omission) ctx.onOmit(omission);\n  }\n  const src = omitted.size === 0 ? all : all.filter((item) => !omitted.has(item.id));\n\n  const idMap = new Map<string, NodeId>();\n  for (const item of src) idMap.set(item.id, env.scene.mintId());\n  // Items whose captured parent isn't part of the snapshot become roots\n  // of the pasted cluster.\n  const isRoot = (item: Node<TData, TLayer, TPose>): boolean =>\n    item.parent === null || !idMap.has(item.parent);\n  // Under a composing strategy a node inside a pasted frame rides it, and\n  // offsetting it as well would move it twice.\n  const byId = new Map(src.map((item) => [item.id as string, item]));\n  const ridesPastedFrame = (item: Node<TData, TLayer, TPose>): boolean => {\n    if (!env.composes) return false;\n    let p = item.parent === null ? undefined : byId.get(item.parent);\n    while (p !== undefined) {\n      if (definesFrame(p)) return true;\n      p = p.parent === null ? undefined : byId.get(p.parent);\n    }\n    return false;\n  };\n  // Without composition poses are absolute, so the delta applies to EVERY\n  // pasted node — the cluster translates rigidly, descendants staying\n  // attached to their parents.\n  let dx = offset.dx;\n  let dy = offset.dy;\n  if (ctx?.dropPoint) {\n    // Drop-point policy: land the cluster origin (min corner of the root\n    // items' bounds) on the drop point; `offset` is ignored.\n    let minX = Infinity;\n    let minY = Infinity;\n    for (const item of src) {\n      if (!isRoot(item)) continue;\n      const b = env.poseBounds(item.pose, item);\n      if (b.x < minX) minX = b.x;\n      if (b.y < minY) minY = b.y;\n    }\n    if (Number.isFinite(minX) && Number.isFinite(minY)) {\n      dx = ctx.dropPoint.worldX - minX;\n      dy = ctx.dropPoint.worldY - minY;\n    }\n  }\n  // `src` is parents-before-children and this keeps it, so children re-attach\n  // to freshly inserted parents when the caller's InsertOps apply in order.\n  return src.map((item) => ({\n    id: idMap.get(item.id)!,\n    kind: item.kind,\n    layer: item.layer,\n    parent: isRoot(item) ? null : idMap.get(item.parent as string)!,\n    pose: ridesPastedFrame(item)\n      ? copyField(item.pose)\n      : env.translate(copyField(item.pose), dx, dy, item),\n    data: copyField(item.data),\n    ...pickability(item),\n    ...(item.kind === 'container'\n      ? { children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)!) }\n      : {}),\n    ...(item.dependsOn === 'children'\n      ? { dependsOn: 'children' as const }\n      : dependencyList(item).length > 0\n        ? { dependsOn: dependencyList(item).map((dep) => idMap.get(dep)!) }\n        : {}),\n    ...fns.get(item.id),\n  } as Node<TData, TLayer, TPose>));\n}\n"],"mappings":"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"}
+{"version":3,"file":"sceneClipboard.js","names":["copyField","value","dependencyList","item","snapshotSceneSelection","env","fnFields","createNodeFnFields","scene","idSet","ids","taken","items","poseFor","n","isRoot","frame","capture","id","asNodeId","statedFields","fnFieldsOfNode","fnKeysOf","cid","a","isLive","member","restoredFnFields","out","registry","spec","NODE_FN_FIELDS","key","fn","omissions","present","src","changed","omission","deps","missing","dep","fns","pasteSceneSnapshot","all","clipboard","omitted","ctx","idMap","byId","ridesPastedFrame","p","definesFrame","dx","offset","dy","minX","minY","b","c"],"sources":["../../src/canvas/sceneClipboard.ts"],"sourcesContent":["/**\n * The scene adapter's clipboard seam: what a copy captures and what a paste\n * mints from it.\n *\n * `pasteSceneSnapshot` is a pure factory — it mints fresh nodes and never\n * touches the scene. Insertion happens through the caller's InsertOps (one per\n * created node, parents before children).\n *\n * A snapshot item carries its node's function fields twice: live, for a paste\n * in the same session, and as the scene's registry keys, for a snapshot that\n * crossed JSON on the way back.\n */\nimport type { ClipboardSnapshot, PasteCtx, PasteOmission } from 'core/adapters/types';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport { definesFrame } from 'core/scene/effectivePose';\nimport {\n  NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, type FnBearingNode,\n} from 'core/scene/nodeFnFields';\nimport { statedFields } from 'core/scene/statedFields';\nimport type { Bounds } from '../core/viewport/fitViewToBounds';\n\n/** What the seam needs from the adapter it serves. */\nexport interface SceneClipboardEnv<TData, TLayer extends string, TPose> {\n  scene: Scene<TData, TLayer, TPose>;\n  /** Whether a stored pose is relative to its container's frame. */\n  composes: boolean;\n  worldPoseOf(id: string): TPose;\n  /** The nearest frame-defining container at or above `id`. */\n  frameAtOrAbove(id: string | null): string | null;\n  poseBounds(pose: TPose, node: unknown): Bounds;\n  translate(pose: TPose, dx: number, dy: number, node?: unknown): TPose;\n}\n\n// Spread-level copy per the clipboard contract: mutating a snapshot's\n// pose/data/children must not touch the scene.\nfunction copyField<T>(value: T): T {\n  if (Array.isArray(value)) return [...value] as T;\n  if (value !== null && typeof value === 'object') return { ...(value as object) } as T;\n  return value;\n}\n\ntype Item<TData, TLayer extends string, TPose> =\n  Node<TData, TLayer, TPose> & Record<string, unknown>;\n\nconst dependencyList = (item: { dependsOn?: readonly NodeId[] | 'children' }): readonly NodeId[] =>\n  (Array.isArray(item.dependsOn) ? item.dependsOn : []);\n\nexport function snapshotSceneSelection<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  ids: string[],\n): ClipboardSnapshot {\n  const { scene } = env;\n  const fnFields = createNodeFnFields<TPose>(scene.registry as never);\n  const idSet = new Set(ids);\n  const taken = new Set<string>();\n  const items: Node<TData, TLayer, TPose>[] = [];\n  // A stored pose is relative to its frame, and a node whose frame is not\n  // copied with it lands somewhere else entirely on paste. Capture those in\n  // world coordinates: every root, and under an envelope root, the nodes\n  // sharing the frame the root left behind.\n  const poseFor = (n: Node<TData, TLayer, TPose>, isRoot: boolean): TPose => {\n    if (!env.composes) return n.pose;\n    if (isRoot) return env.worldPoseOf(n.id);\n    const frame = env.frameAtOrAbove(n.parent);\n    return frame !== null && taken.has(frame) ? n.pose : env.worldPoseOf(n.id);\n  };\n\n  // DFS from one snapshot root: push the node, then its subtree —\n  // parents-before-children, so paste can re-insert in array order.\n  const capture = (id: string, isRoot = false): void => {\n    if (taken.has(id)) return;\n    const n = scene.get(asNodeId(id));\n    if (!n) return;\n    taken.add(id);\n    items.push({\n      kind: n.kind,\n      id: n.id,\n      layer: n.layer,\n      parent: n.parent,\n      pose: copyField(poseFor(n, isRoot)),\n      data: copyField(n.data),\n      ...(n.kind === 'container' ? { children: [...n.children] } : {}),\n      ...statedFields(n),\n      ...(n.dependsOn !== undefined ? { dependsOn: copyField(n.dependsOn) } : {}),\n      ...fnFieldsOfNode(n),\n      ...fnKeysOf(fnFields, n as unknown as FnBearingNode, 'jsonKey'),\n    } as Node<TData, TLayer, TPose>);\n    if (n.kind === 'container') {\n      for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);\n    }\n  };\n  for (const id of ids) {\n    // Dedupe: an id whose ancestor is also selected is already covered\n    // by that ancestor's subtree walk.\n    if (scene.ancestorsOf(asNodeId(id)).some((a) => idSet.has(a))) continue;\n    capture(id, true);\n  }\n  return { items };\n}\n\n// JSON drops a function, and turns a layout strategy into an object with no\n// methods on it: neither is something a pasted node can run.\nconst isLive = (value: unknown): boolean =>\n  typeof value === 'function'\n  || (typeof value === 'object' && value !== null\n    && Object.values(value).some((member) => typeof member === 'function'));\n\n/**\n * The item's function fields: for each, what its registry key names in this\n * scene, else the live one it carries, else nothing.\n */\nfunction restoredFnFields<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  item: Item<TData, TLayer, TPose>,\n): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  const registry = scene.registry as Record<string, Record<string, unknown> | undefined>;\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && item.kind !== 'container') continue;\n    const key = item[spec.jsonKey];\n    const registered = typeof key === 'string' ? registry[spec.field]?.[key] : undefined;\n    const fn = registered ?? (isLive(item[spec.field]) ? item[spec.field] : undefined);\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out;\n}\n\n/**\n * Which items a paste leaves out, and why. A node deriving from an id list is\n * pasted only with everything it depends on, since a copy still naming the\n * originals would follow them rather than the copies beside it; and only with\n * a derivation to run, since without one it is a placeholder that paints\n * nothing. Leaving one out can strand another, so this runs to a fixed point.\n */\nfunction omissions<TData, TLayer extends string, TPose>(\n  src: readonly Item<TData, TLayer, TPose>[],\n  fns: ReadonlyMap<string, Record<string, unknown>>,\n): Map<string, PasteOmission> {\n  const out = new Map<string, PasteOmission>();\n  const present = new Set(src.map((item) => item.id as string));\n  for (let changed = true; changed;) {\n    changed = false;\n    for (const item of src) {\n      if (out.has(item.id)) continue;\n      let omission: PasteOmission | undefined;\n      const deps = dependencyList(item);\n      const missing = deps.filter((dep) => !present.has(dep));\n      const fn = fns.get(item.id)!;\n      if (item.parent !== null && out.has(item.parent)) {\n        omission = { id: item.id, reason: 'container-not-pasted' };\n      } else if (missing.length > 0) {\n        omission = { id: item.id, reason: 'dependency-not-copied', missing };\n      } else if (deps.length > 0 && fn.derivePath === undefined && fn.derivePose === undefined) {\n        omission = { id: item.id, reason: 'derivation-not-registered' };\n      }\n      if (omission === undefined) continue;\n      out.set(item.id, omission);\n      present.delete(item.id);\n      changed = true;\n    }\n  }\n  return out;\n}\n\nexport function pasteSceneSnapshot<TData, TLayer extends string, TPose>(\n  env: SceneClipboardEnv<TData, TLayer, TPose>,\n  clipboard: ClipboardSnapshot,\n  offset: { dx: number; dy: number },\n  ctx?: PasteCtx,\n): Node<TData, TLayer, TPose>[] {\n  const all = clipboard.items as Item<TData, TLayer, TPose>[];\n  if (all.length === 0) return [];\n  const fns = new Map(all.map((item) => [item.id as string, restoredFnFields(env.scene, item)]));\n  const omitted = omissions(all, fns);\n  if (ctx?.onOmit) for (const item of all) {\n    const omission = omitted.get(item.id);\n    if (omission) ctx.onOmit(omission);\n  }\n  const src = omitted.size === 0 ? all : all.filter((item) => !omitted.has(item.id));\n\n  const idMap = new Map<string, NodeId>();\n  for (const item of src) idMap.set(item.id, env.scene.mintId());\n  // Items whose captured parent isn't part of the snapshot become roots\n  // of the pasted cluster.\n  const isRoot = (item: Node<TData, TLayer, TPose>): boolean =>\n    item.parent === null || !idMap.has(item.parent);\n  // Under a composing strategy a node inside a pasted frame rides it, and\n  // offsetting it as well would move it twice.\n  const byId = new Map(src.map((item) => [item.id as string, item]));\n  const ridesPastedFrame = (item: Node<TData, TLayer, TPose>): boolean => {\n    if (!env.composes) return false;\n    let p = item.parent === null ? undefined : byId.get(item.parent);\n    while (p !== undefined) {\n      if (definesFrame(p)) return true;\n      p = p.parent === null ? undefined : byId.get(p.parent);\n    }\n    return false;\n  };\n  // Without composition poses are absolute, so the delta applies to EVERY\n  // pasted node.\n  let dx = offset.dx;\n  let dy = offset.dy;\n  if (ctx?.dropPoint) {\n    // Drop-point policy: land the cluster origin (min corner of the root\n    // items' bounds) on the drop point; `offset` is ignored.\n    let minX = Infinity;\n    let minY = Infinity;\n    for (const item of src) {\n      if (!isRoot(item)) continue;\n      const b = env.poseBounds(item.pose, item);\n      if (b.x < minX) minX = b.x;\n      if (b.y < minY) minY = b.y;\n    }\n    if (Number.isFinite(minX) && Number.isFinite(minY)) {\n      dx = ctx.dropPoint.worldX - minX;\n      dy = ctx.dropPoint.worldY - minY;\n    }\n  }\n  // `src` is parents-before-children and this keeps it, so children re-attach\n  // to freshly inserted parents when the caller's InsertOps apply in order.\n  return src.map((item) => ({\n    id: idMap.get(item.id)!,\n    kind: item.kind,\n    layer: item.layer,\n    parent: isRoot(item) ? null : idMap.get(item.parent as string)!,\n    pose: ridesPastedFrame(item)\n      ? copyField(item.pose)\n      : env.translate(copyField(item.pose), dx, dy, item),\n    data: copyField(item.data),\n    ...statedFields(item),\n    ...(item.kind === 'container'\n      ? { children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)!) }\n      : {}),\n    ...(item.dependsOn === 'children'\n      ? { dependsOn: 'children' as const }\n      : dependencyList(item).length > 0\n        ? { dependsOn: dependencyList(item).map((dep) => idMap.get(dep)!) }\n        : {}),\n    ...fns.get(item.id),\n  } as Node<TData, TLayer, TPose>));\n}\n"],"mappings":"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"}

package/dist/canvas/sceneLayerPaint.js

@@ -1,11 +1,11 @@
-import { isLayerVisible as e } from "../core/layers/render.js";
+import { paintedLayers as e } from "../core/layers/render.js";
 //#region src/canvas/sceneLayerPaint.ts
 function t(e) {
 	return `scene:${e}`;
 }
 function n(t, n) {
-	let r = n.layers ? n.layers(t) : t, i = n.layerOrder, a = i ? i.map((e) => r.find((t) => t.id === e)).filter((e) => e !== void 0) : r, o = n.layerVisibility ?? {};
-	return a.filter((t) => e(t, o));
+	let r = n.layers ? n.layers(t) : t;
+	return e(r, n.layerVisibility ?? {}, n.layerOrder);
 }
 function r() {
 	let e = null;
@@ -32,6 +32,6 @@ function i(e, n) {
 	return r === void 0 && i === void 0 ? e : (i ? i.map((n) => e.find((e) => t(e.id) === n)).filter((e) => e !== void 0) : e).filter((e) => r?.[t(e.id)] !== !1);
 }
 //#endregion
-export { r as createSceneLayerGate, n as paintedLayers, i as paintedSceneLayers, t as sceneLayerKey };
+export { r as createSceneLayerGate, i as paintedSceneLayers, t as sceneLayerKey, n as viewPaintedLayers };
 
 //# sourceMappingURL=sceneLayerPaint.js.map

package/dist/canvas/sceneLayerPaint.js.map

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

package/dist/canvas/sceneSlotWiring.js

@@ -1,20 +1,21 @@
-import { sceneDerivedPathOf as e, withDerivedPaths as t } from "./derivedPath.js";
-import { withColorOverrides as n } from "./colorOverrides.js";
+import { sceneDerivedPathOf as e, sceneShownToPose as t, withDerivedPaths as n } from "./derivedPath.js";
+import { withColorOverrides as r } from "./colorOverrides.js";
 //#region src/canvas/sceneSlotWiring.ts
-function r(e, t) {
+function i(e, t) {
 	let n = (t) => e.overrides.read(t)?.alpha ?? 1;
 	return t ? (e) => t(e) * n(e) : n;
 }
-function i(i, a, o, s, c) {
-	let l = t(a, i.drawOne, i.toPose, c), u = e(a, i.toPose, c);
+function a(a, o, s, c) {
+	let l = n(o, a.drawOne, a.toPose), u = e(o, a.toPose);
 	return {
-		...i,
-		drawOne: s ? n(s, l) : l,
+		...a,
+		...a.toPose ? { toPose: t(o, a.toPose) } : {},
+		drawOne: c ? r(c, l) : l,
 		derivedPathOf: u,
-		alphaFor: r(a, o)
+		alphaFor: i(o, s)
 	};
 }
 //#endregion
-export { r as composeAlphaFor, i as wireSceneSlotToScene };
+export { i as composeAlphaFor, a as wireSceneSlotToScene };
 
 //# sourceMappingURL=sceneSlotWiring.js.map

package/dist/canvas/sceneSlotWiring.js.map

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

package/dist/canvas/sceneViewRender.js

@@ -1,66 +1,61 @@
-import { viewToMat3 as e } from "../renderer/math/viewToMat3.js";
-import { cullDrawCommands as t } from "../renderer/cullDrawCommands.js";
-import { effectivePose as n } from "../core/scene/effectivePose.js";
-import { paintedSceneLayers as r } from "./sceneLayerPaint.js";
-import { paintCanvas as i } from "./canvasRenderer.js";
-import { wrapNodeOutput as a } from "./wrapNodeOutput.js";
-import { sceneDerivedPathOf as o, withDerivedPaths as s } from "./derivedPath.js";
-import { buildSceneTree as c } from "./buildSceneTree.js";
-import { withColorOverrides as l } from "./colorOverrides.js";
-import { paintMissesView as u } from "./paintCull.js";
-import { paintBoundsFor as d } from "./defaultDrawOne.js";
+import { paintedSceneLayers as e } from "./sceneLayerPaint.js";
+import { paintCanvas as t } from "./canvasRenderer.js";
+import { wrapNodeOutput as n } from "./wrapNodeOutput.js";
+import { sceneDerivedPathOf as r, withDerivedPaths as i } from "./derivedPath.js";
+import { buildSceneTree as a } from "./buildSceneTree.js";
+import { sceneToAdapter as o } from "./sceneAdapter.js";
+import { withColorOverrides as s } from "./colorOverrides.js";
+import { paintMissesView as c } from "./paintCull.js";
+import { paintBoundsFor as l } from "./defaultDrawOne.js";
+import { cullDrawCommands as u } from "@weasel-js/renderer";
+import { viewToMat3 as d } from "@weasel-js/geom";
 //#region src/canvas/sceneViewRender.ts
-function f(e, t = {}) {
+function f(t, n = {}) {
+	let { getNode: r, getChildren: i, getPose: a, composePose: s } = o(t);
 	return {
-		getLayers: () => r(e.layers, t).map((e) => ({
+		getLayers: () => e(t.layers, n).map((e) => ({
 			id: e.id,
 			visible: e.visible,
 			parallax: e.parallax
 		})),
-		getNode: (t) => e.get(t),
-		getChildren: (t) => {
-			if (t === null) return e.roots;
-			let n = e.get(t);
-			return n && n.kind === "container" ? n.children : [];
-		},
-		getPose: (t) => n(e, e.get(t))
+		getNode: r,
+		getChildren: i,
+		getPose: a,
+		...s ? { composePose: s } : {}
 	};
 }
-function p(n, r, i, d, p, m, h, g, _) {
-	let v = s(n, i, void 0, m), y = g ? l(g, v) : v, b = o(n, void 0, m), x = (e, t, r) => {
-		let i = n.overrides.read(e.id)?.alpha ?? 1;
-		return a(y(e, t, r), t, (p ? p(e.id) : 1) * i);
-	}, S = m !== void 0 && m.closure !== "identity" ? {
-		...f(n, h),
-		composePose: m.compose
-	} : f(n, h), C = _ ? {
+function p(e, t, o, l, p, m, h, g) {
+	let _ = i(e, o), v = h ? s(h, _) : _, y = r(e), b = (t, r, i) => {
+		let a = e.overrides.read(t.id)?.alpha ?? 1;
+		return n(v(t, r, i), r, (p ? p(t.id) : 1) * a);
+	}, x = f(e, m), S = g ? {
 		x: 0,
 		y: 0,
-		width: _.width,
-		height: _.height
-	} : void 0, w = C && _?.paintBounds ? u(_.paintBounds, r, C) : void 0, T = c(S, x, r, void 0, b, w), E = C ? t(T, e(r), C) : T;
-	if (d && d.length > 0) for (let e of d) E.push(e);
+		width: g.width,
+		height: g.height
+	} : void 0, C = S && g?.paintBounds ? c(g.paintBounds, t, S) : void 0, w = a(x, b, t, void 0, y, C), T = S ? u(w, d(t), S) : w;
+	if (l && l.length > 0) for (let e of l) T.push(e);
 	return [{
 		kind: "group",
-		transform: e(r),
-		children: E
+		transform: d(t),
+		children: T
 	}];
 }
 function m(e) {
-	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: o, alphaFor: s, layerVisibility: c, layerOrder: l, colorOverrides: u, cull: f } = e;
-	return p(t, n, a, o, s, void 0, {
+	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: o, alphaFor: s, layerVisibility: c, layerOrder: u, colorOverrides: d, cull: f } = e;
+	return p(t, n, a, o, s, {
 		layerVisibility: c,
-		layerOrder: l
-	}, u, f ? {
+		layerOrder: u
+	}, d, f ? {
 		width: r,
 		height: i,
-		paintBounds: e.paintBounds ?? d(a)
+		paintBounds: e.paintBounds ?? l(a)
 	} : void 0);
 }
 function h(e) {
-	let { canvas: t, view: n, width: r, height: a, dpr: o } = e;
-	i(t, m(e), n, {
-		width: r,
+	let { canvas: n, view: r, width: i, height: a, dpr: o } = e;
+	t(n, m(e), r, {
+		width: i,
 		height: a,
 		dpr: o
 	});

package/dist/canvas/sceneViewRender.js.map

@@ -1 +1 @@
-{"version":3,"file":"sceneViewRender.js","names":["sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","poseComposition","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","children","cullDrawCommands","viewToMat3","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n *\n * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer\n * ordering, debug sinks, tool overlays). The helper deliberately re-implements\n * the small subset needed for a non-interactive scene view rather than\n * refactoring `<SceneCanvas>` to share code — the spec calls for that\n * dedupe as a follow-up.\n *\n * Note: this duplicates `<SceneCanvas>`'s GL setup + view-wrap pattern in\n * miniature. When `<SceneCanvas>` is eventually migrated onto this helper,\n * the duplication collapses; until then, keep the two render paths\n * in sync by hand where it matters (DPR handling, viewToMat3 wrap).\n */\n\nimport type { WeaselRenderer } from '../renderer/WeaselRenderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '../renderer/cullDrawCommands';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The helper owns its WebGL2 context: the\n   *  first call on a given canvas creates a renderer and stashes it; subsequent\n   *  calls reuse the same renderer (and resize the drawing buffer on dim\n   *  changes). `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  /** Scene to walk. `scene.renderOrder()` provides the per-node order. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene + extras (both ride the same world→screen\n   *  transform; extras living in screen space should be supplied via a\n   *  separately-prepared `extraCommands` group or rendered outside this\n   *  helper). */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; CSS size to `width` / `height`. */\n  width: number;\n  height: number;\n  /** Per-node draw callback. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional commands appended after the scene-node output. Used for the\n   *  minimap's visible-window indicator. Wrapped in the same view transform\n   *  as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`\n   *  when available, otherwise 1. Tests typically pin this to 1 or 2. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks. Built\n * inline rather than via `sceneToAdapter` so this module stays free of React\n * — `renderSceneToPixels` runs headless.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode: (id) => scene.get(id as NodeId),\n    getChildren: (parentId) => {\n      if (parentId === null) return scene.roots as readonly string[];\n      const node = scene.get(parentId as NodeId);\n      return node && node.kind === 'container' ? (node.children as readonly string[]) : [];\n    },\n    getPose: (id) => effectivePose(scene, scene.get(id as NodeId)!),\n  } as HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.\n *\n * Pure — no GL, no DOM, no side effects. Walks the scene through\n * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —\n * appends any `extraCommands`, and wraps the result in a single\n * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen\n * space. Sharing the walk is what keeps hidden layers unpainted and container\n * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.\n *\n * Each node's commands additionally go through `wrapNodeOutput` — pose\n * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`\n * does, so a `drawOne` shared between the two paints the same thing in both.\n * A `drawOne` that rotates its own output will therefore rotate twice here;\n * emit unrotated geometry and let the pose drive it.\n *\n * Output shape follows `buildSceneTree`: one group per **visible** layer, in\n * scene-layer order (or `layers.layerOrder`), each holding one group per node\n * on that layer.\n *\n * Exported for tests and for callers that want to render into something\n * other than a real `<canvas>` (e.g. an offscreen renderer or a\n * snapshot fixture).\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model. */\n  poseComposition?: PoseComposition<TPose>,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  // The scene is in scope here, so this is where the override's alpha and the\n  // derived paths are applied on the headless path; `SceneCanvas` does the same\n  // for the live one. `Canvas` itself never sees a scene, so it can't and doesn't.\n  const derivedOnly = withDerivedPaths(scene, drawOne, undefined, poseComposition);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(scene, undefined, poseComposition);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const composes = poseComposition !== undefined && poseComposition.closure !== 'identity';\n  const hierarchy = composes\n    ? { ...sceneAsHierarchy(scene, layers), composePose: poseComposition!.compose }\n    : sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    derivedPathOf as unknown as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, undefined, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. See module docstring\n * for the design context.\n *\n * Paints through `paintCanvas` (`./canvasRenderer`): one renderer per canvas,\n * created on the first call and resized when `width` / `height` / `dpr`\n * change. Where no WebGL2 context is available (jsdom) the call paints\n * nothing. The renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;AAyHA,SAASA,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,OAAO;EACL,iBACEC,EAAmBC,EAAM,QAAQC,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE,UAAU,MAAOF,EAAM,IAAIG,CAAY;EACvC,cAAc,MAAa;GACzB,IAAIC,MAAa,MAAM,OAAOJ,EAAM;GACpC,IAAMK,IAAOL,EAAM,IAAII,CAAkB;GACzC,OAAOC,KAAQA,EAAK,SAAS,cAAeA,EAAK,WAAiC,CAAC;EACrF;EACA,UAAU,MAAOC,EAAcN,GAAOA,EAAM,IAAIG,CAAY,CAAE;CAChE;AACF;AA0BA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAGA,GAEA,GAEA,GAGA,GACe;CAIf,IAAMC,IAAcC,EAAiBT,GAAOU,GAAS,KAAA,GAAWC,CAAe,GACzEC,IAAUC,IAAiBC,EAAmBD,GAAgBL,CAAW,IAAIA,GAC7EO,IAAgBC,EAAmBhB,GAAO,KAAA,GAAWW,CAAe,GACpEM,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBlB,EAAM,UAAU,KAAKK,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOc,EACLP,EAAQP,GAAMe,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAASjB,EAAK,EAAE,IAAI,KAAKa,CACvC;CACF,GAGMK,IADWZ,MAAoB,KAAA,KAAaA,EAAgB,YAAY,aAE1E;EAAE,GAAGb,EAAiBE,GAAOC,CAAM;EAAG,aAAaU,EAAiB;CAAQ,IAC5Eb,EAAiBE,GAAOC,CAAM,GAE5BuB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BP,GACAN,GACAW,GACA,KAAA,GACAb,GACAW,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAMI,EAAWL,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAIK,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWF,EAAWL,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBQ,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO9B,EACLP,GAAO4B,GAAMlB,GAASwB,GAAeZ,GAAU,KAAA,GAAW;EAAE;EAAiB;CAAW,GAAGT,GAC3FY,IAAO;EAAE;EAAO;EAAQ,aAAaY,EAAK,eAAeC,EAAe5B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAWA,SAAgB6B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGT,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}
+{"version":3,"file":"sceneViewRender.js","names":["viewToMat3","viewToMat3$1","sceneAsHierarchy","sceneToAdapter","scene","paintedSceneLayers","layers","l","composePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","derivedPathOf","sceneDerivedPathOf","wrappedDrawOne","overrideAlpha","node","wrapNodeOutput","pose","v","alphaFor","hierarchy","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","children","cullDrawCommands","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n */\n\nimport type { WeaselRenderer } from '@weasel-js/renderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport { viewToMat3 } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { sceneToAdapter } from './sceneAdapter';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '@weasel-js/animator';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '@weasel-js/renderer';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The first call on a given canvas creates\n   *  its renderer and later calls reuse it;\n   *  `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene and `extraCommands` alike. */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; the element's CSS size is the caller's to set. */\n  width: number;\n  height: number;\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Commands appended after the scene-node output, wrapped in the same view\n   *  transform as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Device-pixel ratio. Defaults to `window.devicePixelRatio || 1` when\n   *  available, otherwise 1. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks: the scene\n * adapter's own reads, under this view's layer list.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  const { getNode, getChildren, getPose, composePose } = sceneToAdapter(scene);\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode,\n    getChildren,\n    getPose,\n    ...(composePose ? { composePose } : {}),\n  };\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch, in\n * screen space. Pure — no GL, no DOM. Walks the scene through `buildSceneTree`,\n * the same walk `<SceneCanvas>` uses, which is what keeps hidden layers\n * unpainted and container clips applied here.\n *\n * Each node's commands go through `wrapNodeOutput` — pose rotation, then the\n * `alphaFor` multiplier — so a `drawOne` that rotates its own output rotates\n * twice; emit unrotated geometry and let the pose drive it.\n *\n * Output is one group per **visible** layer, in scene-layer order (or\n * `layers.layerOrder`), each holding one group per node on that layer.\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const derivedPathOf = sceneDerivedPathOf(scene);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.read(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const hierarchy = sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    derivedPathOf as unknown as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. Where no WebGL2\n * context is available (jsdom) the call paints nothing. The canvas's renderer\n * lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;AAoGA,SAASE,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,IAAM,EAAE,YAAS,gBAAa,YAAS,mBAAgBC,EAAeC,CAAK;CAC3E,OAAO;EACL,iBACEC,EAAmBD,EAAM,QAAQE,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE;EACA;EACA;EACA,GAAIC,IAAc,EAAE,eAAY,IAAI,CAAC;CACvC;AACF;AAeA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GAEA,GAEA,GAGA,GACe;CACf,IAAMC,IAAcC,EAAiBP,GAAOQ,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAgBC,EAAmBb,CAAK,GACxCc,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBf,EAAM,UAAU,KAAKgB,EAAK,EAAY,CAAC,EAAE,SAAS;EACxE,OAAOC,EACLR,EAAQO,GAAME,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAASJ,EAAK,EAAE,IAAI,KAAKD,CACvC;CACF,GAEMM,IAAYvB,EAAiBE,GAAOE,CAAM,GAE1CoB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BP,GACAP,GACAY,GACA,KAAA,GACAd,GACAY,CACF,GACMK,IAAWP,IAAWQ,EAAiBH,GAAM/B,EAAW8B,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAII,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWpC,EAAW8B,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBO,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO7B,EACLL,GAAO0B,GAAMlB,GAASuB,GAAeX,GAAU;EAAE;EAAiB;CAAW,GAAGV,GAChFa,IAAO;EAAE;EAAO;EAAQ,aAAaW,EAAK,eAAeC,EAAe3B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAOA,SAAgB4B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGR,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/slopsDebugLayer.js

@@ -38,13 +38,13 @@ function l(l) {
 						]),
 						fillRule: "nonzero"
 					},
-					fill: {
-						fill: "solid",
+					fill: { paint: {
+						kind: "solid",
 						color: s
-					},
+					} },
 					stroke: {
 						paint: {
-							fill: "solid",
+							kind: "solid",
 							color: c
 						},
 						width: 1

package/dist/canvas/slopsDebugLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { fill: 'solid', color: SLOP_FILL },\n            stroke: { paint: { fill: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM;MAAE,MAAM;MAAS,OAAOhB;KAAU;KACxC,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}
+{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { paint: { kind: 'solid', color: SLOP_FILL } },\n            stroke: { paint: { kind: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM,EAAE,OAAO;MAAE,MAAM;MAAS,OAAOhB;KAAU,EAAE;KACnD,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}

package/dist/canvas/useCanvasRenderer.js

@@ -1,19 +1,31 @@
 import { watchDevicePixelRatio as e } from "../core/device/watchDevicePixelRatio.js";
-import { leaseCanvasRenderer as t } from "./canvasRenderer.js";
-import { useEffect as n, useState as r } from "react";
+import { leaseCanvasRenderer as t, shaderKeyOf as n } from "./canvasRenderer.js";
+import { getProgramSource as r, programSourceRegistry as i } from "@weasel-js/renderer";
+import { useEffect as a, useState as o } from "react";
 //#region src/canvas/useCanvasRenderer.ts
-function i() {
-	let [e] = r(t);
-	return n(() => () => e.release(), [e]), e;
+function s() {
+	let [e] = o(t);
+	return a(() => () => e.release(), [e]), e;
 }
-function a(e, t) {
-	n(() => e.subscribeRestored(t), [e, t]);
+function c(e, t) {
+	a(() => e.subscribeRestored(t), [e, t]);
 }
-function o(t, r) {
-	let i = r === void 0;
-	n(() => i ? e(() => t()) : void 0, [i, t]);
+function l(t, n) {
+	let r = n === void 0;
+	a(() => r ? e(() => t()) : void 0, [r, t]);
+}
+function u(e, t) {
+	let o = n(e);
+	a(() => {
+		if (!o) return;
+		let e = o.split("|"), n = e.map(r);
+		return i.subscribe(() => {
+			let i = e.map(r), a = i.some((e, t) => e !== n[t]);
+			n = i, a && t();
+		});
+	}, [o, t]);
 }
 //#endregion
-export { i as useCanvasRenderer, o as useRedrawOnDensityChange, a as useRedrawOnRestore };
+export { s as useCanvasRenderer, l as useRedrawOnDensityChange, c as useRedrawOnRestore, u as useRedrawOnShaderSource };
 
 //# sourceMappingURL=useCanvasRenderer.js.map

package/dist/canvas/useCanvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","ambient","dpr","watchDevicePixelRatio"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { leaseCanvasRenderer, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n"],"mappings":";;;;AAUA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT;AAGA,SAAgBI,EAAmB,GAA4B,GAAiC;CAC9F,QAAgBJ,EAAM,kBAAkBK,CAAa,GAAG,CAACL,GAAOK,CAAa,CAAC;AAChF;AAOA,SAAgBC,EAAyB,GAA2B,GAAoB;CACtF,IAAMC,IAAUC,MAAQ,KAAA;CACxB,QAAiBD,IAAUE,QAA4BJ,EAAc,CAAC,IAAI,KAAA,GAAY,CAACE,GAASF,CAAa,CAAC;AAChH"}
+{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","ambient","dpr","watchDevicePixelRatio","useRedrawOnShaderSource","key","shaderKeyOf","shaders","ids","seen","getProgramSource","programSourceRegistry","now","changed","src","i"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT;AAGA,SAAgBI,EAAmB,GAA4B,GAAiC;CAC9F,QAAgBJ,EAAM,kBAAkBK,CAAa,GAAG,CAACL,GAAOK,CAAa,CAAC;AAChF;AAOA,SAAgBC,EAAyB,GAA2B,GAAoB;CACtF,IAAMC,IAAUC,MAAQ,KAAA;CACxB,QAAiBD,IAAUE,QAA4BJ,EAAc,CAAC,IAAI,KAAA,GAAY,CAACE,GAASF,CAAa,CAAC;AAChH;AAOA,SAAgBK,EACd,GACA,GACM;CACN,IAAMC,IAAMC,EAAYC,CAAO;CAC/B,QAAgB;EACd,IAAI,CAACF,GAAK;EACV,IAAMG,IAAMH,EAAI,MAAM,GAAG,GACrBI,IAAOD,EAAI,IAAIE,CAAgB;EACnC,OAAOC,EAAsB,gBAAgB;GAC3C,IAAMC,IAAMJ,EAAI,IAAIE,CAAgB,GAC9BG,IAAUD,EAAI,MAAM,GAAK,MAAME,MAAQL,EAAKM,EAAE;GAEpD,AADA,IAAOH,GACHC,KAASd,EAAc;EAC7B,CAAC;CACH,GAAG,CAACM,GAAKN,CAAa,CAAC;AACzB"}