@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/scene/treeReads.js.map

@@ -1 +1 @@
-{"version":3,"file":"treeReads.js","names":["createTreeReads","incarnations","nextIncarnation","nodes","id","node","token","out","cur"],"sources":["../../../src/core/scene/treeReads.ts"],"sourcesContent":["/** The scene's reads of one node and its place in the tree. */\nimport type { Node, NodeId, Scene } from './types';\n\nexport function createTreeReads<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n): Pick<Scene<TData, TLayer, TPose>, 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf'> {\n  // Keyed by node object: every entry into `nodes` is a fresh object and\n  // every edit mutates it in place, which is exactly an incarnation's lifetime.\n  const incarnations = new WeakMap<object, number>();\n  let nextIncarnation = 1;\n\n  return {\n    get: (id) => nodes.get(id),\n\n    incarnation(id) {\n      const node = nodes.get(id);\n      if (!node) return undefined;\n      let token = incarnations.get(node);\n      if (token === undefined) {\n        token = nextIncarnation++;\n        incarnations.set(node, token);\n      }\n      return token;\n    },\n\n    childrenOf(id) {\n      const n = nodes.get(id);\n      return n && n.kind === 'container' ? n.children : [];\n    },\n\n    ancestorsOf(id) {\n      const out: NodeId[] = [];\n      let cur = nodes.get(id)?.parent ?? null;\n      while (cur !== null) {\n        out.push(cur);\n        cur = nodes.get(cur)?.parent ?? null;\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAGA,SAAgBA,EACd,GACyF;CAGzF,IAAMC,oBAAe,IAAI,QAAwB,GAC7CC,IAAkB;CAEtB,OAAO;EACL,MAAM,MAAOC,EAAM,IAAIC,CAAE;EAEzB,YAAY,GAAI;GACd,IAAMC,IAAOF,EAAM,IAAIC,CAAE;GACzB,IAAI,CAACC,GAAM;GACX,IAAIC,IAAQL,EAAa,IAAII,CAAI;GAKjC,OAJIC,MAAU,KAAA,MACZ,IAAQ,KACRL,EAAa,IAAII,GAAMC,CAAK,IAEvBA;EACT;EAEA,WAAW,GAAI;GACb,IAAM,IAAIH,EAAM,IAAIC,CAAE;GACtB,OAAO,KAAK,EAAE,SAAS,cAAc,EAAE,WAAW,CAAC;EACrD;EAEA,YAAY,GAAI;GACd,IAAMG,IAAgB,CAAC,GACnBC,IAAML,EAAM,IAAIC,CAAE,CAAC,EAAE,UAAU;GACnC,OAAOI,MAAQ,OAEb,AADAD,EAAI,KAAKC,CAAG,GACZ,IAAML,EAAM,IAAIK,CAAG,CAAC,EAAE,UAAU;GAElC,OAAOD;EACT;CACF;AACF"}
+{"version":3,"file":"treeReads.js","names":[],"sources":["../../../src/core/scene/treeReads.ts"],"sourcesContent":["/** The scene's reads of one node and its place in the tree. */\nimport type { Node, NodeId, Scene } from './types';\n\nexport function createTreeReads<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n): Pick<Scene<TData, TLayer, TPose>, 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf'> {\n  // Keyed by node object: every entry into `nodes` is a fresh object and\n  // every edit mutates it in place, which is exactly an incarnation's lifetime.\n  const incarnations = new WeakMap<object, number>();\n  let nextIncarnation = 1;\n\n  return {\n    get: (id) => nodes.get(id),\n\n    incarnation(id) {\n      const node = nodes.get(id);\n      if (!node) return undefined;\n      let token = incarnations.get(node);\n      if (token === undefined) {\n        token = nextIncarnation++;\n        incarnations.set(node, token);\n      }\n      return token;\n    },\n\n    childrenOf(id) {\n      const n = nodes.get(id);\n      return n && n.kind === 'container' ? n.children : [];\n    },\n\n    ancestorsOf(id) {\n      const out: NodeId[] = [];\n      let cur = nodes.get(id)?.parent ?? null;\n      while (cur !== null) {\n        out.push(cur);\n        cur = nodes.get(cur)?.parent ?? null;\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAGA,SAAgB,gBACd,OACyF;CAGzF,MAAM,+BAAe,IAAI,QAAwB;CACjD,IAAI,kBAAkB;CAEtB,OAAO;EACL,MAAM,OAAO,MAAM,IAAI,EAAE;EAEzB,YAAY,IAAI;GACd,MAAM,OAAO,MAAM,IAAI,EAAE;GACzB,IAAI,CAAC,MAAM,OAAO;GAClB,IAAI,QAAQ,aAAa,IAAI,IAAI;GACjC,IAAI,UAAU,QAAW;IACvB,QAAQ;IACR,aAAa,IAAI,MAAM,KAAK;GAC9B;GACA,OAAO;EACT;EAEA,WAAW,IAAI;GACb,MAAM,IAAI,MAAM,IAAI,EAAE;GACtB,OAAO,KAAK,EAAE,SAAS,cAAc,EAAE,WAAW,CAAC;EACrD;EAEA,YAAY,IAAI;GACd,MAAM,MAAgB,CAAC;GACvB,IAAI,MAAM,MAAM,IAAI,EAAE,CAAC,EAAE,UAAU;GACnC,OAAO,QAAQ,MAAM;IACnB,IAAI,KAAK,GAAG;IACZ,MAAM,MAAM,IAAI,GAAG,CAAC,EAAE,UAAU;GAClC;GACA,OAAO;EACT;CACF;AACF"}

package/dist/core/scene/types.js

@@ -1,6 +1,7 @@
 //#region src/core/scene/types.ts
-var e = (e) => e;
-//#endregion
-export { e as asNodeId };
+/** Brand a string as a NodeId. */
+var asNodeId = (s) => s;
 
+//#endregion
+export { asNodeId };
 //# sourceMappingURL=types.js.map

package/dist/core/scene/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["asNodeId","s"],"sources":["../../../src/core/scene/types.ts"],"sourcesContent":["import type { History, SerializedHistory } from '@weasel-js/history';\nimport type { SerializedSceneHistory } from './historyForm';\nimport type { ParallaxOpts } from '../viewport/parallax';\nimport type { UnitScope } from '@weasel-js/quantity';\nimport type { LayoutStrategy } from '../../layout/types';\nimport type { AddLayerSpec, LayerRecord, SystemLayerRecord, SystemLayerSpec, UserLayerRecord } from './layerTypes';\nimport type { LayoutFrame, LayoutMove } from './layoutTypes';\nimport type { PoseComposition } from './composeFrame';\nimport type { PoseLinear } from '@weasel-js/geom';\nimport type { PoseHold, PoseOverride, PoseOverrides } from './poseOverrideTypes';\nimport type { SerializedLayer, SerializedNode, SerializedScene } from './serializedTypes';\n\nexport type { AddLayerSpec, LayerRecord, SystemLayerRecord, SystemLayerSpec, UserLayerRecord };\nexport type { LayoutFrame, LayoutMove, PoseHold, PoseOverride, PoseOverrides, SerializedLayer, SerializedNode, SerializedScene };\n\n/**\n * Axis-aligned rectangle pose with optional rotation. Rotation is in\n * radians, pivoted on the unrotated AABB center; absent === 0.\n */\nexport interface RectPose {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  /** Rotation in radians around the unrotated AABB center. Absent === 0. */\n  rotation?: number;\n  /** A skew or per-axis scale the box and rotation cannot hold; see\n   *  {@link PoseLinear}. Absent is the identity. */\n  transform?: PoseLinear;\n}\n\n/**\n * # SceneNode — the thing in the scene\n *\n * Everything the user sees on the canvas — a shape, a group, an annotation,\n * a tile — is a node. Containers and leaves are both nodes; the kit has no\n * other concept of \"scene element.\"\n *\n * Every node carries three independent slots, plus its tree position:\n *\n *   - **`data: TData`** — app-defined payload. The kit never inspects it.\n *   - **`pose: TPose`** — local transform, relative to the node's direct\n *     parent (or world, for root nodes).\n *   - **`layer: TLayer`** — a string tag associating the node with a\n *     visual `RenderLayer` at draw time. Separate from `LayerRecord` (the\n *     per-layer visible/locked metadata held by the `Scene`).\n *\n * Nodes are addressed by `NodeId` everywhere outside the scene tree. Don't\n * hold references to a `Node` object across scene updates; look up by id\n * when you need the latest.\n *\n * The kit-internal name is `Node`; the public re-export is `SceneNode`\n * (avoids collision with DOM `Node` at call sites).\n */\n\n/** Opaque branded id. Treat as opaque outside the kit. */\nimport type { NodeId } from '@weasel-js/routing';\nexport type { NodeId };\n\n/** Brand a string as a NodeId. */\nexport const asNodeId = (s: string): NodeId => s as NodeId;\n\nimport type { DerivedDep, Bivariant, DerivePathFn, DerivePoseFn, ClipFromPoseFn, CopiesFromPoseFn } from './nodeFnTypes';\nexport type { DerivedDep, Bivariant, DerivePathFn, DerivePoseFn, ClipFromPoseFn, CopiesFromPoseFn };\n\ninterface NodeBase<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  layer: TLayer;\n  pose: TPose;\n  data: TData;\n  parent: NodeId | null;\n  /** Nodes whose poses this node's geometry is computed from. Fixed at add\n   *  time. Absent or empty means the node's geometry is authored, which is the\n   *  normal case.\n   *\n   *  `'children'` means \"my own children, in child order\" — a container that\n   *  hugs its contents, which a fixed id list cannot express because\n   *  reparenting would have to maintain it. The two forms differ in lifetime\n   *  as well as in membership: deleting a node deletes everything that names\n   *  it in `dependsOn`, but a container outlives the children it derives\n   *  from — an emptied group is still a group. */\n  dependsOn?: readonly NodeId[] | 'children';\n  /** Whether the hit-test walk can return this node. Default `true`; `false`\n   *  makes it transparent to picking, so a click on it lands on whatever is\n   *  behind — normally its own container.\n   *\n   *  For content a container owns rather than content the user selects on its\n   *  own: the label inside a box, a body's rows. It does not hide the node\n   *  from anything else — it still paints, still clips, and a consumer can\n   *  still select it by id. */\n  pickable?: boolean;\n  /** Computes this node's path from its dependencies, in `dependsOn` order —\n   *  each one the node and the pose it is painted at.\n   *  A dependency that has been removed arrives as `undefined`.\n   *  Returning `null` means \"nothing to draw right now\". Re-evaluated when a\n   *  dependency's world pose changes, never authored. */\n  derivePath?: DerivePathFn<TPose, TData, TLayer>;\n  /** Computes this node's pose from its dependencies' poses, the same way\n   *  `derivePath` computes its path — same `dependsOn` list, same\n   *  registry-keyed serialization.\n   *\n   *  Where a derived path is resolved at paint time and reaches only the\n   *  painter, a derived pose is what the node *is* at: it feeds bounds,\n   *  hit-testing, selection chrome, snapping and layout, and every reader\n   *  gets it through `effectivePose`. A pose override still wins over it.\n   *\n   *  Returning `null` means \"I have nothing to derive from right now\", and\n   *  the node falls back to its authored `pose`. `setPose` on a derived node\n   *  still writes that authored pose; it is simply not what anything reads. */\n  derivePose?: DerivePoseFn<TPose, TData, TLayer>;\n}\n\n/** A node with no children — a shape, a label, an image. */\nexport interface LeafNode<TData, TLayer extends string, TPose = RectPose>\n  extends NodeBase<TData, TLayer, TPose> {\n  kind: 'leaf';\n}\n\n/** A node with an ordered list of children. This is the real group: what\n *  Cmd+G creates, what SVG `<g>` round-trips to. A container has its own pose,\n *  which its children's poses are relative to, and may optionally clip them. */\nexport interface ContainerNode<TData, TLayer extends string, TPose = RectPose>\n  extends NodeBase<TData, TLayer, TPose> {\n  kind: 'container';\n  children: NodeId[];\n  /** Optional clip-path source. Re-evaluated each render. Returning `null`\n   *  means \"no clip for this container right now\"; an empty / zero-area path\n   *  means \"clip everything out\" (children render nowhere). */\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  /** Draws the whole subtree again under each affine it returns, on top of\n   *  the original, which still draws once as authored. The copies are paint,\n   *  not nodes: nothing stores them, so they follow every edit to the\n   *  children, and a pick that lands on one answers with the child it copies.\n   *  A copy is a copy of the clipped content — the clip travels with it.\n   *  Re-evaluated each render; `null` or `[]` draws no copies. */\n  copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;\n  /** How this container arranges its children. Whenever the container's\n   *  child set or order changes, or its bounds change size, the scene hands\n   *  the change to the strategy — `depart` for children that left it,\n   *  `arrive` for children that joined it, `childPoses` otherwise — and records the poses it writes in the same\n   *  undo entry as the change. A drag reads it too: it is the layout `move`\n   *  reflows and drops against. */\n  layout?: LayoutStrategy<TPose>;\n  /** The unit system this container's contents are written in, and what one\n   *  of its base units is worth in the enclosing scope's. It covers the\n   *  children, not the container; `sceneUnitScopes` reads the chain. */\n  units?: UnitScope;\n}\n\n/** A node in the scene tree: either a leaf or a container. Re-exported\n *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */\nexport type Node<TData, TLayer extends string, TPose = RectPose> =\n  | LeafNode<TData, TLayer, TPose>\n  | ContainerNode<TData, TLayer, TPose>;\n\n/** What `Scene.add` needs to mint a node. Everything except the id is\n *  required; the id is generated unless one is supplied. */\nexport interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {\n  kind: 'leaf' | 'container';\n  layer: TLayer;\n  pose: TPose;\n  data: TData;\n  parent?: NodeId | null;\n  index?: number;\n  /** Explicit id wins over the Scene's `generateId` and the kit default. */\n  id?: NodeId;\n  /** Mirrors `SceneNode.pickable`. Omit for the default, which is pickable. */\n  pickable?: boolean;\n  /** Only meaningful when `kind === 'container'`. Attach a clip-path function\n   *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  /** Mirrors `ContainerNode.copiesFromPose`; ignored for leaves. */\n  copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;\n  /** Mirrors `SceneNode.dependsOn`. */\n  dependsOn?: readonly NodeId[] | 'children';\n  /** Mirrors `SceneNode.derivePath`. Taken as a live function; its registry key is\n   *  looked up from it, never passed in. */\n  derivePath?: DerivePathFn<TPose, TData, TLayer>;\n  /** Mirrors `SceneNode.derivePose`, on the same terms as `derivePath`. */\n  derivePose?: DerivePoseFn<TPose, TData, TLayer>;\n  /** Mirrors `ContainerNode.layout`; ignored for leaves. */\n  layout?: LayoutStrategy<TPose>;\n  /** Mirrors `ContainerNode.units`; ignored for leaves. */\n  units?: UnitScope;\n}\n\n/** A custom scene mutation registered with `Scene.registerOp`: how to apply\n *  it and how to undo it. The pair is what makes it participate in history. */\nexport interface RegisteredOp<P> {\n  apply: (payload: P) => void;\n  revert: (payload: P) => void;\n  /** Opts this kind into coalescing under `UseSceneOptions.coalesceWindowMs`:\n   *  two entries of this kind that return the same key inside the window\n   *  merge, and undoing the merged entry calls `revert` with the first\n   *  payload only. Declare it only when `revert` restores an absolute state\n   *  (a stored \"from\" value), never for a relative payload such as a delta.\n   *  Omitted, or returning `undefined`, the op is always its own entry. */\n  coalesceKey?: (payload: P) => string | undefined;\n}\n\n/** Per-scene registry mapping string keys to live function references.\n *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.\n *  Each function-field type has its own keyed map. */\nexport interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {\n  /** Maps registry keys to `clipFromPose` factory functions for container nodes. */\n  clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;\n  /** Maps registry keys to `copiesFromPose` functions for container nodes. */\n  copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */\n  derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */\n  derivePose?: Readonly<Record<string, DerivePoseFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to container layout strategies. */\n  layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;\n  // A new function field is a row in `NODE_FN_FIELDS` (core/scene/nodeFnFields.ts)\n  // plus its entry here; the field name is the registry key by construction.\n}\n\n/**\n * Decides what one edit's changes to containers do to their children.\n * `arrivals` maps each container to the ids that joined it — by an `add`\n * under it or a `move` into it, whatever op or call made them — in the order\n * they arrived. `changed` names every container whose child set or order\n * changed, or whose pose changed size, arrivals included. Both are read once\n * the edit's other mutations have landed.\n *\n * Return the poses to write, in each node's stored frame; they become part of\n * the same edit, and so of the same undo step. An empty map writes nothing.\n * Return `null` to refuse: the whole edit is reverted (see\n * `SceneArrivalRefused`).\n *\n * Runs only for live edits. Undo, redo and a restored history replay the\n * arrangement that was decided the first time. With none installed, a scene\n * holding declared layouts (`ContainerNode.layout`) runs its own.\n */\nexport type SceneArrivalHandler<TPose> = (\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  /** The nodes that left each container in the edit, by the container they\n   *  left — removed, or moved out. */\n  departures: ReadonlyMap<NodeId, readonly NodeId[]>,\n) => ReadonlyMap<NodeId, TPose> | null;\n\n/** Options for `useScene` — the layers the scene has, what it starts out\n *  holding, and how its history behaves. */\nexport interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {\n  systemLayers: readonly SystemLayerSpec<TLayer>[];\n  initial?: readonly AddNodeSpec<TData, TLayer, TPose>[];\n  ops?: Readonly<Record<string, RegisteredOp<unknown>>>;\n  historyLimit?: number;\n  /** Window (ms) within which consecutive same-shaped mutations merge into\n   *  the previous undo entry (matching per-op coalesce keys — e.g. repeated\n   *  `setPose` on the same node, or repeated `applyBatch` calls whose ops\n   *  carry matching `coalesceKey` multisets). `0` (default) disables\n   *  coalescing: every mutation is a discrete undo entry. Undo of a\n   *  coalesced entry returns to the state before the first merged mutation;\n   *  redo restores the latest. `scene.batch` entries never coalesce. */\n  coalesceWindowMs?: number;\n  generateId?: () => NodeId;\n  /** Per-scene registry for non-serializable function fields (clipFromPose, etc.).\n   *  Required only when serializing/deserializing scenes that use function fields. */\n  registry?: SceneRegistry<TPose, TData, TLayer>;\n  /** How a child's pose folds into its container's. Default: it does not, and every pose is world. */\n  composition?: PoseComposition<TPose>;\n  /** How laid-out containers are measured. See {@link LayoutFrame}. */\n  layoutFrame?: LayoutFrame<TPose>;\n  /** When supplied, `scene.applyBatch` consults this on every call. If it returns a non-null\n   *  `Journal`, ops are routed to the journal's `applyBatch` instead of recording a new\n   *  parent-history entry, and undo and redo step that journal. The scene state changes as\n   *  normal; only the history tracking differs.\n   *\n   *  When the accessor isn't known at scene-construction time, wire it after\n   *  construction via `scene.setActiveJournalAccessor(fn)`. */\n  getActiveJournal?: () => import('@weasel-js/history').Journal | null;\n  /** Re-render the host on every scene mutation. Default `true`. Set `false`\n   *  when the scene is read by a frame loop rather than by a render — a game\n   *  loop, a simulation — and nothing in the host's DOM derives from it.\n   *  Read by `useScene`; `createScene` ignores it. */\n  subscribe?: boolean;\n}\n\n/**\n * The kit-owned scene tree: nodes, layers, and the undo history over both.\n *\n * A scene is logical, not visual — it says what exists and where, and nothing\n * about how it is painted. Every mutating method is undoable, and reads are\n * snapshots rather than live views. Nodes are addressed by `NodeId`; hold ids\n * across mutations, not node objects.\n *\n * Three type parameters keep it domain-agnostic: `TData` is the app's payload,\n * which the kit never inspects; `TPose` is the transform shape, `RectPose` by\n * default; `TLayer` is the union of layer names.\n */\nexport interface Scene<TData, TLayer extends string, TPose = RectPose> {\n  // Reads\n  readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  readonly roots: readonly NodeId[];\n  readonly layers: readonly LayerRecord<TLayer>[];\n  /** The registry this scene resolves node functions against — the consumer's\n   *  entries over the kit's. */\n  readonly registry: SceneRegistry<TPose, TData, TLayer>;\n  /** See {@link UseSceneOptions.composition}. */\n  readonly composition: PoseComposition<TPose>;\n  get(id: NodeId): Node<TData, TLayer, TPose> | undefined;\n  /** A token for the node `id` names right now, for telling one node from a\n   *  later one that reuses its id. It holds for as long as the node stays in\n   *  the scene, whatever edits it takes, and is different every time the id\n   *  enters the scene — by `add`, by an undo or redo that brings it back, or\n   *  by `loadState`. `undefined` when `id` is not in the scene. Compare tokens\n   *  for equality only; their order means nothing. */\n  incarnation(id: NodeId): number | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n  ancestorsOf(id: NodeId): readonly NodeId[];\n  renderOrder(): Iterable<NodeId>;\n  /** The same layer-major sequence as {@link Scene.renderOrder}, as the nodes\n   *  themselves. Prefer this wherever the ids are only going to be resolved\n   *  back to nodes. Cached until a structural edit, so repeat calls hand back\n   *  the same array — a snapshot, not a live view, and not yours to mutate. */\n  renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];\n  /** The nodes on one layer, in render order. Cached alongside\n   *  {@link Scene.renderOrderNodes} until a structural edit. A snapshot, not\n   *  a live view, and not yours to mutate. An unknown layer id yields an\n   *  empty array. */\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n\n  /** A fresh id from this scene's `generateId`, or the kit default: the id\n   *  `add` would give a spec with none. For code that has to name a node\n   *  before it exists, such as one building an insert op. */\n  mintId(): NodeId;\n\n  // Mutations (all auto-undoable)\n  add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;\n  /** Delete `id`, its **entire subtree**, and **everything that derives from**\n   *  any of those nodes — a node listing one of them in `dependsOn` goes too,\n   *  along with its own subtree, transitively. A dependent can live anywhere in\n   *  the tree, so this deletes nodes the caller never named and may unlink\n   *  several disjoint subtrees at once. Recorded as one undoable step; `undo()`\n   *  restores every one of them where it was, child order intact. */\n  remove(id: NodeId): void;\n  /** {@link remove} over several roots at once, as a **single** undoable step.\n   *  Ids resolve against the tree as it stands at the call, so an id that\n   *  another one would cascade away is absorbed rather than removed twice —\n   *  which is what makes it safe to pass a whole selection. Throws if any id is\n   *  not in the scene; an empty list does nothing and records no step. */\n  removeMany(ids: readonly NodeId[]): void;\n  /** Every node {@link removeMany} would take if given `ids`: each id, its\n   *  subtree, everything deriving from any of those, and those nodes' subtrees\n   *  in turn. Ids not in the scene come back unchanged.\n   *\n   *  A set, not a restore order: a dependent can be reached before the parent\n   *  it sits under, which is also in the closure. */\n  removalClosure(ids: readonly NodeId[]): readonly NodeId[];\n  update(id: NodeId, patch: { data: TData }): void;\n  setPose(id: NodeId, pose: TPose): void;\n  /** Retag `id` to `layer`. On a **container this cascades**: every descendant\n   *  is moved to the same layer, recorded as a **single** undo step.\n   *\n   *  Invariants:\n   *  - **Layer floor** — a child may not render below its parent, so retagging\n   *    to a layer *below* the node's parent throws. Retagging to the parent's\n   *    layer or any higher one is allowed; a node with no parent is\n   *    unconstrained.\n   *  - **No-op elision** — setting the layer a node already has does nothing\n   *    and pushes **no** history entry. */\n  setLayer(id: NodeId, layer: TLayer): void;\n  /** Point `id` at a different set of dependencies — retargeting an edge's end\n   *  onto another node, or switching a container between an id list and\n   *  `'children'`. Recorded as one undoable step.\n   *\n   *  Order is significant: a derivation reads its dependencies positionally,\n   *  so `[b, a]` is not `[a, b]`. Ids need not be in the scene — a declared\n   *  dependency that appears later invalidates the node when it does, the same\n   *  as one declared at `add`. Passing `undefined` drops the declaration, after\n   *  which nothing cascades the node away.\n   *\n   *  **No-op elision** — declaring what the node already declares does nothing\n   *  and pushes no history entry. */\n  setDependsOn(id: NodeId, dependsOn: readonly NodeId[] | 'children' | undefined): void;\n  /** Give container `id` a different layout — a strategy, its key in\n   *  `SceneRegistry.layout`, or `null` for none — and re-arrange its children\n   *  under it, as one undoable step. Throws for a leaf, or a key the registry\n   *  does not hold. A registered layout is recorded by its key, so a\n   *  serialized history restores it; an unregistered one lives only as long\n   *  as the session.\n   *\n   *  **No-op elision** — setting the layout a container already has does\n   *  nothing and pushes no history entry. */\n  setLayout(id: NodeId, layout: LayoutStrategy<TPose> | string | null): void;\n  /** Reparent `id` under `parent` (or to a root when `parent` is `null`) at\n   *  `index` within the new sibling list, appending when `index` is omitted.\n   *  Siblings are reindexed. Recorded as one undoable step.\n   *\n   *  Rejected (throws) when:\n   *  - `parent` exists but is a **leaf**, not a container;\n   *  - the move would form a **cycle** — `parent` is `id` itself or one of\n   *    `id`'s own descendants;\n   *  - it would drop `id` **below its new parent's layer** (child may not\n   *    render below its parent).\n   *\n   *  `move(id, null)` — detaching to a root — is always allowed regardless of\n   *  layer, since a root has no parent to render beneath. */\n  move(id: NodeId, parent: NodeId | null, index?: number): void;\n  /** Shift `id` to `index` within its **current** parent's child list. Unlike\n   *  {@link move}, the parent never changes — only sibling order. */\n  reorder(id: NodeId, index: number): void;\n  setLayerVisible(layer: TLayer, visible: boolean): void;\n  /** Lock or unlock a layer. A locked layer still paints, but its nodes are\n   *  out of reach: picking and area selection pass over them, the selection\n   *  drops them, and every node mutation on them throws. Locking is never\n   *  blocked by the lock, and neither are the other layer operations. */\n  setLayerLocked(layer: TLayer, locked: boolean): void;\n  /** Set or clear (`undefined`) a layer's parallax — see\n   *  `LayerRecord.parallax`. Undoable; an animation tweening it writes inside\n   *  {@link Scene.untracked} so no frame becomes an undo step. */\n  setLayerParallax(layer: TLayer, parallax: ParallaxOpts | undefined): void;\n  /** Whether `id` sits on a locked layer or under a container that does.\n   *  A container's lock covers its whole subtree, whatever layers the\n   *  descendants are tagged to. An id not in the scene is not locked. */\n  isLocked(id: NodeId): boolean;\n  /** Run `fn` with the lock guard lifted, for a programmatic edit that has to\n   *  reach a locked node. Undo and redo never need it. */\n  unlocked<T>(fn: () => T): T;\n  addLayer(spec: AddLayerSpec<TLayer>): void;\n  /** Drop a user layer and every node tagged to it, as one undoable step.\n   *  Removal cascades, so this also deletes nodes **on other layers** that\n   *  derive from a node on this one. */\n  removeLayer(layer: TLayer): void;\n  renameLayer(layer: TLayer, name: string): void;\n  moveLayer(layer: TLayer, index: number): void;\n\n  // Custom op seam\n  registerOp<P>(kind: string, handler: RegisteredOp<P>): void;\n  recordOp<P>(op: { kind: string; payload: P }): void;\n\n  /** Install (or clear with `null`) the active-journal accessor after scene\n   *  construction, for a journal source built with `scene.history` as a\n   *  dependency. Overrides any `getActiveJournal` set in `UseSceneOptions`. */\n  setActiveJournalAccessor(\n    fn: (() => import('@weasel-js/history').Journal | null) | null,\n  ): void;\n\n  /** Install what the scene does when nodes join a container, replacing any\n   *  handler installed before; `null` removes it. Returns a function that\n   *  removes this handler, and does nothing once another has replaced it.\n   *  See {@link SceneArrivalHandler}. */\n  setArrivalHandler(handler: SceneArrivalHandler<TPose> | null): () => void;\n\n  /** Apply a batch of ops against `adapter` as one undo entry.\n   *\n   *  The entry holds the scene writes the ops made, as a direct call records\n   *  them, and beside them any op that wrote no scene state, bound to\n   *  `adapter`. Undo restores those writes; it does not call an op's\n   *  `invert()` or the adapter again. **What an op states is not recorded**:\n   *  one applied over a document that already holds its result, as after an\n   *  `untracked` preview, records a write from that pose to itself, and undo\n   *  goes nowhere. Put the document back first.\n   *\n   *  The entry lands in the open `batch` when there is one, else on the\n   *  active journal, else on the scene's own history, where it can coalesce\n   *  under `coalesceWindowMs` with one whose ops' keys match.\n   *\n   *  Returns false when the arrival handler refused the batch: it is reverted\n   *  and unrecorded. Inside `batch` it is true; that batch may still refuse. */\n  applyBatch(ops: import('core/ops/types').Op[], label: string, adapter: unknown): boolean;\n\n  // Selection\n\n  /** The transient set of active ids — \"operate on these N as a unit\".\n   *  Shared by every view over this scene unless a view supplies its own\n   *  (see `CanvasView.selection`). Not document content: it never appears\n   *  in `toJSON`. It does ride on history entries, so undo and redo put\n   *  back the selection an edit was made under; changing it is never an\n   *  undo step of its own. Removing a node deselects it. */\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n\n  // Ephemeral presentation state\n\n  /** Per-node pose / alpha overrides the render and hit-test paths read\n   *  through. Like {@link Scene.getSelection} this is not document content:\n   *  writes are never recorded, never serialized, and do not bump\n   *  {@link Scene.getVersion}. See {@link PoseOverrides}. */\n  readonly overrides: PoseOverrides<TPose>;\n\n  // History\n  /** The scene's undo/redo engine, in the shape `@weasel-js/history` defines.\n   *  Mutating members route through\n   *  the scene's own wrappers, so an undo driven through this bumps\n   *  {@link Scene.getVersion} and notifies subscribers exactly as\n   *  {@link Scene.undo} does; `getVersion` / `subscribe` on it report the\n   *  engine's history version, not the scene's. */\n  readonly history: History;\n  undo(): boolean;\n  redo(): boolean;\n  canUndo(): boolean;\n  canRedo(): boolean;\n  batch<T>(label: string, fn: () => T): T;\n  /** The layout container `id` declares, or `null` for a leaf or a\n   *  container that declares none. */\n  layoutOf(id: NodeId): LayoutStrategy<TPose> | null;\n  /** Declare the unit scope of container `id`, or clear it with `null`. */\n  setUnits(id: NodeId, units: UnitScope | null): void;\n  /** Called with the poses each live edit's layout pass wrote, after the\n   *  edit lands — never for an undo or redo, which restore poses rather than\n   *  arrange them. What a reflow animation glides from. */\n  onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;\n  /** Run `fn` with every mutation applied but none recorded — for writes\n   *  that are not edits, such as a simulation stepping poses each frame.\n   *  Undo and redo move between recorded states and never restore an\n   *  untracked write; the next recorded change starts from whatever the\n   *  untracked writes left, so undoing it lands there. A `batch` inside\n   *  records nothing; inside a `batch`, these writes stay out of its entry.\n   *  Notifies once, reverts `fn`'s writes if it throws, and throws on\n   *  `applyBatch` and `history.apply` / `applyOps`, which exist to record. */\n  untracked<T>(fn: () => T): T;\n  /** Read-only snapshot of every history entry currently reachable from\n   *  the present state. Oldest applied first, then redoable entries in\n   *  the order they'd be re-applied. Each entry id is stable. */\n  historyEntries(): readonly { id: string; label: string }[];\n  /** Index of the \"current state\". Equals the count of applied entries;\n   *  `0` means \"nothing applied\" (initial). */\n  historyIndex(): number;\n  /** Jump to the given history index, clamped to [0, total]. Returns true\n   *  if any movement occurred. */\n  jumpToHistoryIndex(index: number): boolean;\n\n  // History persistence\n  /** Snapshot the undo/redo history in a JSON-serializable form (the\n   *  engine's `SerializedHistory`, marked with the scene's recorded form).\n   *  An entry holds the scene's own ops, whichever way the edit was made.\n   *  An op handed to `applyBatch` that wrote no scene state is held as\n   *  itself, and an entry with a nameless one is dropped. Payload\n   *  JSON-safety (e.g. typed arrays inside poses) is the caller's concern.\n   *  Do not call mid-`batch` — the open batch's ops are not yet recorded. */\n  serializeHistory(): SerializedSceneHistory;\n  /** Replace the undo/redo history from a `serializeHistory()` snapshot.\n   *  Call on a scene whose node/layer state already matches the snapshot's\n   *  head state (i.e. right after `loadState` from the paired scene\n   *  snapshot); node state is NOT mutated. Ops re-registered via\n   *  `registerOp` before this call round-trip; unknown kinds become no-op\n   *  placeholders; external ops rebuild via the global op-factory registry\n   *  and replay against the `setHistoryAdapter` accessor. Restored entries\n   *  never coalesce with new ones. Notifies once. A snapshot that is not in\n   *  the current recorded form (see `SCENE_HISTORY_FORM`) is dropped:\n   *  the history is left as it was. Do not call mid-`batch`:\n   *  the stacks are replaced underneath the open batch, whose eventual\n   *  flush would graft onto (and evict against) the restored stacks. */\n  restoreHistory(snapshot: SerializedHistory): void;\n  /** Install (or clear with `null`) the accessor for the adapter that\n   *  RESTORED external ops apply against on undo/redo: the ops handed to\n   *  `applyBatch` that wrote no scene state, such as a selection change,\n   *  rebuilt from a `restoreHistory` snapshot. Resolved lazily at each\n   *  apply, so wiring order relative to `restoreHistory` doesn't matter.\n   *  Live `applyBatch` entries are unaffected (they bind their call-site\n   *  adapter). If unset when a restored op applies, the op is a debug-warned\n   *  no-op. */\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n\n  // Serialization\n  /** Snapshot the current scene state to a JSON-serializable shape.\n   *  History (undo/redo stacks) is NOT captured. Function fields like\n   *  `ContainerNode.clipFromPose` are translated to string keys via the\n   *  scene's registry; throws if any function field has no matching key. */\n  toJSON(): SerializedScene<TData, TLayer, TPose>;\n  /** Replace this scene's entire node + layer state in place from a snapshot\n   *  produced by `toJSON()`. Unlike `sceneFromJSON`, the existing Scene\n   *  instance is preserved — holders such as `<SceneCanvas>` keep their\n   *  reference. History (undo/redo) is cleared, matching `sceneFromJSON`.\n   *  Bumps `getVersion()` and notifies subscribers exactly once. Selected\n   *  ids the snapshot does not hold leave the selection, and every pose\n   *  override is cleared.\n   *\n   *  Throws inside any other edit — `batch`, `untracked`, `applyBatch`, an\n   *  undo — which would revert to a state this replaces. Throws on an unsupported version or unknown registry/layer ids; on a\n   *  malformed snapshot the scene is left empty or partially populated (callers should treat a\n   *  `loadState` throw as fatal and reload). Snapshots from `toJSON()` are\n   *  always well-formed. */\n  loadState(json: SerializedScene<TData, TLayer, TPose>): void;\n\n  // Subscription (used by useScene; also for non-React observers)\n  subscribe(listener: () => void): () => void;\n  /** Monotonically increasing version. Snapshot for `useSyncExternalStore`. */\n  getVersion(): number;\n}\n"],"mappings":";AA4DA,IAAaA,KAAY,MAAsBC"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/core/scene/types.ts"],"sourcesContent":["import type { History, SerializedHistory } from '@weasel-js/history';\nimport type { SerializedSceneHistory } from './historyForm';\nimport type { ParallaxOpts } from '../viewport/parallax';\nimport type { UnitScope } from '@weasel-js/quantity';\nimport type { LayoutStrategy } from '../../layout/types';\nimport type { AddLayerSpec, LayerRecord, SystemLayerRecord, SystemLayerSpec, UserLayerRecord } from './layerTypes';\nimport type { LayoutFrame, LayoutMove } from './layoutTypes';\nimport type { PoseComposition } from './composeFrame';\nimport type { PoseRemoval, PoseWrite, PoseWriteOrigin, RemovedNode, ScenePoseReports } from './poseWrites';\nimport type { PoseHold, PoseOverride, PoseOverrides } from './poseOverrideTypes';\nimport type { SerializedLayer, SerializedNode, SerializedScene } from './serializedTypes';\nimport type { UseSceneOptions } from './useSceneOptions';\n\nimport type { RectPose } from '../geometry/rectPose';\nexport type { RectPose };\nexport type { AddLayerSpec, LayerRecord, SystemLayerRecord, SystemLayerSpec, UserLayerRecord };\nexport type { UseSceneOptions };\nexport type { PoseRemoval, PoseWrite, PoseWriteOrigin, RemovedNode, ScenePoseReports };\nexport type { LayoutFrame, LayoutMove, PoseHold, PoseOverride, PoseOverrides, SerializedLayer, SerializedNode, SerializedScene };\n\n/**\n * # SceneNode — the thing in the scene\n *\n * Everything the user sees on the canvas — a shape, a group, an annotation,\n * a tile — is a node. Containers and leaves are both nodes; the kit has no\n * other concept of \"scene element.\"\n *\n * Every node carries three independent slots, plus its tree position:\n *\n *   - **`data: TData`** — app-defined payload. The kit never inspects it.\n *   - **`pose: TPose`** — local transform, relative to the node's direct\n *     parent (or world, for root nodes).\n *   - **`layer: TLayer`** — a string tag associating the node with a\n *     visual `RenderLayer` at draw time. Separate from `LayerRecord` (the\n *     per-layer visible/locked metadata held by the `Scene`).\n *\n * Nodes are addressed by `NodeId` everywhere outside the scene tree. Don't\n * hold references to a `Node` object across scene updates; look up by id\n * when you need the latest.\n *\n * The kit-internal name is `Node`; the public re-export is `SceneNode`\n * (avoids collision with DOM `Node` at call sites).\n */\n\n/** Opaque branded id. Treat as opaque outside the kit. */\nimport type { NodeId } from '@weasel-js/routing';\nexport type { NodeId };\n\n/** Brand a string as a NodeId. */\nexport const asNodeId = (s: string): NodeId => s as NodeId;\n\nimport type { DerivedDep, Bivariant, DerivePathFn, DerivePoseFn, ClipFromPoseFn, CopiesFromPoseFn } from './nodeFnTypes';\nexport type { DerivedDep, Bivariant, DerivePathFn, DerivePoseFn, ClipFromPoseFn, CopiesFromPoseFn };\n\ninterface NodeBase<TData, TLayer extends string, TPose> {\n  id: NodeId;\n  layer: TLayer;\n  pose: TPose;\n  data: TData;\n  parent: NodeId | null;\n  /** Nodes whose poses this node's geometry is computed from. Fixed at add\n   *  time. Absent or empty means the node's geometry is authored, which is the\n   *  normal case.\n   *\n   *  `'children'` means \"my own children, in child order\" — a container that\n   *  hugs its contents, which a fixed id list cannot express because\n   *  reparenting would have to maintain it. The two forms differ in lifetime\n   *  as well as in membership: deleting a node deletes everything that names\n   *  it in `dependsOn`, but a container outlives the children it derives\n   *  from — an emptied group is still a group. */\n  dependsOn?: readonly NodeId[] | 'children';\n  /** Whether the hit-test walk can return this node. Default `true`; `false`\n   *  makes it transparent to picking, so a click on it lands on whatever is\n   *  behind — normally its own container.\n   *\n   *  For content a container owns rather than content the user selects on its\n   *  own: the label inside a box, a body's rows. It does not hide the node\n   *  from anything else — it still paints, still clips, and a consumer can\n   *  still select it by id. */\n  pickable?: boolean;\n  /** Not drawn, with its whole subtree: picking, area selection, select-all,\n   *  snapping and the selection pass over it, and an SVG export writes it with\n   *  `display=\"none\"`. Absent means shown; `Scene.isHidden` folds in its\n   *  ancestors' flags and its layer's visibility. */\n  hidden?: boolean;\n  /** Out of reach, with its whole subtree: still drawn, but picking and area\n   *  selection pass over it, the selection drops it, and every edit to it\n   *  throws, as on a locked layer. Absent means unlocked; `Scene.isLocked`\n   *  folds in its ancestors' and its layer's. */\n  locked?: boolean;\n  /** Computes this node's path from its dependencies, in `dependsOn` order —\n   *  each one the node and the pose it is painted at.\n   *  A dependency that has been removed arrives as `undefined`.\n   *  Returning `null` means \"nothing to draw right now\". Re-evaluated when a\n   *  dependency's world pose changes, never authored. */\n  derivePath?: DerivePathFn<TPose, TData, TLayer>;\n  /** Computes this node's pose from its dependencies' poses, the same way\n   *  `derivePath` computes its path — same `dependsOn` list, same\n   *  registry-keyed serialization.\n   *\n   *  Where a derived path is resolved at paint time and reaches only the\n   *  painter, a derived pose is what the node *is* at: it feeds bounds,\n   *  hit-testing, selection chrome, snapping and layout, and every reader\n   *  gets it through `effectivePose`. A pose override still wins over it.\n   *\n   *  Returning `null` means \"I have nothing to derive from right now\", and\n   *  the node falls back to its authored `pose`. `setPose` on a derived node\n   *  still writes that authored pose; it is simply not what anything reads. */\n  derivePose?: DerivePoseFn<TPose, TData, TLayer>;\n}\n\n/** A node with no children — a shape, a label, an image. */\nexport interface LeafNode<TData, TLayer extends string, TPose = RectPose>\n  extends NodeBase<TData, TLayer, TPose> {\n  kind: 'leaf';\n}\n\n/** A node with an ordered list of children. This is the real group: what\n *  Cmd+G creates, what SVG `<g>` round-trips to. A container has its own pose,\n *  which its children's poses are relative to, and may optionally clip them. */\nexport interface ContainerNode<TData, TLayer extends string, TPose = RectPose>\n  extends NodeBase<TData, TLayer, TPose> {\n  kind: 'container';\n  children: NodeId[];\n  /** Optional clip-path source. Re-evaluated each render. Returning `null`\n   *  means \"no clip for this container right now\"; an empty / zero-area path\n   *  means \"clip everything out\" (children render nowhere). */\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  /** Draws the whole subtree again under each affine it returns, on top of\n   *  the original, which still draws once as authored. The copies are paint,\n   *  not nodes: nothing stores them, so they follow every edit to the\n   *  children, and a pick that lands on one answers with the child it copies.\n   *  A copy is a copy of the clipped content — the clip travels with it.\n   *  Re-evaluated each render; `null` or `[]` draws no copies. */\n  copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;\n  /** How this container arranges its children. Whenever the container's\n   *  child set or order changes, or its bounds change size, the scene hands\n   *  the change to the strategy — `depart` for children that left it,\n   *  `arrive` for children that joined it, `childPoses` otherwise — and records the poses it writes in the same\n   *  undo entry as the change. A drag reads it too: it is the layout `move`\n   *  reflows and drops against. */\n  layout?: LayoutStrategy<TPose>;\n  /** The unit system this container's contents are written in, and what one\n   *  of its base units is worth in the enclosing scope's. It covers the\n   *  children, not the container; `sceneUnitScopes` reads the chain. */\n  units?: UnitScope;\n}\n\n/** A node in the scene tree: either a leaf or a container. Re-exported\n *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */\nexport type Node<TData, TLayer extends string, TPose = RectPose> =\n  | LeafNode<TData, TLayer, TPose>\n  | ContainerNode<TData, TLayer, TPose>;\n\n/** What `Scene.add` needs to mint a node. Everything except the id is\n *  required; the id is generated unless one is supplied. */\nexport interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {\n  kind: 'leaf' | 'container';\n  layer: TLayer;\n  pose: TPose;\n  data: TData;\n  parent?: NodeId | null;\n  index?: number;\n  /** Explicit id wins over the Scene's `generateId` and the kit default. */\n  id?: NodeId;\n  /** Mirrors `SceneNode.pickable`. Omit for the default, which is pickable. */\n  pickable?: boolean;\n  /** Mirrors `SceneNode.hidden`. */\n  hidden?: boolean;\n  /** Mirrors `SceneNode.locked`. */\n  locked?: boolean;\n  /** Only meaningful when `kind === 'container'`. Attach a clip-path function\n   *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */\n  clipFromPose?: ClipFromPoseFn<TPose>;\n  /** Mirrors `ContainerNode.copiesFromPose`; ignored for leaves. */\n  copiesFromPose?: CopiesFromPoseFn<TPose, TData, TLayer>;\n  /** Mirrors `SceneNode.dependsOn`. */\n  dependsOn?: readonly NodeId[] | 'children';\n  /** Mirrors `SceneNode.derivePath`. Taken as a live function; its registry key is\n   *  looked up from it, never passed in. */\n  derivePath?: DerivePathFn<TPose, TData, TLayer>;\n  /** Mirrors `SceneNode.derivePose`, on the same terms as `derivePath`. */\n  derivePose?: DerivePoseFn<TPose, TData, TLayer>;\n  /** Mirrors `ContainerNode.layout`; ignored for leaves. */\n  layout?: LayoutStrategy<TPose>;\n  /** Mirrors `ContainerNode.units`; ignored for leaves. */\n  units?: UnitScope;\n}\n\n/** A custom scene mutation registered with `Scene.registerOp`: how to apply\n *  it and how to undo it. The pair is what makes it participate in history. */\nexport interface RegisteredOp<P> {\n  apply: (payload: P) => void;\n  revert: (payload: P) => void;\n  /** Opts this kind into coalescing under `UseSceneOptions.coalesceWindowMs`:\n   *  two entries of this kind that return the same key inside the window\n   *  merge, and undoing the merged entry calls `revert` with the first\n   *  payload only. Declare it only when `revert` restores an absolute state\n   *  (a stored \"from\" value), never for a relative payload such as a delta.\n   *  Omitted, or returning `undefined`, the op is always its own entry. */\n  coalesceKey?: (payload: P) => string | undefined;\n}\n\n/** Per-scene registry mapping string keys to live function references.\n *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.\n *  Each function-field type has its own keyed map. */\nexport interface SceneRegistry<TPose, TData = unknown, TLayer extends string = string> {\n  /** Maps registry keys to `clipFromPose` factory functions for container nodes. */\n  clipFromPose?: Readonly<Record<string, ClipFromPoseFn<TPose>>>;\n  /** Maps registry keys to `copiesFromPose` functions for container nodes. */\n  copiesFromPose?: Readonly<Record<string, CopiesFromPoseFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */\n  derivePath?: Readonly<Record<string, DerivePathFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */\n  derivePose?: Readonly<Record<string, DerivePoseFn<TPose, TData, TLayer>>>;\n  /** Maps registry keys to container layout strategies. */\n  layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;\n  // A new function field is a row in `NODE_FN_FIELDS` (core/scene/nodeFnFields.ts)\n  // plus its entry here; the field name is the registry key by construction.\n}\n\n/**\n * Decides what one edit's changes to containers do to their children.\n * `arrivals` maps each container to the ids that joined it — by an `add`\n * under it or a `move` into it, whatever op or call made them — in the order\n * they arrived. `changed` names every container whose child set or order\n * changed, or whose pose changed size, arrivals included. Both are read once\n * the edit's other mutations have landed.\n *\n * Return the poses to write, in each node's stored frame; they become part of\n * the same edit, and so of the same undo step. An empty map writes nothing.\n * Return `null` to refuse: the whole edit is reverted (see\n * `SceneArrivalRefused`).\n *\n * Runs only for live edits. Undo, redo and a restored history replay the\n * arrangement that was decided the first time. With none installed, a scene\n * holding declared layouts (`ContainerNode.layout`) runs its own.\n */\nexport type SceneArrivalHandler<TPose> = (\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  /** The nodes that left each container in the edit, by the container they\n   *  left — removed, or moved out. */\n  departures: ReadonlyMap<NodeId, readonly NodeId[]>,\n) => ReadonlyMap<NodeId, TPose> | null;\n\n/**\n * The kit-owned scene tree: nodes, layers, and the undo history over both.\n *\n * A scene is logical, not visual — it says what exists and where, and nothing\n * about how it is painted. Every mutating method is undoable, and reads are\n * snapshots rather than live views. Nodes are addressed by `NodeId`; hold ids\n * across mutations, not node objects.\n *\n * Three type parameters keep it domain-agnostic: `TData` is the app's payload,\n * which the kit never inspects; `TPose` is the transform shape, `RectPose` by\n * default; `TLayer` is the union of layer names.\n */\nexport interface Scene<TData, TLayer extends string, TPose = RectPose>\n  extends ScenePoseReports<TPose, Node<TData, TLayer, TPose>> {\n  // Reads\n  readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  readonly roots: readonly NodeId[];\n  readonly layers: readonly LayerRecord<TLayer>[];\n  /** The registry this scene resolves node functions against — the consumer's\n   *  entries over the kit's. */\n  readonly registry: SceneRegistry<TPose, TData, TLayer>;\n  /** See {@link UseSceneOptions.composition}. */\n  readonly composition: PoseComposition<TPose>;\n  get(id: NodeId): Node<TData, TLayer, TPose> | undefined;\n  /** A token for the node `id` names right now, for telling one node from a\n   *  later one that reuses its id. It holds for as long as the node stays in\n   *  the scene, whatever edits it takes, and is different every time the id\n   *  enters the scene — by `add`, by an undo or redo that brings it back, or\n   *  by `loadState`. `undefined` when `id` is not in the scene. Compare tokens\n   *  for equality only; their order means nothing. */\n  incarnation(id: NodeId): number | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n  ancestorsOf(id: NodeId): readonly NodeId[];\n  renderOrder(): Iterable<NodeId>;\n  /** The same layer-major sequence as {@link Scene.renderOrder}, as the nodes\n   *  themselves. Prefer this wherever the ids are only going to be resolved\n   *  back to nodes. Cached until a structural edit, so repeat calls hand back\n   *  the same array — a snapshot, not a live view, and not yours to mutate. */\n  renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];\n  /** The nodes on one layer, in render order. Cached alongside\n   *  {@link Scene.renderOrderNodes} until a structural edit. A snapshot, not\n   *  a live view, and not yours to mutate. An unknown layer id yields an\n   *  empty array. */\n  nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];\n\n  /** A fresh id from this scene's `generateId`, or the kit default: the id\n   *  `add` would give a spec with none. For code that has to name a node\n   *  before it exists, such as one building an insert op. */\n  mintId(): NodeId;\n\n  // Mutations (all auto-undoable)\n  add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;\n  /** Delete `id`, its **entire subtree**, and **everything that derives from**\n   *  any of those nodes — a node listing one of them in `dependsOn` goes too,\n   *  along with its own subtree, transitively. A dependent can live anywhere in\n   *  the tree, so this deletes nodes the caller never named and may unlink\n   *  several disjoint subtrees at once. Recorded as one undoable step; `undo()`\n   *  restores every one of them where it was, child order intact. */\n  remove(id: NodeId): void;\n  /** {@link remove} over several roots at once, as a **single** undoable step.\n   *  Ids resolve against the tree as it stands at the call, so an id that\n   *  another one would cascade away is absorbed rather than removed twice —\n   *  which is what makes it safe to pass a whole selection. Throws if any id is\n   *  not in the scene; an empty list does nothing and records no step. */\n  removeMany(ids: readonly NodeId[]): void;\n  /** Every node {@link removeMany} would take if given `ids`: each id, its\n   *  subtree, everything deriving from any of those, and those nodes' subtrees\n   *  in turn. Ids not in the scene come back unchanged.\n   *\n   *  A set, not a restore order: a dependent can be reached before the parent\n   *  it sits under, which is also in the closure. */\n  removalClosure(ids: readonly NodeId[]): readonly NodeId[];\n  update(id: NodeId, patch: { data: TData }): void;\n  setPose(id: NodeId, pose: TPose): void;\n  /** Retag `id` to `layer`. On a **container this cascades**: every descendant\n   *  is moved to the same layer, recorded as a **single** undo step.\n   *\n   *  Invariants:\n   *  - **Layer floor** — a child may not render below its parent, so retagging\n   *    to a layer *below* the node's parent throws. Retagging to the parent's\n   *    layer or any higher one is allowed; a node with no parent is\n   *    unconstrained.\n   *  - **No-op elision** — setting the layer a node already has does nothing\n   *    and pushes **no** history entry. */\n  setLayer(id: NodeId, layer: TLayer): void;\n  /** Point `id` at a different set of dependencies — retargeting an edge's end\n   *  onto another node, or switching a container between an id list and\n   *  `'children'`. Recorded as one undoable step.\n   *\n   *  Order is significant: a derivation reads its dependencies positionally,\n   *  so `[b, a]` is not `[a, b]`. Ids need not be in the scene — a declared\n   *  dependency that appears later invalidates the node when it does, the same\n   *  as one declared at `add`. Passing `undefined` drops the declaration, after\n   *  which nothing cascades the node away.\n   *\n   *  **No-op elision** — declaring what the node already declares does nothing\n   *  and pushes no history entry. */\n  setDependsOn(id: NodeId, dependsOn: readonly NodeId[] | 'children' | undefined): void;\n  /** Give container `id` a different layout — a strategy, its key in\n   *  `SceneRegistry.layout`, or `null` for none — and re-arrange its children\n   *  under it, as one undoable step. Throws for a leaf, or a key the registry\n   *  does not hold. A registered layout is recorded by its key, so a\n   *  serialized history restores it; an unregistered one lives only as long\n   *  as the session.\n   *\n   *  **No-op elision** — setting the layout a container already has does\n   *  nothing and pushes no history entry. */\n  setLayout(id: NodeId, layout: LayoutStrategy<TPose> | string | null): void;\n  /** Reparent `id` under `parent` (or to a root when `parent` is `null`) at\n   *  `index` within the new sibling list, appending when `index` is omitted.\n   *  Siblings are reindexed. Recorded as one undoable step.\n   *\n   *  Rejected (throws) when:\n   *  - `parent` exists but is a **leaf**, not a container;\n   *  - the move would form a **cycle** — `parent` is `id` itself or one of\n   *    `id`'s own descendants;\n   *  - it would drop `id` **below its new parent's layer** (child may not\n   *    render below its parent).\n   *\n   *  `move(id, null)` — detaching to a root — is always allowed regardless of\n   *  layer, since a root has no parent to render beneath. */\n  move(id: NodeId, parent: NodeId | null, index?: number): void;\n  /** Shift `id` to `index` within its **current** parent's child list. Unlike\n   *  {@link move}, the parent never changes — only sibling order. */\n  reorder(id: NodeId, index: number): void;\n  /** Show or hide a layer. Hiding drops its nodes from the selection. */\n  setLayerVisible(layer: TLayer, visible: boolean): void;\n  /** Lock or unlock a layer. A locked layer still paints, but its nodes are\n   *  out of reach: picking and area selection pass over them, the selection\n   *  drops them, and every node mutation on them throws. Locking is never\n   *  blocked by the lock, and neither are the other layer operations. */\n  setLayerLocked(layer: TLayer, locked: boolean): void;\n  /** Set or clear (`undefined`) a layer's parallax — see\n   *  `LayerRecord.parallax`. Undoable; an animation tweening it writes inside\n   *  {@link Scene.untracked} so no frame becomes an undo step. */\n  setLayerParallax(layer: TLayer, parallax: ParallaxOpts | undefined): void;\n  /** Whether `id` is locked: it or an ancestor carries `locked`, or sits on a\n   *  locked layer. A lock covers its whole subtree, whatever layers the\n   *  descendants are tagged to. An id not in the scene is not locked. */\n  isLocked(id: NodeId): boolean;\n  /** Whether `id` is not drawn: its own layer is hidden, or it or an ancestor\n   *  carries `hidden`. A hidden layer hides only the nodes tagged to it. An\n   *  id not in the scene is not hidden. */\n  isHidden(id: NodeId): boolean;\n  /** Hide or show node `id` and its subtree — see `SceneNode.hidden`. One\n   *  undo step; hiding drops the subtree from the selection. Never blocked by\n   *  a lock, and setting what the node already has records nothing. */\n  setHidden(id: NodeId, hidden: boolean): void;\n  /** Lock or unlock node `id` and its subtree — see `SceneNode.locked`. One\n   *  undo step; locking drops the subtree from the selection. Never blocked\n   *  by a lock, and setting what the node already has records nothing. */\n  setLocked(id: NodeId, locked: boolean): void;\n  /** Run `fn` with the lock guard lifted, for a programmatic edit that has to\n   *  reach a locked node. Undo and redo never need it. */\n  unlocked<T>(fn: () => T): T;\n  addLayer(spec: AddLayerSpec<TLayer>): void;\n  /** Drop a user layer and every node tagged to it, as one undoable step.\n   *  Removal cascades, so this also deletes nodes **on other layers** that\n   *  derive from a node on this one. */\n  removeLayer(layer: TLayer): void;\n  renameLayer(layer: TLayer, name: string): void;\n  moveLayer(layer: TLayer, index: number): void;\n\n  // Custom op seam\n  registerOp<P>(kind: string, handler: RegisteredOp<P>): void;\n  recordOp<P>(op: { kind: string; payload: P }): void;\n\n  /** Install (or clear with `null`) the active-journal accessor after scene\n   *  construction, for a journal source built with `scene.history` as a\n   *  dependency. Overrides any `getActiveJournal` set in `UseSceneOptions`. */\n  setActiveJournalAccessor(\n    fn: (() => import('@weasel-js/history').Journal | null) | null,\n  ): void;\n\n  /** Install what the scene does when nodes join a container, replacing any\n   *  handler installed before; `null` removes it. Returns a function that\n   *  removes this handler, and does nothing once another has replaced it.\n   *  See {@link SceneArrivalHandler}. */\n  setArrivalHandler(handler: SceneArrivalHandler<TPose> | null): () => void;\n\n  /** Apply a batch of ops against `adapter` as one undo entry.\n   *\n   *  The entry holds the scene writes the ops made, as a direct call records\n   *  them, and beside them any op that wrote no scene state, bound to\n   *  `adapter`. Undo restores those writes; it does not call an op's\n   *  `invert()` or the adapter again. **What an op states is not recorded**:\n   *  one applied over a document that already holds its result, as after an\n   *  `untracked` preview, records a write from that pose to itself, and undo\n   *  goes nowhere. Put the document back first.\n   *\n   *  The entry lands in the open `batch` when there is one, else on the\n   *  active journal, else on the scene's own history, where it can coalesce\n   *  under `coalesceWindowMs` with one whose ops' keys match.\n   *\n   *  Returns false when the arrival handler refused the batch: it is reverted\n   *  and unrecorded. Inside `batch` it is true; that batch may still refuse. */\n  applyBatch(ops: import('core/ops/types').Op[], label: string, adapter: unknown): boolean;\n\n  // Selection\n\n  /** The transient set of active ids — \"operate on these N as a unit\".\n   *  Shared by every view over this scene unless a view supplies its own\n   *  (see `CanvasView.selection`). Not document content: it never appears\n   *  in `toJSON`. It does ride on history entries, so undo and redo put\n   *  back the selection an edit was made under; changing it is never an\n   *  undo step of its own. Removing a node deselects it. */\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n\n  // Ephemeral presentation state\n\n  /** Per-node pose / alpha overrides the render and hit-test paths read\n   *  through. Like {@link Scene.getSelection} this is not document content:\n   *  writes are never recorded, never serialized, and do not bump\n   *  {@link Scene.getVersion}. See {@link PoseOverrides}. */\n  readonly overrides: PoseOverrides<TPose>;\n\n  // History\n  /** The scene's undo/redo engine, in the shape `@weasel-js/history` defines.\n   *  Mutating members route through\n   *  the scene's own wrappers, so an undo driven through this bumps\n   *  {@link Scene.getVersion} and notifies subscribers exactly as\n   *  {@link Scene.undo} does; `getVersion` / `subscribe` on it report the\n   *  engine's history version, not the scene's. */\n  readonly history: History;\n  undo(): boolean;\n  redo(): boolean;\n  canUndo(): boolean;\n  canRedo(): boolean;\n  batch<T>(label: string, fn: () => T): T;\n  /** The layout container `id` declares, or `null` for a leaf or a\n   *  container that declares none. */\n  layoutOf(id: NodeId): LayoutStrategy<TPose> | null;\n  /** Declare the unit scope of container `id`, or clear it with `null`. */\n  setUnits(id: NodeId, units: UnitScope | null): void;\n  /** Run `fn` with every mutation applied but none recorded — for writes\n   *  that are not edits, such as a simulation stepping poses each frame.\n   *  Undo and redo move between recorded states and never restore an\n   *  untracked write; the next recorded change starts from whatever the\n   *  untracked writes left, so undoing it lands there. A `batch` inside\n   *  records nothing; inside a `batch`, these writes stay out of its entry.\n   *  Notifies once, reverts `fn`'s writes if it throws, and throws on\n   *  `applyBatch` and `history.apply` / `applyOps`, which exist to record. */\n  untracked<T>(fn: () => T): T;\n  /** Read-only snapshot of every history entry currently reachable from\n   *  the present state. Oldest applied first, then redoable entries in\n   *  the order they'd be re-applied. Each entry id is stable. */\n  historyEntries(): readonly { id: string; label: string }[];\n  /** Index of the \"current state\". Equals the count of applied entries;\n   *  `0` means \"nothing applied\" (initial). */\n  historyIndex(): number;\n  /** Jump to the given history index, clamped to [0, total]. Returns true\n   *  if any movement occurred. */\n  jumpToHistoryIndex(index: number): boolean;\n\n  // History persistence\n  /** Snapshot the undo/redo history in a JSON-serializable form (the\n   *  engine's `SerializedHistory`, marked with the scene's recorded form).\n   *  An entry holds the scene's own ops, whichever way the edit was made.\n   *  An op handed to `applyBatch` that wrote no scene state is held as\n   *  itself, and an entry with a nameless one is dropped. Payload\n   *  JSON-safety (e.g. typed arrays inside poses) is the caller's concern.\n   *  Do not call mid-`batch` — the open batch's ops are not yet recorded. */\n  serializeHistory(): SerializedSceneHistory;\n  /** Replace the undo/redo history from a `serializeHistory()` snapshot.\n   *  Call on a scene whose node/layer state already matches the snapshot's\n   *  head state (i.e. right after `loadState` from the paired scene\n   *  snapshot); node state is NOT mutated. Ops re-registered via\n   *  `registerOp` before this call round-trip; unknown kinds become no-op\n   *  placeholders; external ops rebuild via the global op-factory registry\n   *  and replay against the `setHistoryAdapter` accessor. Restored entries\n   *  never coalesce with new ones. Notifies once. A snapshot that is not in\n   *  the current recorded form (see `SCENE_HISTORY_FORM`) is dropped:\n   *  the history is left as it was. Do not call mid-`batch`:\n   *  the stacks are replaced underneath the open batch, whose eventual\n   *  flush would graft onto (and evict against) the restored stacks. */\n  restoreHistory(snapshot: SerializedHistory): void;\n  /** Install (or clear with `null`) the accessor for the adapter that\n   *  RESTORED external ops apply against on undo/redo: the ops handed to\n   *  `applyBatch` that wrote no scene state, such as a selection change,\n   *  rebuilt from a `restoreHistory` snapshot. Resolved lazily at each\n   *  apply, so wiring order relative to `restoreHistory` doesn't matter.\n   *  Live `applyBatch` entries are unaffected (they bind their call-site\n   *  adapter). If unset when a restored op applies, the op is a debug-warned\n   *  no-op. */\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n\n  // Serialization\n  /** Snapshot the current scene state to a JSON-serializable shape.\n   *  History (undo/redo stacks) is NOT captured. Function fields like\n   *  `ContainerNode.clipFromPose` are translated to string keys via the\n   *  scene's registry; throws if any function field has no matching key. */\n  toJSON(): SerializedScene<TData, TLayer, TPose>;\n  /** Replace this scene's entire node + layer state in place from a snapshot\n   *  produced by `toJSON()`. Unlike `sceneFromJSON`, the existing Scene\n   *  instance is preserved — holders such as `<SceneCanvas>` keep their\n   *  reference. History (undo/redo) is cleared, matching `sceneFromJSON`.\n   *  Bumps `getVersion()` and notifies subscribers exactly once. Selected\n   *  ids the snapshot does not hold leave the selection, and every pose\n   *  override is cleared.\n   *\n   *  Throws inside any other edit — `batch`, `untracked`, `applyBatch`, an\n   *  undo — which would revert to a state this replaces. Throws on an unsupported version or unknown registry/layer ids; on a\n   *  malformed snapshot the scene is left empty or partially populated (callers should treat a\n   *  `loadState` throw as fatal and reload). Snapshots from `toJSON()` are\n   *  always well-formed. */\n  loadState(json: SerializedScene<TData, TLayer, TPose>): void;\n\n  // Subscription (used by useScene; also for non-React observers)\n  subscribe(listener: () => void): () => void;\n  /** Monotonically increasing version. Snapshot for `useSyncExternalStore`. */\n  getVersion(): number;\n}\n"],"mappings":";;AAiDA,IAAa,YAAY,MAAsB"}

package/dist/core/scene/unionOfChildren.js

@@ -1,15 +1,25 @@
-import { unionAABB as e } from "../geometry/unionBounds.js";
-import { poseDescriptorForNode as t, visualBoundsViaDescriptor as n } from "../geometry/poseDescriptor.js";
+import { unionAABB } from "../geometry/unionBounds.js";
+import { poseDescriptorForNode, visualBoundsViaDescriptor } from "../geometry/poseDescriptor.js";
+
 //#region src/core/scene/unionOfChildren.ts
-function r(r) {
-	return (i, a) => {
-		let o = [];
-		for (let e of a) e !== void 0 && o.push(n(e.pose, t(r, e)));
-		let s = e(o);
-		return s === null ? null : t(r, i).fromBounds(s, i.pose);
+/**
+* A container's pose as the envelope of what it holds, read through
+* `descriptor` — a rotated member contributes the extent of its ink. Register
+* the result under `UNION_OF_CHILDREN` in `createScene`'s `registry` to teach
+* a scene how to size its groups around a pose shape the kit cannot read.
+*
+* Returns `null` for an emptied container, which falls back to its authored
+* pose rather than collapsing to a zero box at the origin.
+*/
+function unionOfChildrenVia(descriptor) {
+	return (node, deps) => {
+		const boxes = [];
+		for (const d of deps) if (d !== void 0) boxes.push(visualBoundsViaDescriptor(d.pose, poseDescriptorForNode(descriptor, d)));
+		const u = unionAABB(boxes);
+		return u === null ? null : poseDescriptorForNode(descriptor, node).fromBounds(u, node.pose);
 	};
 }
-//#endregion
-export { r as unionOfChildrenVia };
 
+//#endregion
+export { unionOfChildrenVia };
 //# sourceMappingURL=unionOfChildren.js.map

package/dist/core/scene/unionOfChildren.js.map

@@ -1 +1 @@
-{"version":3,"file":"unionOfChildren.js","names":["unionOfChildrenVia","boxes","d","deps","visualBoundsViaDescriptor","poseDescriptorForNode","descriptor","u","unionAABB","node"],"sources":["../../../src/core/scene/unionOfChildren.ts"],"sourcesContent":["import { unionAABB } from 'core/geometry/unionBounds';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'core/geometry/poseDescriptor';\nimport type { DerivePoseFn } from 'core/scene/types';\n\n/**\n * A container's pose as the envelope of what it holds, read through\n * `descriptor` — a rotated member contributes the extent of its ink. Register\n * the result under `UNION_OF_CHILDREN` in `createScene`'s `registry` to teach\n * a scene how to size its groups around a pose shape the kit cannot read.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose rather than collapsing to a zero box at the origin.\n */\nexport function unionOfChildrenVia<TPose>(\n  descriptor: PoseDescriptor<TPose>,\n): DerivePoseFn<TPose> {\n  return (node, deps) => {\n    const boxes = [];\n    for (const d of deps) {\n      if (d !== undefined) {\n        boxes.push(visualBoundsViaDescriptor(d.pose, poseDescriptorForNode(descriptor, d)));\n      }\n    }\n    const u = unionAABB(boxes);\n    return u === null\n      ? null\n      : poseDescriptorForNode(descriptor, node).fromBounds(u, node.pose);\n  };\n}\n"],"mappings":";;;AAiBA,SAAgBA,EACd,GACqB;CACrB,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAQ,CAAC;EACf,KAAK,IAAMC,KAAKC,GACd,AAAID,MAAM,KAAA,KACRD,EAAM,KAAKG,EAA0BF,EAAE,MAAMG,EAAsBC,GAAYJ,CAAC,CAAC,CAAC;EAGtF,IAAMK,IAAIC,EAAUP,CAAK;EACzB,OAAOM,MAAM,OACT,OACAF,EAAsBC,GAAYG,CAAI,CAAC,CAAC,WAAWF,GAAGE,EAAK,IAAI;CACrE;AACF"}
+{"version":3,"file":"unionOfChildren.js","names":[],"sources":["../../../src/core/scene/unionOfChildren.ts"],"sourcesContent":["import { unionAABB } from 'core/geometry/unionBounds';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'core/geometry/poseDescriptor';\nimport type { DerivePoseFn } from 'core/scene/types';\n\n/**\n * A container's pose as the envelope of what it holds, read through\n * `descriptor` — a rotated member contributes the extent of its ink. Register\n * the result under `UNION_OF_CHILDREN` in `createScene`'s `registry` to teach\n * a scene how to size its groups around a pose shape the kit cannot read.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose rather than collapsing to a zero box at the origin.\n */\nexport function unionOfChildrenVia<TPose>(\n  descriptor: PoseDescriptor<TPose>,\n): DerivePoseFn<TPose> {\n  return (node, deps) => {\n    const boxes = [];\n    for (const d of deps) {\n      if (d !== undefined) {\n        boxes.push(visualBoundsViaDescriptor(d.pose, poseDescriptorForNode(descriptor, d)));\n      }\n    }\n    const u = unionAABB(boxes);\n    return u === null\n      ? null\n      : poseDescriptorForNode(descriptor, node).fromBounds(u, node.pose);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,mBACd,YACqB;CACrB,QAAQ,MAAM,SAAS;EACrB,MAAM,QAAQ,CAAC;EACf,KAAK,MAAM,KAAK,MACd,IAAI,MAAM,QACR,MAAM,KAAK,0BAA0B,EAAE,MAAM,sBAAsB,YAAY,CAAC,CAAC,CAAC;EAGtF,MAAM,IAAI,UAAU,KAAK;EACzB,OAAO,MAAM,OACT,OACA,sBAAsB,YAAY,IAAI,CAAC,CAAC,WAAW,GAAG,KAAK,IAAI;CACrE;AACF"}

package/dist/core/scene/unitScopes.js

@@ -1,13 +1,20 @@
-import { scopesOf as e } from "@weasel-js/quantity";
+import { scopesOf } from "@weasel-js/quantity";
+
 //#region src/core/scene/unitScopes.ts
-function t(t, n, r, i = {}) {
-	return e(n, r, {
-		parentOf: (e) => t.get(e)?.parent,
-		scopeOf: (e) => t.get(e)?.units,
-		...i.inclusive ? { inclusive: !0 } : {}
+/**
+* The unit scopes enclosing node `id`, outermost first, under the scene's own
+* `root`: what `resolveScoped` and `formatScoped` take for a value that
+* positions or sizes it. A container's own scope covers its children, so it
+* is counted only under `inclusive`, for a value written inside it.
+*/
+function sceneUnitScopes(scene, id, root, opts = {}) {
+	return scopesOf(id, root, {
+		parentOf: (at) => scene.get(at)?.parent,
+		scopeOf: (at) => scene.get(at)?.units,
+		...opts.inclusive ? { inclusive: true } : {}
 	});
 }
-//#endregion
-export { t as sceneUnitScopes };
 
+//#endregion
+export { sceneUnitScopes };
 //# sourceMappingURL=unitScopes.js.map

package/dist/core/scene/unitScopes.js.map

@@ -1 +1 @@
-{"version":3,"file":"unitScopes.js","names":["sceneUnitScopes","scopesOf","id","root","scene","at","opts"],"sources":["../../../src/core/scene/unitScopes.ts"],"sourcesContent":["import { scopesOf, type UnitScope } from '@weasel-js/quantity';\nimport type { NodeId } from './types';\n\n/** What reading scopes needs of a scene. A `Scene` satisfies it. */\nexport interface ScopedScene {\n  get(id: NodeId): { kind: string; parent: NodeId | null; units?: UnitScope } | undefined;\n}\n\n/**\n * The unit scopes enclosing node `id`, outermost first, under the scene's own\n * `root`: what `resolveScoped` and `formatScoped` take for a value that\n * positions or sizes it. A container's own scope covers its children, so it\n * is counted only under `inclusive`, for a value written inside it.\n */\nexport function sceneUnitScopes(\n  scene: ScopedScene,\n  id: NodeId,\n  root: UnitScope,\n  opts: { inclusive?: boolean } = {},\n): UnitScope[] {\n  return scopesOf(id, root, {\n    parentOf: (at) => scene.get(at)?.parent,\n    scopeOf: (at) => scene.get(at)?.units,\n    ...(opts.inclusive ? { inclusive: true } : {}),\n  });\n}\n"],"mappings":";;AAcA,SAAgBA,EACd,GACA,GACA,GACA,IAAgC,CAAC,GACpB;CACb,OAAOC,EAASC,GAAIC,GAAM;EACxB,WAAW,MAAOC,EAAM,IAAIC,CAAE,CAAC,EAAE;EACjC,UAAU,MAAOD,EAAM,IAAIC,CAAE,CAAC,EAAE;EAChC,GAAIC,EAAK,YAAY,EAAE,WAAW,GAAK,IAAI,CAAC;CAC9C,CAAC;AACH"}
+{"version":3,"file":"unitScopes.js","names":[],"sources":["../../../src/core/scene/unitScopes.ts"],"sourcesContent":["import { scopesOf, type UnitScope } from '@weasel-js/quantity';\nimport type { NodeId } from './types';\n\n/** What reading scopes needs of a scene. A `Scene` satisfies it. */\nexport interface ScopedScene {\n  get(id: NodeId): { kind: string; parent: NodeId | null; units?: UnitScope } | undefined;\n}\n\n/**\n * The unit scopes enclosing node `id`, outermost first, under the scene's own\n * `root`: what `resolveScoped` and `formatScoped` take for a value that\n * positions or sizes it. A container's own scope covers its children, so it\n * is counted only under `inclusive`, for a value written inside it.\n */\nexport function sceneUnitScopes(\n  scene: ScopedScene,\n  id: NodeId,\n  root: UnitScope,\n  opts: { inclusive?: boolean } = {},\n): UnitScope[] {\n  return scopesOf(id, root, {\n    parentOf: (at) => scene.get(at)?.parent,\n    scopeOf: (at) => scene.get(at)?.units,\n    ...(opts.inclusive ? { inclusive: true } : {}),\n  });\n}\n"],"mappings":";;;;;;;;;AAcA,SAAgB,gBACd,OACA,IACA,MACA,OAAgC,CAAC,GACpB;CACb,OAAO,SAAS,IAAI,MAAM;EACxB,WAAW,OAAO,MAAM,IAAI,EAAE,CAAC,EAAE;EACjC,UAAU,OAAO,MAAM,IAAI,EAAE,CAAC,EAAE;EAChC,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,IAAI,CAAC;CAC9C,CAAC;AACH"}

package/dist/core/scene/useScene.js

@@ -1,32 +1,40 @@
-import { asNodeId as e } from "./types.js";
-import { createScene as t } from "./scene.js";
-import { useRef as n, useSyncExternalStore as r } from "react";
+import { asNodeId } from "./types.js";
+import { createScene } from "./scene.js";
+import { useRef, useSyncExternalStore } from "react";
+
 //#region src/core/scene/useScene.ts
-var i = () => () => {}, a = "default";
-function o(e) {
-	return !!e && typeof e == "object" && "items" in e && !("systemLayers" in e);
+/** A subscribe function that never notifies. `useSyncExternalStore` still runs
+*  (hooks are unconditional) but the host is never re-rendered by the store. */
+var NEVER_SUBSCRIBE = () => () => {};
+var DEFAULT_LAYER = "default";
+function isTrivialOptions(options) {
+	return !!options && typeof options === "object" && "items" in options && !("systemLayers" in options);
 }
-function s(n) {
-	return o(n) ? t({
-		systemLayers: [{ id: a }],
-		historyLimit: n.historyLimit,
-		generateId: n.generateId,
-		initial: n.items.map((t) => ({
+function buildScene(options) {
+	if (!isTrivialOptions(options)) return createScene(options);
+	return createScene({
+		systemLayers: [{ id: DEFAULT_LAYER }],
+		historyLimit: options.historyLimit,
+		generateId: options.generateId,
+		initial: options.items.map((item) => ({
 			kind: "leaf",
-			layer: a,
-			pose: t,
-			data: t,
-			id: e(t.id)
+			layer: DEFAULT_LAYER,
+			pose: item,
+			data: item,
+			id: asNodeId(item.id)
 		}))
-	}) : t(n);
+	});
 }
-function c(e) {
-	let t = n(null);
-	t.current === null && (t.current = s(e));
-	let a = t.current, o = e?.subscribe !== !1;
-	return r(o ? a.subscribe : i, a.getVersion, a.getVersion), a;
+/** Create and subscribe to a scene. */
+function useScene(options) {
+	const sceneRef = useRef(null);
+	if (sceneRef.current === null) sceneRef.current = buildScene(options);
+	const scene = sceneRef.current;
+	const subscribed = options?.subscribe !== false;
+	useSyncExternalStore(subscribed ? scene.subscribe : NEVER_SUBSCRIBE, scene.getVersion, scene.getVersion);
+	return scene;
 }
-//#endregion
-export { c as useScene };
 
+//#endregion
+export { useScene };
 //# sourceMappingURL=useScene.js.map

package/dist/core/scene/useScene.js.map

@@ -1 +1 @@
-{"version":3,"file":"useScene.js","names":["NEVER_SUBSCRIBE","DEFAULT_LAYER","isTrivialOptions","options","buildScene","createScene","item","asNodeId","useScene","sceneRef","useRef","scene","subscribed","useSyncExternalStore"],"sources":["../../../src/core/scene/useScene.ts"],"sourcesContent":["import { useRef, useSyncExternalStore } from 'react';\nimport { createScene } from './scene';\nimport type { NodeId, Scene, UseSceneOptions } from './types';\nimport { asNodeId } from './types';\n\n/** Trivial-form options: a flat list of items, no layers, no parenting. The\n *  full `useScene` form is reachable any time by adding `systemLayers`.\n *\n *  `historyLimit` and `generateId` are accepted because they're orthogonal to\n *  the \"what's in the scene\" question. `ops` is intentionally omitted — if\n *  you need custom ops, your app state already lives outside the \"flat list\n *  of rects\" frame and you should reach for the full `UseSceneOptions`. */\nexport interface UseSceneTrivialOptions<TItem extends { id: string }> {\n  items: readonly TItem[];\n  historyLimit?: number;\n  generateId?: () => NodeId;\n  /** Re-render the host on every scene mutation. Default `true`. See\n   *  {@link UseSceneOptions.subscribe}. */\n  subscribe?: boolean;\n}\n\n/** A subscribe function that never notifies. `useSyncExternalStore` still runs\n *  (hooks are unconditional) but the host is never re-rendered by the store. */\nconst NEVER_SUBSCRIBE = () => () => {};\n\nconst DEFAULT_LAYER = 'default' as const;\ntype DefaultLayer = typeof DEFAULT_LAYER;\n\nfunction isTrivialOptions<TItem extends { id: string }>(\n  options: unknown,\n): options is UseSceneTrivialOptions<TItem> {\n  return (\n    !!options\n    && typeof options === 'object'\n    && 'items' in (options as Record<string, unknown>)\n    && !('systemLayers' in (options as Record<string, unknown>))\n  );\n}\n\nfunction buildScene(options: unknown): Scene<unknown, string, unknown> {\n  if (!isTrivialOptions(options)) {\n    return createScene(options as UseSceneOptions<unknown, string, unknown>);\n  }\n  return createScene<unknown, DefaultLayer, unknown>({\n    systemLayers: [{ id: DEFAULT_LAYER }],\n    historyLimit: options.historyLimit,\n    generateId: options.generateId,\n    initial: options.items.map((item) => ({\n      kind: 'leaf',\n      layer: DEFAULT_LAYER,\n      pose: item,\n      data: item,\n      id: asNodeId(item.id),\n    })),\n  });\n}\n\n/** React hook returning a kit-owned `Scene`. The Scene is constructed once\n *  per host component and tracked via `useSyncExternalStore`, so React re-\n *  renders on every Scene mutation (including undo/redo) unless\n *  `subscribe: false` opts out.\n *\n *  Two call shapes:\n *  - **Trivial**: `useScene({ items })` — one auto-registered system layer\n *    named `'default'`, each item added as a leaf with `pose === data === item`.\n *    Cheapest path for \"a flat list of rects.\"\n *  - **Full**: `useScene({ systemLayers, initial?, ops?, ... })` — explicit\n *    layers, parenting, and custom op registration. */\nexport function useScene<TItem extends { id: string }>(\n  options: UseSceneTrivialOptions<TItem>,\n): Scene<TItem, DefaultLayer, TItem>;\n/** The full call shape: explicit layers, initial nodes, custom ops, and\n *  history configuration. */\nexport function useScene<TData, TLayer extends string, TPose = import('./composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose>;\n/** Create and subscribe to a scene. */\nexport function useScene(options: unknown): unknown {\n  const sceneRef = useRef<Scene<unknown, string, unknown> | null>(null);\n  if (sceneRef.current === null) sceneRef.current = buildScene(options);\n  const scene = sceneRef.current;\n  const subscribed = (options as { subscribe?: boolean } | null)?.subscribe !== false;\n  useSyncExternalStore(\n    subscribed ? scene.subscribe : NEVER_SUBSCRIBE,\n    scene.getVersion,\n    scene.getVersion,\n  );\n  return scene;\n}\n"],"mappings":";;;;AAuBA,IAAMA,gBAA8B,CAAC,GAE/BC,IAAgB;AAGtB,SAASC,EACP,GAC0C;CAC1C,OACE,CAAC,CAACC,KACC,OAAOA,KAAY,YACnB,WAAYA,KACZ,EAAE,kBAAmBA;AAE5B;AAEA,SAASC,EAAW,GAAmD;CAIrE,OAHKF,EAAiBC,CAAO,IAGtBE,EAA4C;EACjD,cAAc,CAAC,EAAE,IAAIJ,EAAc,CAAC;EACpC,cAAcE,EAAQ;EACtB,YAAYA,EAAQ;EACpB,SAASA,EAAQ,MAAM,KAAK,OAAU;GACpC,MAAM;GACN,OAAOF;GACP,MAAMK;GACN,MAAMA;GACN,IAAIC,EAASD,EAAK,EAAE;EACtB,EAAE;CACJ,CAAC,IAbQD,EAAYF,CAAoD;AAc3E;AAsBA,SAAgBK,EAAS,GAA2B;CAClD,IAAMC,IAAWC,EAA+C,IAAI;CACpE,AAAID,EAAS,YAAY,SAAM,EAAS,UAAUL,EAAWD,CAAO;CACpE,IAAMQ,IAAQF,EAAS,SACjBG,IAAcT,GAA4C,cAAc;CAM9E,OALAU,EACED,IAAaD,EAAM,YAAYX,GAC/BW,EAAM,YACNA,EAAM,UACR,GACOA;AACT"}
+{"version":3,"file":"useScene.js","names":[],"sources":["../../../src/core/scene/useScene.ts"],"sourcesContent":["import { useRef, useSyncExternalStore } from 'react';\nimport { createScene } from './scene';\nimport type { NodeId, Scene, UseSceneOptions } from './types';\nimport { asNodeId } from './types';\n\n/** Trivial-form options: a flat list of items, no layers, no parenting. The\n *  full `useScene` form is reachable any time by adding `systemLayers`.\n *\n *  `historyLimit` and `generateId` are accepted because they're orthogonal to\n *  the \"what's in the scene\" question. `ops` is intentionally omitted — if\n *  you need custom ops, your app state already lives outside the \"flat list\n *  of rects\" frame and you should reach for the full `UseSceneOptions`. */\nexport interface UseSceneTrivialOptions<TItem extends { id: string }> {\n  items: readonly TItem[];\n  historyLimit?: number;\n  generateId?: () => NodeId;\n  /** Re-render the host on every scene mutation. Default `true`. See\n   *  {@link UseSceneOptions.subscribe}. */\n  subscribe?: boolean;\n}\n\n/** A subscribe function that never notifies. `useSyncExternalStore` still runs\n *  (hooks are unconditional) but the host is never re-rendered by the store. */\nconst NEVER_SUBSCRIBE = () => () => {};\n\nconst DEFAULT_LAYER = 'default' as const;\ntype DefaultLayer = typeof DEFAULT_LAYER;\n\nfunction isTrivialOptions<TItem extends { id: string }>(\n  options: unknown,\n): options is UseSceneTrivialOptions<TItem> {\n  return (\n    !!options\n    && typeof options === 'object'\n    && 'items' in (options as Record<string, unknown>)\n    && !('systemLayers' in (options as Record<string, unknown>))\n  );\n}\n\nfunction buildScene(options: unknown): Scene<unknown, string, unknown> {\n  if (!isTrivialOptions(options)) {\n    return createScene(options as UseSceneOptions<unknown, string, unknown>);\n  }\n  return createScene<unknown, DefaultLayer, unknown>({\n    systemLayers: [{ id: DEFAULT_LAYER }],\n    historyLimit: options.historyLimit,\n    generateId: options.generateId,\n    initial: options.items.map((item) => ({\n      kind: 'leaf',\n      layer: DEFAULT_LAYER,\n      pose: item,\n      data: item,\n      id: asNodeId(item.id),\n    })),\n  });\n}\n\n/** React hook returning a kit-owned `Scene`. The Scene is constructed once\n *  per host component and tracked via `useSyncExternalStore`, so React re-\n *  renders on every Scene mutation (including undo/redo) unless\n *  `subscribe: false` opts out.\n *\n *  Two call shapes:\n *  - **Trivial**: `useScene({ items })` — one auto-registered system layer\n *    named `'default'`, each item added as a leaf with `pose === data === item`.\n *    Cheapest path for \"a flat list of rects.\"\n *  - **Full**: `useScene({ systemLayers, initial?, ops?, ... })` — explicit\n *    layers, parenting, and custom op registration. */\nexport function useScene<TItem extends { id: string }>(\n  options: UseSceneTrivialOptions<TItem>,\n): Scene<TItem, DefaultLayer, TItem>;\n/** The full call shape: explicit layers, initial nodes, custom ops, and\n *  history configuration. */\nexport function useScene<TData, TLayer extends string, TPose = import('./composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose>;\n/** Create and subscribe to a scene. */\nexport function useScene(options: unknown): unknown {\n  const sceneRef = useRef<Scene<unknown, string, unknown> | null>(null);\n  if (sceneRef.current === null) sceneRef.current = buildScene(options);\n  const scene = sceneRef.current;\n  const subscribed = (options as { subscribe?: boolean } | null)?.subscribe !== false;\n  useSyncExternalStore(\n    subscribed ? scene.subscribe : NEVER_SUBSCRIBE,\n    scene.getVersion,\n    scene.getVersion,\n  );\n  return scene;\n}\n"],"mappings":";;;;;;;AAuBA,IAAM,8BAA8B,CAAC;AAErC,IAAM,gBAAgB;AAGtB,SAAS,iBACP,SAC0C;CAC1C,OACE,CAAC,CAAC,WACC,OAAO,YAAY,YACnB,WAAY,WACZ,EAAE,kBAAmB;AAE5B;AAEA,SAAS,WAAW,SAAmD;CACrE,IAAI,CAAC,iBAAiB,OAAO,GAC3B,OAAO,YAAY,OAAoD;CAEzE,OAAO,YAA4C;EACjD,cAAc,CAAC,EAAE,IAAI,cAAc,CAAC;EACpC,cAAc,QAAQ;EACtB,YAAY,QAAQ;EACpB,SAAS,QAAQ,MAAM,KAAK,UAAU;GACpC,MAAM;GACN,OAAO;GACP,MAAM;GACN,MAAM;GACN,IAAI,SAAS,KAAK,EAAE;EACtB,EAAE;CACJ,CAAC;AACH;;AAsBA,SAAgB,SAAS,SAA2B;CAClD,MAAM,WAAW,OAA+C,IAAI;CACpE,IAAI,SAAS,YAAY,MAAM,SAAS,UAAU,WAAW,OAAO;CACpE,MAAM,QAAQ,SAAS;CACvB,MAAM,aAAc,SAA4C,cAAc;CAC9E,qBACE,aAAa,MAAM,YAAY,iBAC/B,MAAM,YACN,MAAM,UACR;CACA,OAAO;AACT"}

package/dist/core/selection/chromeState.js

@@ -1,31 +1,55 @@
-import { unionAABB as e } from "../geometry/unionBounds.js";
+import { unionAABB } from "../geometry/unionBounds.js";
+
 //#region src/core/selection/chromeState.ts
-var t = {
+/** Nothing selected, nothing resolvable — what a caller reads before a
+*  surface has attached, or where chrome state has no owner. */
+var EMPTY_CHROME_STATE = {
 	selection: [],
-	multiActive: !1,
+	multiActive: false,
 	boundsOf: () => null,
 	unionBounds: null,
 	modifiers: {
-		alt: !1,
-		shift: !1,
-		meta: !1,
-		ctrl: !1
+		alt: false,
+		shift: false,
+		meta: false,
+		ctrl: false
 	}
 };
-function n(t) {
-	let { selection: n, multiActive: r, effectiveBoundsOf: i, modifiers: a, canRotate: o } = t;
+/** Whether chrome goes on something painted on `layer`, as `gate` — a
+*  `ChromeState`, a `ViewApi` — says. No layer, or no gate: it does. */
+function paintsLayer(gate, layer) {
+	return layer === void 0 || gate?.layerIsPainted?.(layer) !== false;
+}
+function buildChromeState(args) {
+	const { effectiveBoundsOf, modifiers, canRotate, layerIsPainted, layerOf } = args;
+	const gate = { ...layerIsPainted ? { layerIsPainted } : {} };
+	const shown = () => {
+		if (!layerIsPainted || !layerOf) return args.selection;
+		const kept = args.selection.filter((id) => paintsLayer(gate, layerOf(id)));
+		return kept.length === args.selection.length ? args.selection : kept;
+	};
+	const multi = () => {
+		const ids = shown();
+		return args.multiActive && (ids === args.selection || ids.length > 1);
+	};
 	return {
-		selection: n,
-		multiActive: r,
-		boundsOf: i,
-		modifiers: a,
-		canRotate: o ?? (() => !0),
+		get selection() {
+			return shown();
+		},
+		get multiActive() {
+			return multi();
+		},
+		boundsOf: effectiveBoundsOf,
+		modifiers,
+		canRotate: canRotate ?? (() => true),
+		...gate,
 		get unionBounds() {
-			return r ? e(n.map((e) => i(e))) : null;
+			if (!multi()) return null;
+			return unionAABB(shown().map((id) => effectiveBoundsOf(id)));
 		}
 	};
 }
-//#endregion
-export { t as EMPTY_CHROME_STATE, n as buildChromeState };
 
+//#endregion
+export { EMPTY_CHROME_STATE, buildChromeState, paintsLayer };
 //# sourceMappingURL=chromeState.js.map

package/dist/core/selection/chromeState.js.map

@@ -1 +1 @@
-{"version":3,"file":"chromeState.js","names":["EMPTY_CHROME_STATE","buildChromeState","args","effectiveBoundsOf","canRotate","multiActive","unionAABB","selection","id"],"sources":["../../../src/core/selection/chromeState.ts"],"sourcesContent":["import type { NodeId } from '../scene/types';\nimport type { ModifierState } from '../modifierState';\nimport type { Bounds } from '../viewport/fitViewToBounds';\nimport { unionAABB } from 'core/geometry/unionBounds';\n\nexport type { Bounds };\n\n/** Nothing selected, nothing resolvable — what a caller reads before a\n *  surface has attached, or where chrome state has no owner. */\nexport const EMPTY_CHROME_STATE: ChromeState = {\n  selection: [],\n  multiActive: false,\n  boundsOf: () => null,\n  unionBounds: null,\n  modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n};\n\n/**\n * Read-only state that affordances consult on every render and hit-test\n * call. Built via `buildChromeState` and held across renders, so affordances\n * must not cache anything they read from it.\n */\nexport interface ChromeState {\n  /** Currently selected ids. Live; reflects useSelection's React state. */\n  readonly selection: readonly NodeId[];\n  /** True when the canvas is in multi-mode AND >= 2 ids are selected. */\n  readonly multiActive: boolean;\n  /** Bounds for any selection member id. Honors active-tool overlay state\n   *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed\n   *  pose bounds). Returns null for unknown ids or ids whose bounds aren't\n   *  computable. */\n  boundsOf(id: string): Bounds | null;\n  /** Multi-union AABB when `multiActive`. Recomputed from `boundsOf` over\n   *  every selected id on each read, expanding rotated members to the extent\n   *  of their ink; null otherwise. */\n  readonly unionBounds: Bounds | null;\n  /** Active modifier state at the moment of the call. */\n  readonly modifiers: ModifierState;\n  /** True iff the node's pose-descriptor declares it can carry a rotation.\n   *  Affordances consult this to decide whether to expose rotate cursors /\n   *  drag-bands. Defaults to `true` when the descriptor doesn't declare\n   *  (back-compat) or when the id is unknown — the rotation gesture will\n   *  no-op visually for poses without AABB fields, but the affordance\n   *  doesn't lie about the cursor. Optional on the interface so unit-test\n   *  call sites that construct `ChromeState` by hand keep compiling;\n   *  affordances should treat an absent predicate as \"true\". */\n  canRotate?(id: string): boolean;\n}\n\nexport interface BuildChromeStateArgs {\n  selection: readonly NodeId[];\n  multiActive: boolean;\n  effectiveBoundsOf: (id: string) => Bounds | null;\n  modifiers: ModifierState;\n  /** Optional rotation-support predicate. When omitted, `canRotate` returns\n   *  `true` for every id — preserves pre-existing affordance behavior for\n   *  unit-test call sites that don't wire pose-descriptor capability. */\n  canRotate?: (id: string) => boolean;\n}\n\nexport function buildChromeState(args: BuildChromeStateArgs): ChromeState {\n  const { selection, multiActive, effectiveBoundsOf, modifiers, canRotate } = args;\n  return {\n    selection,\n    multiActive,\n    boundsOf: effectiveBoundsOf,\n    modifiers,\n    canRotate: canRotate ?? (() => true),\n    // Not cached: the state is memoized across renders, and poses move under\n    // it (a committed move, a live preview) without any of its inputs changing.\n    get unionBounds() {\n      if (!multiActive) return null;\n      return unionAABB(selection.map((id) => effectiveBoundsOf(id)));\n    },\n  };\n}\n"],"mappings":";;AASA,IAAaA,IAAkC;CAC7C,WAAW,CAAC;CACZ,aAAa;CACb,gBAAgB;CAChB,aAAa;CACb,WAAW;EAAE,KAAK;EAAO,OAAO;EAAO,MAAM;EAAO,MAAM;CAAM;AAClE;AA6CA,SAAgBC,EAAiB,GAAyC;CACxE,IAAM,EAAE,cAAW,gBAAa,sBAAmB,cAAW,iBAAcC;CAC5E,OAAO;EACL;EACA;EACA,UAAUC;EACV;EACA,WAAWC,YAAoB;EAG/B,IAAI,cAAc;GAEhB,OADKC,IACEC,EAAUC,EAAU,KAAK,MAAOJ,EAAkBK,CAAE,CAAC,CAAC,IADpC;EAE3B;CACF;AACF"}
+{"version":3,"file":"chromeState.js","names":[],"sources":["../../../src/core/selection/chromeState.ts"],"sourcesContent":["import type { NodeId } from '../scene/types';\nimport type { ModifierState } from '../modifierState';\nimport type { Bounds } from '../viewport/fitViewToBounds';\nimport { unionAABB } from 'core/geometry/unionBounds';\n\nexport type { Bounds };\n\n/** Nothing selected, nothing resolvable — what a caller reads before a\n *  surface has attached, or where chrome state has no owner. */\nexport const EMPTY_CHROME_STATE: ChromeState = {\n  selection: [],\n  multiActive: false,\n  boundsOf: () => null,\n  unionBounds: null,\n  modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n};\n\n/**\n * Read-only state that affordances consult on every render and hit-test\n * call. Built via `buildChromeState` and held across renders, so affordances\n * must not cache anything they read from it.\n */\nexport interface ChromeState {\n  /** Currently selected ids. Live; reflects useSelection's React state,\n   *  less any on a layer this view does not paint. */\n  readonly selection: readonly NodeId[];\n  /** True when the canvas is in multi-mode AND >= 2 ids are selected, and\n   *  still >= 2 once `selection` drops the ones this view does not paint. */\n  readonly multiActive: boolean;\n  /** Bounds for any selection member id. Honors active-tool overlay state\n   *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed\n   *  pose bounds). Returns null for unknown ids or ids whose bounds aren't\n   *  computable. */\n  boundsOf(id: string): Bounds | null;\n  /** Multi-union AABB when `multiActive`. Recomputed from `boundsOf` over\n   *  every selected id on each read, expanding rotated members to the extent\n   *  of their ink; null otherwise. */\n  readonly unionBounds: Bounds | null;\n  /** Active modifier state at the moment of the call. */\n  readonly modifiers: ModifierState;\n  /** True iff the node's pose-descriptor declares it can carry a rotation.\n   *  Affordances consult this to decide whether to expose rotate cursors /\n   *  drag-bands. Defaults to `true` when the descriptor doesn't declare\n   *  (back-compat) or when the id is unknown — the rotation gesture will\n   *  no-op visually for poses without AABB fields, but the affordance\n   *  doesn't lie about the cursor. Optional on the interface so unit-test\n   *  call sites that construct `ChromeState` by hand keep compiling;\n   *  affordances should treat an absent predicate as \"true\". */\n  canRotate?(id: string): boolean;\n  /** Whether a scene layer reaches the screen in the view this state was\n   *  built for — its `layerVisibility` / `layerOrder`, as `ViewApi` answers\n   *  it. Absent: the view paints every layer the scene shows. An affordance\n   *  that reads it puts no chrome on a node whose layer it says `false` to. */\n  layerIsPainted?(layerId: string): boolean;\n}\n\nexport interface BuildChromeStateArgs {\n  selection: readonly NodeId[];\n  multiActive: boolean;\n  effectiveBoundsOf: (id: string) => Bounds | null;\n  modifiers: ModifierState;\n  /** Optional rotation-support predicate. When omitted, `canRotate` returns\n   *  `true` for every id — preserves pre-existing affordance behavior for\n   *  unit-test call sites that don't wire pose-descriptor capability. */\n  canRotate?: (id: string) => boolean;\n  layerIsPainted?: (layerId: string) => boolean;\n  /** The scene layer a selected id is painted on. With `layerIsPainted`,\n   *  drops from `selection` every id this view does not paint. */\n  layerOf?: (id: string) => string | undefined;\n}\n\n/** Whether chrome goes on something painted on `layer`, as `gate` — a\n *  `ChromeState`, a `ViewApi` — says. No layer, or no gate: it does. */\nexport function paintsLayer(\n  gate: { layerIsPainted?(layerId: string): boolean } | null | undefined,\n  layer: string | undefined,\n): boolean {\n  return layer === undefined || gate?.layerIsPainted?.(layer) !== false;\n}\n\nexport function buildChromeState(args: BuildChromeStateArgs): ChromeState {\n  const { effectiveBoundsOf, modifiers, canRotate, layerIsPainted, layerOf } = args;\n  const gate = { ...(layerIsPainted ? { layerIsPainted } : {}) };\n  // Read per call, like `unionBounds`: the view's layer settings change under a memoized state.\n  const shown = (): readonly NodeId[] => {\n    if (!layerIsPainted || !layerOf) return args.selection;\n    const kept = args.selection.filter((id) => paintsLayer(gate, layerOf(id)));\n    return kept.length === args.selection.length ? args.selection : kept;\n  };\n  const multi = (): boolean => {\n    const ids = shown();\n    return args.multiActive && (ids === args.selection || ids.length > 1);\n  };\n  return {\n    get selection() { return shown(); },\n    get multiActive() { return multi(); },\n    boundsOf: effectiveBoundsOf,\n    modifiers,\n    canRotate: canRotate ?? (() => true),\n    ...gate,\n    // Not cached: the state is memoized across renders, and poses move under\n    // it (a committed move, a live preview) without any of its inputs changing.\n    get unionBounds() {\n      if (!multi()) return null;\n      return unionAABB(shown().map((id) => effectiveBoundsOf(id)));\n    },\n  };\n}\n"],"mappings":";;;;;AASA,IAAa,qBAAkC;CAC7C,WAAW,CAAC;CACZ,aAAa;CACb,gBAAgB;CAChB,aAAa;CACb,WAAW;EAAE,KAAK;EAAO,OAAO;EAAO,MAAM;EAAO,MAAM;CAAM;AAClE;;;AA0DA,SAAgB,YACd,MACA,OACS;CACT,OAAO,UAAU,UAAa,MAAM,iBAAiB,KAAK,MAAM;AAClE;AAEA,SAAgB,iBAAiB,MAAyC;CACxE,MAAM,EAAE,mBAAmB,WAAW,WAAW,gBAAgB,YAAY;CAC7E,MAAM,OAAO,EAAE,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC,EAAG;CAE7D,MAAM,cAAiC;EACrC,IAAI,CAAC,kBAAkB,CAAC,SAAS,OAAO,KAAK;EAC7C,MAAM,OAAO,KAAK,UAAU,QAAQ,OAAO,YAAY,MAAM,QAAQ,EAAE,CAAC,CAAC;EACzE,OAAO,KAAK,WAAW,KAAK,UAAU,SAAS,KAAK,YAAY;CAClE;CACA,MAAM,cAAuB;EAC3B,MAAM,MAAM,MAAM;EAClB,OAAO,KAAK,gBAAgB,QAAQ,KAAK,aAAa,IAAI,SAAS;CACrE;CACA,OAAO;EACL,IAAI,YAAY;GAAE,OAAO,MAAM;EAAG;EAClC,IAAI,cAAc;GAAE,OAAO,MAAM;EAAG;EACpC,UAAU;EACV;EACA,WAAW,oBAAoB;EAC/B,GAAG;EAGH,IAAI,cAAc;GAChB,IAAI,CAAC,MAAM,GAAG,OAAO;GACrB,OAAO,UAAU,MAAM,CAAC,CAAC,KAAK,OAAO,kBAAkB,EAAE,CAAC,CAAC;EAC7D;CACF;AACF"}

package/dist/core/selection/readOnlySelection.js

@@ -1,32 +1,47 @@
 //#region src/core/selection/readOnlySelection.ts
-var e = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap(), n = () => {};
-function r(t) {
-	let r = e.get(t);
-	return r || (r = {
-		getSelection: () => t.getSelection(),
-		setSelection: n
-	}, e.set(t, r)), r;
+var methodViews = /* @__PURE__ */ new WeakMap();
+var apiViews = /* @__PURE__ */ new WeakMap();
+var ignore = () => {};
+function readOnlyAdapterMethods(methods) {
+	let view = methodViews.get(methods);
+	if (!view) {
+		view = {
+			getSelection: () => methods.getSelection(),
+			setSelection: ignore
+		};
+		methodViews.set(methods, view);
+	}
+	return view;
 }
-function i(e) {
-	let i = r(e.adapterMethods), a = t.get(e);
-	if (a && a.adapterMethods === i) return a;
-	let o = {
+/**
+* A view of `api` that reads the live selection and ignores every write.
+* `api` itself is untouched and still writes.
+*
+* One view per `api`, and one set of `adapterMethods` per `api.adapterMethods`,
+* so either is as stable a memo or effect dependency as the object it wraps.
+*/
+function readOnlySelection(api) {
+	const adapterMethods = readOnlyAdapterMethods(api.adapterMethods);
+	const cached = apiViews.get(api);
+	if (cached && cached.adapterMethods === adapterMethods) return cached;
+	const view = {
 		get current() {
-			return e.current;
+			return api.current;
 		},
-		get: e.get,
-		contains: e.contains,
-		set: n,
-		add: n,
-		remove: n,
-		toggle: n,
-		clear: n,
-		applyClick: n,
-		adapterMethods: i
+		get: api.get,
+		contains: api.contains,
+		set: ignore,
+		add: ignore,
+		remove: ignore,
+		toggle: ignore,
+		clear: ignore,
+		applyClick: ignore,
+		adapterMethods
 	};
-	return t.set(e, o), o;
+	apiViews.set(api, view);
+	return view;
 }
-//#endregion
-export { i as readOnlySelection };
 
+//#endregion
+export { readOnlySelection };
 //# sourceMappingURL=readOnlySelection.js.map

package/dist/core/selection/readOnlySelection.js.map

@@ -1 +1 @@
-{"version":3,"file":"readOnlySelection.js","names":["methodViews","apiViews","ignore","readOnlyAdapterMethods","view","methods","readOnlySelection","adapterMethods","api","cached"],"sources":["../../../src/core/selection/readOnlySelection.ts"],"sourcesContent":["import type { SelectionApi } from './useSelection';\n\ntype AdapterMethods = SelectionApi['adapterMethods'];\n\nconst methodViews = new WeakMap<AdapterMethods, AdapterMethods>();\nconst apiViews = new WeakMap<SelectionApi, SelectionApi>();\n\nconst ignore = (): void => {};\n\nfunction readOnlyAdapterMethods(methods: AdapterMethods): AdapterMethods {\n  let view = methodViews.get(methods);\n  if (!view) {\n    view = { getSelection: () => methods.getSelection(), setSelection: ignore };\n    methodViews.set(methods, view);\n  }\n  return view;\n}\n\n/**\n * A view of `api` that reads the live selection and ignores every write.\n * `api` itself is untouched and still writes.\n *\n * One view per `api`, and one set of `adapterMethods` per `api.adapterMethods`,\n * so either is as stable a memo or effect dependency as the object it wraps.\n */\nexport function readOnlySelection(api: SelectionApi): SelectionApi {\n  const adapterMethods = readOnlyAdapterMethods(api.adapterMethods);\n  const cached = apiViews.get(api);\n  if (cached && cached.adapterMethods === adapterMethods) return cached;\n  const view: SelectionApi = {\n    get current() { return api.current; },\n    get: api.get,\n    contains: api.contains,\n    set: ignore,\n    add: ignore,\n    remove: ignore,\n    toggle: ignore,\n    clear: ignore,\n    applyClick: ignore,\n    adapterMethods,\n  };\n  apiViews.set(api, view);\n  return view;\n}\n"],"mappings":";AAIA,IAAMA,oBAAc,IAAI,QAAwC,GAC1DC,oBAAW,IAAI,QAAoC,GAEnDC,UAAqB,CAAC;AAE5B,SAASC,EAAuB,GAAyC;CACvE,IAAIC,IAAOJ,EAAY,IAAIK,CAAO;CAKlC,OAJKD,MACH,IAAO;EAAE,oBAAoBC,EAAQ,aAAa;EAAG,cAAcH;CAAO,GAC1EF,EAAY,IAAIK,GAASD,CAAI,IAExBA;AACT;AASA,SAAgBE,EAAkB,GAAiC;CACjE,IAAMC,IAAiBJ,EAAuBK,EAAI,cAAc,GAC1DC,IAASR,EAAS,IAAIO,CAAG;CAC/B,IAAIC,KAAUA,EAAO,mBAAmBF,GAAgB,OAAOE;CAC/D,IAAML,IAAqB;EACzB,IAAI,UAAU;GAAE,OAAOI,EAAI;EAAS;EACpC,KAAKA,EAAI;EACT,UAAUA,EAAI;EACd,KAAKN;EACL,KAAKA;EACL,QAAQA;EACR,QAAQA;EACR,OAAOA;EACP,YAAYA;EACZ;CACF;CAEA,OADAD,EAAS,IAAIO,GAAKJ,CAAI,GACfA;AACT"}
+{"version":3,"file":"readOnlySelection.js","names":[],"sources":["../../../src/core/selection/readOnlySelection.ts"],"sourcesContent":["import type { SelectionApi } from './useSelection';\n\ntype AdapterMethods = SelectionApi['adapterMethods'];\n\nconst methodViews = new WeakMap<AdapterMethods, AdapterMethods>();\nconst apiViews = new WeakMap<SelectionApi, SelectionApi>();\n\nconst ignore = (): void => {};\n\nfunction readOnlyAdapterMethods(methods: AdapterMethods): AdapterMethods {\n  let view = methodViews.get(methods);\n  if (!view) {\n    view = { getSelection: () => methods.getSelection(), setSelection: ignore };\n    methodViews.set(methods, view);\n  }\n  return view;\n}\n\n/**\n * A view of `api` that reads the live selection and ignores every write.\n * `api` itself is untouched and still writes.\n *\n * One view per `api`, and one set of `adapterMethods` per `api.adapterMethods`,\n * so either is as stable a memo or effect dependency as the object it wraps.\n */\nexport function readOnlySelection(api: SelectionApi): SelectionApi {\n  const adapterMethods = readOnlyAdapterMethods(api.adapterMethods);\n  const cached = apiViews.get(api);\n  if (cached && cached.adapterMethods === adapterMethods) return cached;\n  const view: SelectionApi = {\n    get current() { return api.current; },\n    get: api.get,\n    contains: api.contains,\n    set: ignore,\n    add: ignore,\n    remove: ignore,\n    toggle: ignore,\n    clear: ignore,\n    applyClick: ignore,\n    adapterMethods,\n  };\n  apiViews.set(api, view);\n  return view;\n}\n"],"mappings":";AAIA,IAAM,8BAAc,IAAI,QAAwC;AAChE,IAAM,2BAAW,IAAI,QAAoC;AAEzD,IAAM,eAAqB,CAAC;AAE5B,SAAS,uBAAuB,SAAyC;CACvE,IAAI,OAAO,YAAY,IAAI,OAAO;CAClC,IAAI,CAAC,MAAM;EACT,OAAO;GAAE,oBAAoB,QAAQ,aAAa;GAAG,cAAc;EAAO;EAC1E,YAAY,IAAI,SAAS,IAAI;CAC/B;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,kBAAkB,KAAiC;CACjE,MAAM,iBAAiB,uBAAuB,IAAI,cAAc;CAChE,MAAM,SAAS,SAAS,IAAI,GAAG;CAC/B,IAAI,UAAU,OAAO,mBAAmB,gBAAgB,OAAO;CAC/D,MAAM,OAAqB;EACzB,IAAI,UAAU;GAAE,OAAO,IAAI;EAAS;EACpC,KAAK,IAAI;EACT,UAAU,IAAI;EACd,KAAK;EACL,KAAK;EACL,QAAQ;EACR,QAAQ;EACR,OAAO;EACP,YAAY;EACZ;CACF;CACA,SAAS,IAAI,KAAK,IAAI;CACtB,OAAO;AACT"}

package/dist/core/selection/selectionTarget.js

@@ -1,6 +1,17 @@
 //#region src/core/selection/selectionTarget.ts
-var e = "__weasel:multi-selection";
-//#endregion
-export { e as MULTI_RESIZE_TARGET_ID };
+/** Synthetic id a canvas uses to address the
+*  union-AABB target when 2+ real ids are selected. The selection-overlay
+*  layer and the affordance hit-tester both resolve it to `ChromeState`'s
+*  `unionBounds`; consumers wiring their own selection-overlay layer can
+*  reference the same constant.
+*
+*  Lives in `core/selection` (next to `ChromeState`) because it's a
+*  selection-derived concept, not a tool concept — `affordances/`,
+*  `features/selection/`, and `tools/` all consume it, so it must sit at
+*  the bottom of the layering (`core` → `affordances` → `tools` →
+*  `features`). */
+var MULTI_RESIZE_TARGET_ID = "__weasel:multi-selection";
 
+//#endregion
+export { MULTI_RESIZE_TARGET_ID };
 //# sourceMappingURL=selectionTarget.js.map

package/dist/core/selection/selectionTarget.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectionTarget.js","names":["MULTI_RESIZE_TARGET_ID"],"sources":["../../../src/core/selection/selectionTarget.ts"],"sourcesContent":["/** Synthetic id a canvas uses to address the\n *  union-AABB target when 2+ real ids are selected. The selection-overlay\n *  layer and the affordance hit-tester both resolve it to `ChromeState`'s\n *  `unionBounds`; consumers wiring their own selection-overlay layer can\n *  reference the same constant.\n *\n *  Lives in `core/selection` (next to `ChromeState`) because it's a\n *  selection-derived concept, not a tool concept — `affordances/`,\n *  `features/selection/`, and `tools/` all consume it, so it must sit at\n *  the bottom of the layering (`core` → `affordances` → `tools` →\n *  `features`). */\nexport const MULTI_RESIZE_TARGET_ID = '__weasel:multi-selection';\n"],"mappings":";AAWA,IAAaA,IAAyB"}
+{"version":3,"file":"selectionTarget.js","names":[],"sources":["../../../src/core/selection/selectionTarget.ts"],"sourcesContent":["/** Synthetic id a canvas uses to address the\n *  union-AABB target when 2+ real ids are selected. The selection-overlay\n *  layer and the affordance hit-tester both resolve it to `ChromeState`'s\n *  `unionBounds`; consumers wiring their own selection-overlay layer can\n *  reference the same constant.\n *\n *  Lives in `core/selection` (next to `ChromeState`) because it's a\n *  selection-derived concept, not a tool concept — `affordances/`,\n *  `features/selection/`, and `tools/` all consume it, so it must sit at\n *  the bottom of the layering (`core` → `affordances` → `tools` →\n *  `features`). */\nexport const MULTI_RESIZE_TARGET_ID = '__weasel:multi-selection';\n"],"mappings":";;;;;;;;;;;;AAWA,IAAa,yBAAyB"}