@weasel-js/core 1.9.3 → 1.10.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"kitOps.js","names":["setParallax","to","record","setUnits","node","registerKitOps","env","registerKitOp","kind","handler","state","p","attach","dependents","trackChildDerived","target","attached","addedFns","field","fnFields","fn","key","restoreFn","dwarn","detach","childDerived","invalidateChildDerivedFrom","invalidateDependents","n","d","keys","k","clone","restoreNodeFunctions","requireLayerIndex","invalidateOrder","requireNode","layoutRefs","placeLayout","f","live","side","layout","rebuildLayerIndex","placeLayer","rec","layer","index"],"sources":["../../../src/core/scene/kitOps.ts"],"sourcesContent":["/**\n * The kit's own op kinds: `kit:add`, `kit:remove`, `kit:setPose`, and the\n * rest. They are registered like any other op; the scene's mutation methods\n * build serializable payloads and route through the same log and replay\n * machinery a consumer's ops do.\n */\nimport type { UnitScope } from '@weasel-js/quantity';\nimport type { ParallaxOpts } from 'core/viewport/parallax';\nimport { dwarn } from 'debug/flag';\nimport type { LayoutStrategy } from '../../layout/types';\nimport { restoreFn, type FnBearingNode, type NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type {\n  ContainerNode, LayerRecord, LeafNode, Node, NodeId, RegisteredOp, UserLayerRecord,\n} from './types';\n\n/**\n * Snapshot of every node a removal deletes, so revert restores it exactly.\n *\n * A cascade unlinks several disjoint subtrees, not one, so `detached` names\n * each node the tree has to re-link; everything else in `nodes` has a parent\n * that is also going and rides back in that parent's cloned `children`.\n * Entries are sorted by ascending sibling index — globally rather than\n * per-parent, because only same-parent order constrains re-insertion and\n * entries under different parents never interact.\n */\nexport interface RemoveSnapshot<TData, TLayer extends string, TPose> {\n  nodes: Node<TData, TLayer, TPose>[];\n  detached: { id: NodeId; parent: NodeId | null; index: number }[];\n  /** Registry keys for the function-valued fields on `nodes`. The functions\n   *  themselves do not survive a persisted history, so revert re-resolves\n   *  them the way `kit:add` does. */\n  fnKeys?: ({ id: NodeId } & Record<string, string | undefined>)[];\n}\n\n/** What a `kit:setLayout` op carries: the container, and each side's layout\n *  by registry key when it has one. */\nexport interface SetLayoutPayload { id: NodeId; fromKey?: string; toKey?: string }\n\n/** What the op table needs from the scene it mutates. */\nexport interface KitOpsEnv<TData, TLayer extends string, TPose> {\n  state: {\n    nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n    layers: LayerRecord<TLayer>[];\n  };\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  store: ReturnType<typeof createNodeStore<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  rebuildLayerIndex(): void;\n  invalidateOrder(): void;\n  fnFields: readonly NodeFnField[];\n  /** Drop from the selection whatever a layer lock just put out of reach, and\n   *  the ids in `gone`. */\n  narrowSelection(gone?: ReadonlySet<NodeId>): void;\n  /** Drop the pose override of a node that is about to leave the scene: ids\n   *  are reusable, and one left behind would attach itself to whatever is\n   *  added under that id next. */\n  clearOverride(id: NodeId): void;\n}\n\nfunction setParallax(record: { parallax?: ParallaxOpts }, to: ParallaxOpts | undefined): void {\n  if (to === undefined) delete record.parallax;\n  else record.parallax = to;\n}\n\nfunction setUnits(node: { units?: UnitScope }, to: UnitScope | undefined): void {\n  if (to === undefined) delete node.units;\n  else node.units = to;\n}\n\n/** Register every kit op kind. Answers with the table a live `kit:setLayout`\n *  payload's strategies are kept in, which `scene.setLayout` fills. */\nexport function registerKitOps<TData, TLayer extends string, TPose>(\n  env: KitOpsEnv<TData, TLayer, TPose>,\n): {\n  layoutRefs: WeakMap<object, { from: LayoutStrategy<TPose> | null; to: LayoutStrategy<TPose> | null }>;\n} {\n  const { state, requireLayerIndex, rebuildLayerIndex, invalidateOrder, fnFields } = env;\n  const {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, detach, attach, addedFns, restoreNodeFunctions,\n  } = env.store;\n\n  function registerKitOp<P>(kind: string, handler: RegisteredOp<P>): void {\n    env.register(kind, handler as RegisteredOp<unknown>);\n  }\n\n  registerKitOp<{\n    id: NodeId; kind: 'leaf' | 'container'; layer: TLayer; pose: TPose; data: TData;\n    parent: NodeId | null; index: number;\n    dependsOn?: readonly NodeId[] | 'children';\n    pickable?: boolean;\n    units?: UnitScope;\n  } & Record<string, unknown>>('kit:add', {\n    apply: (p) => {\n      if (state.nodes.has(p.id)) {\n        throw new Error(`Scene: id collision on \"${p.id}\"`);\n      }\n      const node: Node<TData, TLayer, TPose> = p.kind === 'container'\n        ? ({ kind: 'container', id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent, children: [] } as ContainerNode<TData, TLayer, TPose>)\n        : ({ kind: 'leaf', id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent } as LeafNode<TData, TLayer, TPose>);\n      state.nodes.set(p.id, node);\n      attach(p.id, p.parent, p.index);\n      if (p.dependsOn !== undefined) node.dependsOn = p.dependsOn;\n      if (p.pickable !== undefined) node.pickable = p.pickable;\n      if (p.units !== undefined) (node as ContainerNode<TData, TLayer, TPose>).units = p.units;\n      dependents.add(p.id, p.dependsOn === 'children' ? [] : p.dependsOn ?? []);\n      trackChildDerived(p.id, p.dependsOn);\n      // Two ways a function field comes back. Redo of a live add reads\n      // what `scene.add` attached, since it replays the op without a spec.\n      // A restored history has only the registry key the payload carries.\n      const target = node as unknown as FnBearingNode;\n      const attached = addedFns.get(p);\n      for (const field of fnFields) {\n        const fn = attached?.get(field);\n        if (fn !== undefined) {\n          field.write(target, fn);\n          continue;\n        }\n        const key = p[field.spec.opKey] as string | undefined;\n        if (key !== undefined) restoreFn(field, target, key, 'kit:add', dwarn);\n      }\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      env.clearOverride(p.id);\n      detach(p.id);\n      state.nodes.delete(p.id);\n      dependents.remove(p.id);\n      childDerived.delete(p.id);\n      invalidateChildDerivedFrom(p.parent);\n      invalidateDependents(p.id);\n    },\n  });\n\n  // Neither half invalidates dependents: removal's closure takes every live one.\n  registerKitOp<RemoveSnapshot<TData, TLayer, TPose>>('kit:remove', {\n    apply: (p) => {\n      for (const n of p.nodes) env.clearOverride(n.id);\n      for (const d of p.detached) detach(d.id);\n      for (const n of p.nodes) {\n        state.nodes.delete(n.id);\n        dependents.remove(n.id);\n        childDerived.delete(n.id);\n      }\n      // A `dependsOn: 'children'` container the removal did not take is now\n      // hugging a smaller set.\n      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);\n      env.narrowSelection(new Set(p.nodes.map((n) => n.id)));\n    },\n    revert: (p) => {\n      const keys = new Map((p.fnKeys ?? []).map((k) => [k.id, k]));\n      // Order-independent: every clone carries its own parent and children.\n      for (const n of p.nodes) {\n        const clone: Node<TData, TLayer, TPose> = n.kind === 'container'\n          ? { ...n, children: [...n.children] }\n          : { ...n };\n        restoreNodeFunctions(clone, keys.get(n.id));\n        state.nodes.set(n.id, clone);\n        dependents.add(n.id, clone.dependsOn === 'children' ? [] : clone.dependsOn ?? []);\n        trackChildDerived(n.id, clone.dependsOn);\n      }\n      for (const d of p.detached) attach(d.id, d.parent, d.index);\n      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);\n    },\n  });\n\n  registerKitOp<{ id: NodeId; from: TPose; to: TPose }>('kit:setPose', {\n    apply: (p) => {\n      (requireNode(p.id) as { pose: TPose }).pose = p.to;\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { pose: TPose }).pose = p.from;\n      invalidateDependents(p.id);\n    },\n  });\n\n  // A derivation is handed its dependencies' nodes, not only their poses, so a\n  // connector reading `data` or `layer` goes stale on these two exactly as it\n  // does on a move.\n  registerKitOp<{ id: NodeId; from: TData; to: TData }>('kit:setData', {\n    apply: (p) => {\n      (requireNode(p.id) as { data: TData }).data = p.to;\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { data: TData }).data = p.from;\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{ id: NodeId; from: TLayer; to: TLayer }>('kit:setLayer', {\n    apply: (p) => {\n      requireLayerIndex(p.to);\n      (requireNode(p.id) as { layer: TLayer }).layer = p.to;\n      invalidateOrder();\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      (requireNode(p.id) as { layer: TLayer }).layer = p.from;\n      invalidateOrder();\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{\n    id: NodeId;\n    from: Node<TData, TLayer, TPose>['dependsOn'];\n    to: Node<TData, TLayer, TPose>['dependsOn'];\n  }>('kit:setDependsOn', {\n    apply: (p) => { retarget(p.id, p.to); },\n    revert: (p) => { retarget(p.id, p.from); },\n  });\n\n  registerKitOp<{ id: NodeId; from?: UnitScope; to?: UnitScope }>('kit:setUnits', {\n    apply: (p) => { setUnits(requireNode(p.id) as { units?: UnitScope }, p.to); },\n    revert: (p) => { setUnits(requireNode(p.id) as { units?: UnitScope }, p.from); },\n  });\n\n  /** The strategies each live `kit:setLayout` payload swaps between. A payload\n   *  replayed from a persisted history has none, and resolves its keys. */\n  const layoutRefs = new WeakMap<object, { from: LayoutStrategy<TPose> | null; to: LayoutStrategy<TPose> | null }>();\n  function placeLayout(p: SetLayoutPayload, side: 'from' | 'to'): void {\n    const node = requireNode(p.id) as unknown as FnBearingNode;\n    const field = fnFields.find((f) => f.spec.field === 'layout')!;\n    const live = layoutRefs.get(p);\n    const key = side === 'from' ? p.fromKey : p.toKey;\n    if (live === undefined && key !== undefined) {\n      delete node.layout;\n      restoreFn(field, node, key, 'kit:setLayout', dwarn);\n      return;\n    }\n    const layout = live?.[side] ?? null;\n    if (layout === null) delete node.layout;\n    else field.write(node, layout);\n  }\n  registerKitOp<SetLayoutPayload>('kit:setLayout', {\n    apply: (p) => { placeLayout(p, 'to'); },\n    revert: (p) => { placeLayout(p, 'from'); },\n  });\n\n  registerKitOp<{\n    id: NodeId; fromParent: NodeId | null; fromIndex: number;\n    toParent: NodeId | null; toIndex: number;\n  }>('kit:move', {\n    apply: (p) => {\n      detach(p.id);\n      attach(p.id, p.toParent, p.toIndex);\n      // Both ends: the container it left no longer hugs it, and the one it\n      // joined now does.\n      invalidateChildDerivedFrom(p.fromParent);\n      invalidateDependents(p.id);\n    },\n    revert: (p) => {\n      detach(p.id);\n      attach(p.id, p.fromParent, p.fromIndex);\n      invalidateChildDerivedFrom(p.toParent);\n      invalidateDependents(p.id);\n    },\n  });\n\n  registerKitOp<{ layer: TLayer; from: boolean; to: boolean }>('kit:setLayerVisible', {\n    apply: (p) => { state.layers[requireLayerIndex(p.layer)].visible = p.to; },\n    revert: (p) => { state.layers[requireLayerIndex(p.layer)].visible = p.from; },\n  });\n\n  registerKitOp<{ layer: TLayer; from: boolean; to: boolean }>('kit:setLayerLocked', {\n    apply: (p) => { state.layers[requireLayerIndex(p.layer)].locked = p.to; if (p.to) env.narrowSelection(); },\n    revert: (p) => { state.layers[requireLayerIndex(p.layer)].locked = p.from; },\n  });\n\n  registerKitOp<{ layer: TLayer; from?: ParallaxOpts; to?: ParallaxOpts }>('kit:setLayerParallax', {\n    apply: (p) => { setParallax(state.layers[requireLayerIndex(p.layer)], p.to); },\n    revert: (p) => { setParallax(state.layers[requireLayerIndex(p.layer)], p.from); },\n  });\n\n  registerKitOp<{ record: UserLayerRecord<TLayer>; index: number }>('kit:addLayer', {\n    apply: (p) => { state.layers.splice(p.index, 0, { ...p.record }); rebuildLayerIndex(); },\n    revert: (p) => { state.layers.splice(p.index, 1); rebuildLayerIndex(); },\n  });\n\n  registerKitOp<{ record: LayerRecord<TLayer>; index: number }>('kit:removeLayer', {\n    apply: (p) => { state.layers.splice(p.index, 1); rebuildLayerIndex(); },\n    revert: (p) => { state.layers.splice(p.index, 0, { ...p.record } as LayerRecord<TLayer>); rebuildLayerIndex(); },\n  });\n\n  registerKitOp<{ layer: TLayer; from: string; to: string }>('kit:renameLayer', {\n    apply: (p) => { (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.to; },\n    revert: (p) => { (state.layers[requireLayerIndex(p.layer)] as UserLayerRecord<TLayer>).name = p.from; },\n  });\n\n  /** Finds the layer by id, not by where the payload last left it: moves of\n   *  one layer coalesce, and the entry then reverts the first payload from\n   *  wherever the last one put the layer. */\n  function placeLayer(layer: TLayer, index: number): void {\n    const [rec] = state.layers.splice(requireLayerIndex(layer), 1);\n    state.layers.splice(index, 0, rec);\n    rebuildLayerIndex();\n  }\n\n  registerKitOp<{ layer: TLayer; from: number; to: number }>('kit:moveLayer', {\n    apply: (p) => placeLayer(p.layer, p.to),\n    revert: (p) => placeLayer(p.layer, p.from),\n  });\n\n  return { layoutRefs };\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"kitRegistry.js","names":["UNION_OF_CHILDREN","unionOfChildren","poses","d","deps","rect","asRectPose","union","unionAABB","pose","p","withKitRegistry","registry"],"sources":["../../../src/core/scene/kitRegistry.ts"],"sourcesContent":["/**\n * The `SceneRegistry` entries the kit owns.\n *\n * A registry-keyed function has to be resolvable by key in whatever scene\n * loads a snapshot, so a function the *kit* attaches to a node cannot live in\n * the consumer's registry alone — a document saved with a grouped container\n * would come back with a dead key. `createScene` merges these under the\n * consumer's, which stays the winner on a key collision.\n */\nimport { unionAABB } from '../geometry/unionBounds';\nimport type { RectPose, SceneRegistry } from './types';\n\n/** Registry key for {@link unionOfChildren}. */\nexport const UNION_OF_CHILDREN = 'kit:unionOfChildren';\n\n/**\n * A container's pose as the envelope of what it holds — `unionAABB`, so a\n * rotated member contributes the extent of its ink rather than its unrotated\n * box. Paired with `dependsOn: 'children'`, this is what makes a group's\n * bounds track its members instead of freezing at the moment it was made.\n *\n * Its members and its result share one frame: a container deriving its pose\n * from its children defines none of its own (see `definesFrame`), so the same\n * union is right under any composition strategy.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose — the group stays where the last member left it rather than collapsing\n * to a zero box at the origin.\n *\n * Reads members as rect poses, and only as rect poses: a scene whose poses are\n * shaped otherwise gets `null` here and its container keeps its authored pose,\n * because this entry is registered into every scene and the scene layer holds\n * no descriptor to read another shape with. To make such a container track its\n * members, register `unionOfChildrenVia(itsDescriptor)` under\n * {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.\n */\nexport function unionOfChildren<TPose>(\n  _node: unknown,\n  deps: readonly ({ pose: TPose } | undefined)[],\n): TPose | null {\n  const poses: RectPose[] = [];\n  for (const d of deps) {\n    if (d === undefined) continue;\n    const rect = asRectPose(d.pose);\n    if (rect === null) return null;\n    poses.push(rect);\n  }\n  if (poses.length === 0) return null;\n  const union = unionAABB(poses);\n  // Sound by the check above: every member read as a rect, so the union is one\n  // too, and a scene holding rect poses is a scene whose `TPose` is one.\n  return union === null ? null : (union as unknown as TPose);\n}\n\n/** `pose` as a rect, or `null` when it is some other shape entirely. */\nexport function asRectPose(pose: unknown): RectPose | null {\n  if (pose === null || typeof pose !== 'object') return null;\n  const p = pose as Partial<RectPose>;\n  const rect = typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n  return rect ? (pose as RectPose) : null;\n}\n\n/** Merge the kit's own entries under a consumer registry. */\nexport function withKitRegistry<TPose, TData = unknown, TLayer extends string = string>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n): SceneRegistry<TPose, TData, TLayer> {\n  return {\n    ...registry,\n    derivePose: {\n      [UNION_OF_CHILDREN]: unionOfChildren as NonNullable<\n        SceneRegistry<TPose, TData, TLayer>['derivePose']\n      >[string],\n      ...registry.derivePose,\n    },\n  };\n}\n"],"mappings":";;AAaA,IAAaA,IAAoB;AAuBjC,SAAgBC,EACd,GACA,GACc;CACd,IAAMC,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAKC,GAAM;EACpB,IAAID,MAAM,KAAA,GAAW;EACrB,IAAME,IAAOC,EAAWH,EAAE,IAAI;EAC9B,IAAIE,MAAS,MAAM,OAAO;EAC1B,EAAM,KAAKA,CAAI;CACjB;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAMK,IAAQC,EAAUN,CAAK;CAG7B,OAAOK,MAAU,OAAO,OAAQA;AAClC;AAGA,SAAgBD,EAAW,GAAgC;CACzD,IAAqB,OAAOG,KAAS,aAAjCA,GAA2C,OAAO;CACtD,IAAMC,IAAID;CAGV,OAFa,OAAOC,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAClD,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW,WACzCD,IAAoB;AACrC;AAGA,SAAgBE,EACd,GACqC;CACrC,OAAO;EACL,GAAGC;EACH,YAAY;IACTZ,IAAoBC;GAGrB,GAAGW,EAAS;EACd;CACF;AACF"}
+{"version":3,"file":"kitRegistry.js","names":["UNION_OF_CHILDREN","unionOfChildren","poses","d","deps","rect","asRectPose","union","unionAABB","pose","p","withKitRegistry","registry"],"sources":["../../../src/core/scene/kitRegistry.ts"],"sourcesContent":["/**\n * The `SceneRegistry` entries the kit owns.\n *\n * A registry-keyed function has to be resolvable by key in whatever scene\n * loads a snapshot, so a function the *kit* attaches to a node cannot live in\n * the consumer's registry alone — a document saved with a grouped container\n * would come back with a dead key. `createScene` merges these under the\n * consumer's, which stays the winner on a key collision.\n */\nimport { unionAABB } from '../geometry/unionBounds';\nimport type { RectPose, SceneRegistry } from './types';\n\n/** Registry key for {@link unionOfChildren}. */\nexport const UNION_OF_CHILDREN = 'kit:unionOfChildren';\n\n/**\n * A container's pose as the envelope of what it holds — `unionAABB`, so a\n * rotated member contributes the extent of its ink rather than its unrotated\n * box. Paired with `dependsOn: 'children'`, this is what makes a group's\n * bounds track its members.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose.\n *\n * Reads members as rect poses only: a scene whose poses are shaped otherwise\n * gets `null` here and its container keeps its authored pose. To make such a\n * container track its members, register `unionOfChildrenVia(itsDescriptor)`\n * under {@link UNION_OF_CHILDREN} — the consumer's entry wins the collision.\n */\nexport function unionOfChildren<TPose>(\n  _node: unknown,\n  deps: readonly ({ pose: TPose } | undefined)[],\n): TPose | null {\n  const poses: RectPose[] = [];\n  for (const d of deps) {\n    if (d === undefined) continue;\n    const rect = asRectPose(d.pose);\n    if (rect === null) return null;\n    poses.push(rect);\n  }\n  if (poses.length === 0) return null;\n  const union = unionAABB(poses);\n  // Sound by the check above: every member read as a rect, so the union is one\n  // too, and a scene holding rect poses is a scene whose `TPose` is one.\n  return union === null ? null : (union as unknown as TPose);\n}\n\n/** `pose` as a rect, or `null` when it is some other shape entirely. */\nexport function asRectPose(pose: unknown): RectPose | null {\n  if (pose === null || typeof pose !== 'object') return null;\n  const p = pose as Partial<RectPose>;\n  const rect = typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number';\n  return rect ? (pose as RectPose) : null;\n}\n\n/** Merge the kit's own entries under a consumer registry. */\nexport function withKitRegistry<TPose, TData = unknown, TLayer extends string = string>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n): SceneRegistry<TPose, TData, TLayer> {\n  return {\n    ...registry,\n    derivePose: {\n      [UNION_OF_CHILDREN]: unionOfChildren as NonNullable<\n        SceneRegistry<TPose, TData, TLayer>['derivePose']\n      >[string],\n      ...registry.derivePose,\n    },\n  };\n}\n"],"mappings":";;AAaA,IAAaA,IAAoB;AAgBjC,SAAgBC,EACd,GACA,GACc;CACd,IAAMC,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAKC,GAAM;EACpB,IAAID,MAAM,KAAA,GAAW;EACrB,IAAME,IAAOC,EAAWH,EAAE,IAAI;EAC9B,IAAIE,MAAS,MAAM,OAAO;EAC1B,EAAM,KAAKA,CAAI;CACjB;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAMK,IAAQC,EAAUN,CAAK;CAG7B,OAAOK,MAAU,OAAO,OAAQA;AAClC;AAGA,SAAgBD,EAAW,GAAgC;CACzD,IAAqB,OAAOG,KAAS,aAAjCA,GAA2C,OAAO;CACtD,IAAMC,IAAID;CAGV,OAFa,OAAOC,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAClD,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW,WACzCD,IAAoB;AACrC;AAGA,SAAgBE,EACd,GACqC;CACrC,OAAO;EACL,GAAGC;EACH,YAAY;IACTZ,IAAoBC;GAGrB,GAAGW,EAAS;EACd;CACF;AACF"}

package/dist/core/scene/layerStack.js

@@ -0,0 +1,131 @@
+//#region src/core/scene/layerStack.ts
+function e(e) {
+	return {
+		kind: "system",
+		id: e.id,
+		visible: e.visible ?? !0,
+		locked: e.locked ?? !1,
+		...e.parallax ? { parallax: e.parallax } : {}
+	};
+}
+function t(e, t) {
+	function n(n) {
+		e.layers.length = 0, e.layerIndex.clear(), t();
+		for (let t of n) {
+			if (e.layerIndex.has(t.id)) throw Error(`Scene: duplicate ${t.kind} layer id "${t.id}"`);
+			e.layerIndex.set(t.id, e.layers.length), e.layers.push(t);
+		}
+	}
+	function r(t) {
+		let n = e.layerIndex.get(t);
+		if (n === void 0) throw Error(`Scene: unknown layer "${t}"`);
+		return n;
+	}
+	function i() {
+		t(), e.layerIndex.clear();
+		for (let t = 0; t < e.layers.length; t++) e.layerIndex.set(e.layers[t].id, t);
+	}
+	function a(e, t, n, i, a = "place") {
+		if (r(t) < r(i)) {
+			let r = a === "place" ? `cannot place node '${e ?? "<new>"}' on layer '${t}' under parent '${n}' on layer '${i}'` : `cannot setLayer('${e ?? "<new>"}', '${t}') — node has parent '${n}' on layer '${i}'`;
+			throw Error(`Scene: ${r} — a child may not render below its parent's layer`);
+		}
+	}
+	return {
+		reset: n,
+		requireLayerIndex: r,
+		rebuildLayerIndex: i,
+		assertSubtreeLayer: a
+	};
+}
+function n(e, t, n, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let e = 0; e < t.length; e++) i.set(t[e].id, e);
+	for (let t of e.values()) {
+		if (t.parent === null) continue;
+		let a = e.get(t.parent);
+		if (a && i.get(t.layer) < i.get(a.layer)) throw Error(`Scene: moveLayer("${n}", ${r}) — a child may not render below its parent's layer`);
+	}
+}
+function r(e) {
+	let { layers: t, nodes: r, requireLayerIndex: i, record: a } = e;
+	function o(e, n) {
+		let r = t[i(e)];
+		if (r.kind !== "user") throw Error(`Scene: cannot ${n} system layer "${e}"`);
+		return r;
+	}
+	return {
+		setLayerVisible(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerVisible", {
+				layer: e,
+				from: r.visible,
+				to: n
+			}, "setLayerVisible");
+		},
+		setLayerLocked(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerLocked", {
+				layer: e,
+				from: r.locked,
+				to: n
+			}, "setLayerLocked");
+		},
+		setLayerParallax(e, n) {
+			let r = t[i(e)];
+			a("kit:setLayerParallax", {
+				layer: e,
+				from: r.parallax,
+				to: n
+			}, "setLayerParallax");
+		},
+		addLayer(n) {
+			if (e.layerIndex.has(n.id)) throw Error(`Scene: duplicate layer id "${n.id}"`);
+			let r = Math.max(0, Math.min(n.index ?? t.length, t.length)), i = {
+				kind: "user",
+				id: n.id,
+				name: n.name,
+				visible: n.visible ?? !0,
+				locked: n.locked ?? !1,
+				...n.parallax ? { parallax: n.parallax } : {}
+			};
+			a("kit:addLayer", {
+				record: i,
+				index: r
+			}, "addLayer");
+		},
+		removeLayer(t) {
+			let n = o(t, "remove");
+			e.lifted(() => e.batch("removeLayer", () => {
+				let o = [];
+				for (let [e, n] of r) n.layer === t && o.push(e);
+				e.removeMany(o), a("kit:removeLayer", {
+					record: n,
+					index: i(t)
+				}, "removeLayer");
+			}));
+		},
+		renameLayer(e, t) {
+			let n = o(e, "rename");
+			a("kit:renameLayer", {
+				layer: e,
+				from: n.name,
+				to: t
+			}, "renameLayer");
+		},
+		moveLayer(e, o) {
+			let s = i(e), c = Math.max(0, Math.min(o, t.length - 1));
+			if (s === c) return;
+			let l = [...t], [u] = l.splice(s, 1);
+			l.splice(c, 0, u), n(r, l, e, o), a("kit:moveLayer", {
+				layer: e,
+				from: s,
+				to: c
+			}, "moveLayer");
+		}
+	};
+}
+//#endregion
+export { r as createLayerEdits, t as createLayerStack, e as systemLayerRecord };
+
+//# sourceMappingURL=layerStack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layerStack.js","names":["systemLayerRecord","spec","createLayerStack","reset","state","invalidateOrder","record","records","requireLayerIndex","i","layer","rebuildLayerIndex","assertSubtreeLayer","nodeLayer","parentLayer","action","verb","nodeId","parentId","assertOrderKeepsChildrenAbove","place","order","node","nodes","parent","index","createLayerEdits","env","userLayer","rec","layers","visible","locked","parallax","tagged","id","name","from","to","proposed"],"sources":["../../../src/core/scene/layerStack.ts"],"sourcesContent":["/**\n * The scene's layer stack: the ordered layer records, the index from a\n * layer's id to its place in that order, the rule tying a node's layer to\n * its parent's, and the edits a caller makes to the stack.\n */\nimport type { LayerRecord, Node, NodeId, Scene, UseSceneOptions, UserLayerRecord } from './types';\n\n/** What the stack keeps of a scene's state. */\nexport interface LayerStackState<TLayer extends string> {\n  layers: LayerRecord<TLayer>[];\n  layerIndex: Map<TLayer, number>;\n}\n\n/** A declared system layer as the stack holds it. */\nexport function systemLayerRecord<TLayer extends string>(\n  spec: UseSceneOptions<unknown, TLayer, unknown>['systemLayers'][number],\n): LayerRecord<TLayer> {\n  return {\n    kind: 'system',\n    id: spec.id,\n    visible: spec.visible ?? true,\n    locked: spec.locked ?? false,\n    ...(spec.parallax ? { parallax: spec.parallax } : {}),\n  };\n}\n\n/** The reads over `state`'s layers the rest of the scene uses, and the two\n *  ways the stack is rebuilt. It starts empty; `reset` fills it. */\nexport function createLayerStack<TLayer extends string>(\n  state: LayerStackState<TLayer>,\n  /** Called whenever the layer order changes. */\n  invalidateOrder: () => void,\n) {\n  /** Replace the whole stack with `records`, in order. Throws on a duplicate\n   *  id, leaving the stack holding the records before it. */\n  function reset(records: readonly LayerRecord<TLayer>[]): void {\n    state.layers.length = 0;\n    state.layerIndex.clear();\n    invalidateOrder();\n    for (const record of records) {\n      if (state.layerIndex.has(record.id)) {\n        throw new Error(`Scene: duplicate ${record.kind} layer id \"${record.id}\"`);\n      }\n      state.layerIndex.set(record.id, state.layers.length);\n      state.layers.push(record);\n    }\n  }\n\n  function requireLayerIndex(layer: TLayer): number {\n    const i = state.layerIndex.get(layer);\n    if (i === undefined) throw new Error(`Scene: unknown layer \"${layer}\"`);\n    return i;\n  }\n\n  /** Repopulate `state.layerIndex` from the current `state.layers` order.\n   *  Call after any op that inserts, removes, or reorders a layer record. */\n  function rebuildLayerIndex(): void {\n    invalidateOrder();\n    state.layerIndex.clear();\n    for (let i = 0; i < state.layers.length; i++) {\n      state.layerIndex.set(state.layers[i].id, i);\n    }\n  }\n\n  /**\n   * A child may sit on its parent's layer **or any layer above it** (higher\n   * render index) — never below. `renderOrder()` is layer-major\n   * (each node yielded in its OWN layer's pass) and `buildSceneTree` buckets by\n   * each node's own layer, so a child on a higher layer than its parent renders\n   * correctly on top while staying a tree child for hit-testing / move /\n   * reparent (e.g. plantings tagged into a top `plantings` layer while remaining\n   * children of their container). Rejecting only the *below* case keeps the\n   * sensible invariant that a child never paints under its own parent.\n   */\n  function assertSubtreeLayer(\n    nodeId: string | undefined,\n    nodeLayer: TLayer,\n    parentId: NodeId,\n    parentLayer: TLayer,\n    verb: 'place' | 'relayer' = 'place',\n  ): void {\n    if (requireLayerIndex(nodeLayer) < requireLayerIndex(parentLayer)) {\n      const action = verb === 'place'\n        ? `cannot place node '${nodeId ?? '<new>'}' on layer '${nodeLayer}' under parent '${parentId}' on layer '${parentLayer}'`\n        : `cannot setLayer('${nodeId ?? '<new>'}', '${nodeLayer}') — node has parent '${parentId}' on layer '${parentLayer}'`;\n      throw new Error(`Scene: ${action} — a child may not render below its parent's layer`);\n    }\n  }\n\n  return { reset, requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer };\n}\n\n/** What the layer edits read of the scene, and what they record through. */\nexport interface LayerEditsEnv<TData, TLayer extends string, TPose> {\n  layers: readonly LayerRecord<TLayer>[];\n  layerIndex: ReadonlyMap<TLayer, number>;\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  /** Apply a kit op and record it as an edit. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  removeMany(ids: readonly NodeId[]): void;\n}\n\nexport type LayerEdits<TData, TLayer extends string, TPose> = Pick<\n  Scene<TData, TLayer, TPose>,\n  | 'setLayerVisible' | 'setLayerLocked' | 'setLayerParallax'\n  | 'addLayer' | 'removeLayer' | 'renameLayer' | 'moveLayer'\n>;\n\n/** Throw when moving a layer to give `order` would put a child below its parent. */\nfunction assertOrderKeepsChildrenAbove<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n  order: readonly LayerRecord<TLayer>[],\n  layer: TLayer,\n  index: number,\n): void {\n  const place = new Map<TLayer, number>();\n  for (let i = 0; i < order.length; i++) place.set(order[i].id, i);\n  for (const node of nodes.values()) {\n    if (node.parent === null) continue;\n    const parent = nodes.get(node.parent);\n    if (!parent) continue;\n    if (place.get(node.layer)! < place.get(parent.layer)!) {\n      throw new Error(\n        `Scene: moveLayer(\"${layer}\", ${index}) — a child may not render below its parent's layer`,\n      );\n    }\n  }\n}\n\nexport function createLayerEdits<TData, TLayer extends string, TPose>(\n  env: LayerEditsEnv<TData, TLayer, TPose>,\n): LayerEdits<TData, TLayer, TPose> {\n  const { layers, nodes, requireLayerIndex, record } = env;\n\n  function userLayer(layer: TLayer, verb: string): UserLayerRecord<TLayer> {\n    const rec = layers[requireLayerIndex(layer)];\n    if (rec.kind !== 'user') throw new Error(`Scene: cannot ${verb} system layer \"${layer}\"`);\n    return rec;\n  }\n\n  return {\n    setLayerVisible(layer, visible) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerVisible', { layer, from: rec.visible, to: visible }, 'setLayerVisible');\n    },\n\n    setLayerLocked(layer, locked) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerLocked', { layer, from: rec.locked, to: locked }, 'setLayerLocked');\n    },\n\n    setLayerParallax(layer, parallax) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerParallax', { layer, from: rec.parallax, to: parallax }, 'setLayerParallax');\n    },\n\n    addLayer(spec) {\n      if (env.layerIndex.has(spec.id)) throw new Error(`Scene: duplicate layer id \"${spec.id}\"`);\n      const index = Math.max(0, Math.min(spec.index ?? layers.length, layers.length));\n      const layer: UserLayerRecord<TLayer> = {\n        kind: 'user',\n        id: spec.id,\n        name: spec.name,\n        visible: spec.visible ?? true,\n        locked: spec.locked ?? false,\n        ...(spec.parallax ? { parallax: spec.parallax } : {}),\n      };\n      record('kit:addLayer', { record: layer, index }, 'addLayer');\n    },\n\n    removeLayer(layer) {\n      const rec = userLayer(layer, 'remove');\n      // A layer operation, like the lock toggle: taking a locked layer away\n      // takes its nodes with it.\n      env.lifted(() => env.batch('removeLayer', () => {\n        const tagged: NodeId[] = [];\n        for (const [id, node] of nodes) {\n          if (node.layer === layer) tagged.push(id);\n        }\n        env.removeMany(tagged);\n        record('kit:removeLayer', { record: rec, index: requireLayerIndex(layer) }, 'removeLayer');\n      }));\n    },\n\n    renameLayer(layer, name) {\n      const rec = userLayer(layer, 'rename');\n      record('kit:renameLayer', { layer, from: rec.name, to: name }, 'renameLayer');\n    },\n\n    moveLayer(layer, index) {\n      const from = requireLayerIndex(layer);\n      const to = Math.max(0, Math.min(index, layers.length - 1));\n      if (from === to) return;\n      const proposed = [...layers];\n      const [rec] = proposed.splice(from, 1);\n      proposed.splice(to, 0, rec);\n      assertOrderKeepsChildrenAbove(nodes, proposed, layer, index);\n      record('kit:moveLayer', { layer, from, to }, 'moveLayer');\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/layoutPass.js

@@ -1,12 +1,12 @@
-import { IDENTITY_POSE_COMPOSITION as e, composeWorldPose as t, rebaseLocalPose as n } from "./composeFrame.js";
-import { samePoseValue as r } from "./poseSnapshot.js";
-import { definesFrame as i, documentPose as a } from "./effectivePose.js";
-import { asRectPose as o } from "./kitRegistry.js";
+import { composeWorldPose as e, rebaseLocalPose as t } from "./composeFrame.js";
+import { samePoseValue as n } from "./poseSnapshot.js";
+import { definesFrame as r, documentPose as i } from "./effectivePose.js";
+import { asRectPose as a } from "./kitRegistry.js";
 //#region src/core/scene/layoutPass.ts
-function s(t) {
+function o(e) {
 	return {
-		bounds: t?.bounds ?? ((e) => {
-			let t = o(e);
+		bounds: e?.bounds ?? ((e) => {
+			let t = a(e);
 			return t === null ? null : {
 				x: t.x,
 				y: t.y,
@@ -14,83 +14,82 @@ function s(t) {
 				height: t.height
 			};
 		}),
-		remap: t?.remap ?? ((e, t, n) => ({
+		remap: e?.remap ?? ((e, t, n) => ({
 			...e,
 			...n
-		})),
-		composition: t?.composition ?? e
+		}))
 	};
 }
-function c(e, t, n, r) {
+function s(e, t, n, r) {
 	let i = e.bounds(n, t), a = e.bounds(r, t);
 	return i === null || a === null ? i !== a : i.width !== a.width || i.height !== a.height;
 }
-var l = 16;
-function u(e, o, s, u, d, f = /* @__PURE__ */ new Map()) {
-	let p = /* @__PURE__ */ new Map(), m = (t) => p.get(t) ?? a(e, e.get(t)), h = {
+var c = 16;
+function l(a, o, l, u, d, f = /* @__PURE__ */ new Map()) {
+	let p = /* @__PURE__ */ new Map(), m = (e) => p.get(e) ?? i(a, a.get(e)), h = {
 		getPose: (e) => m(e),
-		getParent: (t) => e.get(t)?.parent ?? null,
-		definesFrame: (t) => {
-			let n = e.get(t);
-			return n === void 0 || i(n);
+		getParent: (e) => a.get(e)?.parent ?? null,
+		definesFrame: (e) => {
+			let t = a.get(e);
+			return t === void 0 || r(t);
 		}
-	}, { compose: g, decompose: _ } = d.composition, v = (e) => t(h, e, g), y = [.../* @__PURE__ */ new Set([...s.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (t, n) => {
-		let i = e.get(t), a = m(t);
-		r(a, n) || (p.set(t, n), t !== S && i.kind === "container" && o(t) !== null && c(d, t, a, n) && y.push(t));
-	}, S = null, C = (t) => {
-		let n = v(t), r = d.bounds(n, t);
-		if (r === null) return null;
-		let i = e.childrenOf(t).map((e) => ({
+	}, { compose: g, decompose: _ } = a.composition, v = (t) => e(h, t, g), y = [.../* @__PURE__ */ new Set([...l.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (e, t) => {
+		let r = a.get(e), i = m(e);
+		n(i, t) || (p.set(e, t), e !== S && r.kind === "container" && o(e) !== null && s(d, e, i, t) && y.push(e));
+	}, S = null, C = (e) => {
+		let t = v(e), n = d.bounds(t, e);
+		if (n === null) return null;
+		let r = a.childrenOf(e).map((e) => ({
 			id: e,
 			pose: v(e)
 		}));
 		return {
-			world: n,
+			world: t,
 			container: {
-				id: t,
-				bounds: r
+				id: e,
+				bounds: n
 			},
-			children: i
+			children: r
 		};
-	}, w = (t, r, i) => {
-		if (i.bounds) {
-			let a = e.get(t), o = d.remap(r.world, r.container.bounds, i.bounds, t);
-			x(t, n(h, o, a.parent, g, _));
+	}, w = (e, n, r) => {
+		if (r.bounds) {
+			let i = a.get(e), o = d.remap(n.world, n.container.bounds, r.bounds, e);
+			x(e, t(h, o, i.parent, g, _));
 		}
-		for (let [r, a] of i.poses) {
-			let i = r;
-			e.get(i)?.parent === t && x(i, n(h, a, t, g, _));
+		for (let [n, i] of r.poses) {
+			let r = n;
+			a.get(r)?.parent === e && x(r, t(h, i, e, g, _));
 		}
 	};
 	for (; y.length > 0;) {
-		let t = y.shift();
-		S = t;
-		let n = (b.get(t) ?? 0) + 1;
-		if (b.set(t, n), n > l) continue;
-		let r = o(t);
-		if (r === null || e.get(t) === void 0) continue;
-		let i = n === 1 ? s.get(t) : void 0, a = n === 1 ? f.get(t) : void 0, c = !1;
-		if (a !== void 0 && r.depart) {
-			let e = C(t);
-			if (e === null) continue;
-			let n = new Set(i ?? []), o = e.children.filter((e) => !n.has(e.id));
-			w(t, e, r.depart(e.container, o, new Set(a))), c = !0;
+		let e = y.shift();
+		S = e;
+		let t = (b.get(e) ?? 0) + 1;
+		if (b.set(e, t), t > c) continue;
+		let n = o(e);
+		if (n === null || a.get(e) === void 0) continue;
+		let r = t === 1 ? l.get(e) : void 0, i = t === 1 ? f.get(e) : void 0, s = !1;
+		if (i !== void 0 && n.depart) {
+			let t = C(e);
+			if (t === null) continue;
+			let a = new Set(r ?? []), o = t.children.filter((e) => !a.has(e.id));
+			w(e, t, n.depart(t.container, o, new Set(i))), s = !0;
 		}
-		if (i !== void 0 && r.arrive) {
-			let e = C(t);
-			if (e === null) continue;
-			let n = r.arrive(e.container, e.children, new Set(i));
-			if (n === null) return null;
-			w(t, e, n);
-		} else if (!c || i !== void 0) {
-			let e = C(t);
-			if (e === null) continue;
-			w(t, e, { poses: r.childPoses(e.container, e.children) });
+		if (r !== void 0 && n.arrive) {
+			let t = C(e);
+			if (t === null) continue;
+			let i = n.arrive(t.container, t.children, new Set(r));
+			if (i === null) return null;
+			w(e, t, i);
+		} else if (!s || r !== void 0) {
+			let t = C(e);
+			if (t === null) continue;
+			w(e, t, { poses: n.childPoses(t.container, t.children) });
 		}
 	}
 	return p;
 }
 //#endregion
-export { c as resized, s as resolveLayoutFrame, u as runLayoutPass };
+export { s as resized, o as resolveLayoutFrame, l as runLayoutPass };
 
 //# sourceMappingURL=layoutPass.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","IDENTITY_POSE_COMPOSITION","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n  composition: PoseComposition<TPose>;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n    composition: frame?.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = frame.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;;AA8CA,SAAgBA,EAA0B,GAAmE;CAC3G,OAAO;EACL,QAAQC,GAAO,YAAY,MAAS;GAClC,IAAMC,IAAIC,EAAWC,CAAI;GACzB,OAAOF,MAAM,OAAO,OAAO;IAAE,GAAGA,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;EAChF;EACA,OAAOD,GAAO,WAAW,GAAM,GAAO,OAAQ;GAAE,GAAIG;GAAiB,GAAGC;EAAG;EAC3E,aAAaJ,GAAO,eAAgBK;CACtC;AACF;AAGA,SAAgBC,EAAe,GAAmC,GAAY,GAAa,GAAoB;CAC7G,IAAMC,IAAIP,EAAM,OAAOQ,GAAMC,CAAE,GACzBC,IAAIV,EAAM,OAAOI,GAAIK,CAAE;CAE7B,OADIF,MAAM,QAAQG,MAAM,OAAaH,MAAMG,IACpCH,EAAE,UAAUG,EAAE,SAASH,EAAE,WAAWG,EAAE;AAC/C;AAIA,IAAMC,IAAa;AAEnB,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,oBAAqD,IAAI,IAAI,GACpC;CAGzB,IAAMC,oBAAM,IAAI,IAAmB,GAC7BC,KAAU,MAAsBD,EAAI,IAAIJ,CAAE,KAAKM,EAAaC,GAAQA,EAAO,IAAIP,CAAE,CAAE,GACnFQ,IAAyB;EAC7B,UAAU,MAAOH,EAAOL,CAAY;EACpC,YAAY,MAAOO,EAAO,IAAIP,CAAY,CAAC,EAAE,UAAU;EACvD,eAAe,MAAO;GACpB,IAAMS,IAAOF,EAAO,IAAIP,CAAY;GACpC,OAAOS,MAAS,KAAA,KAAaC,EAAaD,CAAI;EAChD;CACF,GACM,EAAE,YAAS,iBAAclB,EAAM,aAC/BoB,KAAS,MAAsBC,EAAiBJ,GAAIR,GAAIa,CAAO,GAE/DC,IAAkB,CAAC,mBAAG,IAAI,IAAY,CAAC,GAAGC,EAAS,KAAK,GAAG,GAAGC,CAAO,CAAC,CAAC,GACvEC,oBAAS,IAAI,IAAoB,GACjCC,KAAS,GAAY,MAAsB;EAC/C,IAAMT,IAAOF,EAAO,IAAIP,CAAE,GACpBmB,IAASd,EAAOL,CAAE;EACxB,AAAIoB,EAAcD,GAAQzB,CAAI,MAC9BU,EAAI,IAAIJ,GAAIN,CAAI,GAEZM,MAAOqB,KAAWZ,EAAK,SAAS,eAAea,EAAStB,CAAE,MAAM,QAC/DH,EAAQN,GAAOS,GAAImB,GAAQzB,CAAI,KAAGoB,EAAM,KAAKd,CAAE;CACtD,GACIqB,IAAyB,MAIvBE,KAAW,MAAwB;EACvC,IAAM7B,IAAOiB,EAAMa,CAAW,GACxBC,IAASlC,EAAM,OAAOG,GAAM8B,CAAW;EAC7C,IAAIC,MAAW,MAAM,OAAO;EAC5B,IAAMC,IAAiCnB,EAAO,WAAWiB,CAAW,CAAC,CAAC,KAAK,OAAS;GAClF,IAAIG;GACJ,MAAMhB,EAAMgB,CAAG;EACjB,EAAE;EACF,OAAO;GAAE,OAAOjC;GAAM,WAAW;IAAE,IAAI8B;IAAuB;GAAO;GAAG;EAAS;CACnF,GACMI,KACJ,GACA,GACA,MACS;EACT,IAAIC,EAAO,QAAQ;GACjB,IAAMpB,IAAOF,EAAO,IAAIiB,CAAW,GAC7BM,IAAQvC,EAAM,MAAMwC,EAAG,OAAOA,EAAG,UAAU,QAAQF,EAAO,QAAQL,CAAW;GACnF,EAAMA,GAAaQ,EAAgBxB,GAAIsB,GAAOrB,EAAK,QAAQI,GAASoB,CAAS,CAAC;EAChF;EACA,KAAK,IAAM,CAACN,GAAKjC,MAASmC,EAAO,OAAO;GACtC,IAAM7B,IAAK2B;GACX,AAAIpB,EAAO,IAAIP,CAAE,CAAC,EAAE,WAAWwB,KAC/BN,EAAMlB,GAAIgC,EAAgBxB,GAAId,GAAM8B,GAAaX,GAASoB,CAAS,CAAC;EACtE;CACF;CAEA,OAAOnB,EAAM,SAAS,IAAG;EACvB,IAAMU,IAAcV,EAAM,MAAM;EAChC,IAAUU;EACV,IAAM,KAAKP,EAAO,IAAIO,CAAW,KAAK,KAAK;EAE3C,IADAP,EAAO,IAAIO,GAAa,CAAC,GACrB,IAAItB,GAAY;EACpB,IAAMgC,IAASZ,EAASE,CAAW;EACnC,IAAIU,MAAW,QAAQ3B,EAAO,IAAIiB,CAAW,MAAM,KAAA,GAAW;EAC9D,IAAMW,IAAS,MAAM,IAAIpB,EAAS,IAAIS,CAAW,IAAI,KAAA,GAC/CY,IAAO,MAAM,IAAIC,EAAW,IAAIb,CAAW,IAAI,KAAA,GACjDc,IAAW;EACf,IAAIF,MAAS,KAAA,KAAaF,EAAO,QAAQ;GACvC,IAAMH,IAAKR,EAAQC,CAAW;GAC9B,IAAIO,MAAO,MAAM;GACjB,IAAMQ,IAAY,IAAI,IAAYJ,KAAU,CAAC,CAAC,GACxCK,IAAUT,EAAG,SAAS,QAAQ,MAAM,CAACQ,EAAU,IAAIE,EAAE,EAAE,CAAC;GAE9D,AADAb,EAAMJ,GAAaO,GAAIG,EAAO,OAAOH,EAAG,WAAWS,GAAS,IAAI,IAAYJ,CAAI,CAAC,CAAC,GAClF,IAAW;EACb;EACA,IAAID,MAAW,KAAA,KAAaD,EAAO,QAAQ;GACzC,IAAMH,IAAKR,EAAQC,CAAW;GAC9B,IAAIO,MAAO,MAAM;GACjB,IAAMF,IAASK,EAAO,OAAOH,EAAG,WAAWA,EAAG,UAAU,IAAI,IAAYI,CAAM,CAAC;GAC/E,IAAIN,MAAW,MAAM,OAAO;GAC5B,EAAML,GAAaO,GAAIF,CAAM;EAC/B,OAAO,IAAI,CAACS,KAAYH,MAAW,KAAA,GAAW;GAC5C,IAAMJ,IAAKR,EAAQC,CAAW;GAC9B,IAAIO,MAAO,MAAM;GACjB,EAAMP,GAAaO,GAAI,EAAE,OAAOG,EAAO,WAAWH,EAAG,WAAWA,EAAG,QAAQ,EAAE,CAAC;EAChF;CACF;CACA,OAAO3B;AACT"}
+{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","n","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n  readonly composition: PoseComposition<TPose>;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = source.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/core/scene/lockGuard.js

@@ -0,0 +1,37 @@
+//#region src/core/scene/lockGuard.ts
+function e(e) {
+	let t = 0;
+	function n(t) {
+		if (!e.layers.some((e) => e.locked)) return !1;
+		let n = e.nodes.get(t);
+		for (; n !== void 0;) {
+			if (e.layers[e.layerIndex.get(n.layer) ?? -1]?.locked) return !0;
+			n = n.parent === null ? void 0 : e.nodes.get(n.parent);
+		}
+		return !1;
+	}
+	return {
+		isLocked: n,
+		refuse(e, r) {
+			if (!(t > 0 || !n(e))) throw Error(`Scene: cannot ${r} "${e}" — it is on a locked layer`);
+		},
+		refuseLayer(n, r) {
+			if (!(t > 0 || !e.layers[e.layerIndex.get(n) ?? -1]?.locked)) throw Error(`Scene: cannot ${r} layer "${n}" — it is locked`);
+		},
+		reachable(t) {
+			return e.layers.some((e) => e.locked) ? t.filter((e) => !n(e)) : t;
+		},
+		lifted(e) {
+			t++;
+			try {
+				return e();
+			} finally {
+				t--;
+			}
+		}
+	};
+}
+//#endregion
+export { e as createLockGuard };
+
+//# sourceMappingURL=lockGuard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lockGuard.js","names":["createLockGuard","bypass","isLocked","state","l","cur","id","verb","layer","ids","fn"],"sources":["../../../src/core/scene/lockGuard.ts"],"sourcesContent":["/**\n * The scene's lock guard: what a locked layer refuses, and how a caller that\n * is restoring an already-legal state gets past it.\n */\nimport type { Node, NodeId } from './types';\n\n/** What the guard reads of a scene's state. */\nexport interface LockGuardState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  layers: { locked: boolean }[];\n  layerIndex: Map<TLayer, number>;\n}\n\nexport interface LockGuard<TLayer extends string> {\n  /** Whether `id` sits on a locked layer, or inside a node that does. */\n  isLocked(id: NodeId): boolean;\n  /** Throw when `id` is locked and the guard is not lifted. */\n  refuse(id: NodeId, verb: string): void;\n  /** Throw when `layer` is locked and the guard is not lifted. */\n  refuseLayer(layer: TLayer, verb: string): void;\n  /** `ids` less the locked ones: the scene's selection never holds a locked\n   *  node, whoever writes it. */\n  reachable(ids: readonly NodeId[]): readonly NodeId[];\n  /** Run `fn` with the guard lifted: `unlocked()`, `removeLayer`, and every\n   *  replay — undo, redo, a journal stepping, a rollback — which restores a\n   *  state that was legal when it was recorded. */\n  lifted<T>(fn: () => T): T;\n}\n\nexport function createLockGuard<TData, TLayer extends string, TPose>(\n  state: LockGuardState<TData, TLayer, TPose>,\n): LockGuard<TLayer> {\n  let bypass = 0;\n\n  function isLocked(id: NodeId): boolean {\n    if (!state.layers.some((l) => l.locked)) return false;\n    let cur = state.nodes.get(id);\n    while (cur !== undefined) {\n      if (state.layers[state.layerIndex.get(cur.layer) ?? -1]?.locked) return true;\n      cur = cur.parent === null ? undefined : state.nodes.get(cur.parent);\n    }\n    return false;\n  }\n\n  return {\n    isLocked,\n    refuse(id, verb) {\n      if (bypass > 0 || !isLocked(id)) return;\n      throw new Error(`Scene: cannot ${verb} \"${id}\" — it is on a locked layer`);\n    },\n    refuseLayer(layer, verb) {\n      if (bypass > 0 || !state.layers[state.layerIndex.get(layer) ?? -1]?.locked) return;\n      throw new Error(`Scene: cannot ${verb} layer \"${layer}\" — it is locked`);\n    },\n    reachable(ids) {\n      if (!state.layers.some((l) => l.locked)) return ids;\n      return ids.filter((id) => !isLocked(id));\n    },\n    lifted(fn) {\n      bypass++;\n      try {\n        return fn();\n      } finally {\n        bypass--;\n      }\n    },\n  };\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACmB;CACnB,IAAIC,IAAS;CAEb,SAASC,EAAS,GAAqB;EACrC,IAAI,CAACC,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,GAAG,OAAO;EAChD,IAAIC,IAAMF,EAAM,MAAM,IAAIG,CAAE;EAC5B,OAAOD,MAAQ,KAAA,IAAW;GACxB,IAAIF,EAAM,OAAOA,EAAM,WAAW,IAAIE,EAAI,KAAK,KAAK,GAAG,EAAE,QAAQ,OAAO;GACxE,IAAMA,EAAI,WAAW,OAAO,KAAA,IAAYF,EAAM,MAAM,IAAIE,EAAI,MAAM;EACpE;EACA,OAAO;CACT;CAEA,OAAO;EACL;EACA,OAAO,GAAI,GAAM;GACf,IAAI,MAAS,KAAK,CAACH,EAASI,CAAE,IAC9B,MAAU,MAAM,iBAAiBC,EAAK,IAAID,EAAG,4BAA4B;EAC3E;EACA,YAAY,GAAO,GAAM;GACvB,IAAI,MAAS,KAAK,CAACH,EAAM,OAAOA,EAAM,WAAW,IAAIK,CAAK,KAAK,GAAG,EAAE,SACpE,MAAU,MAAM,iBAAiBD,EAAK,UAAUC,EAAM,iBAAiB;EACzE;EACA,UAAU,GAAK;GAEb,OADKL,EAAM,OAAO,MAAM,MAAMC,EAAE,MAAM,IAC/BK,EAAI,QAAQ,MAAO,CAACP,EAASI,CAAE,CAAC,IADSG;EAElD;EACA,OAAO,GAAI;GACT;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IACR;GACF;EACF;CACF;AACF"}

package/dist/{features/groups → core/scene}/nestedHit.js

@@ -1,7 +1,7 @@
 import { worldPoseLookup as e } from "./composePose.js";
-import { poseDescriptorForNode as t } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-//#region src/features/groups/nestedHit.ts
+import { poseDescriptorForNode as t } from "../geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as n } from "../geometry/autoPoseDescriptor.js";
+//#region src/core/scene/nestedHit.ts
 function r(r, i) {
 	let a = i.poseDescriptor ?? n, o = i.isGroup ?? (() => !1), s = e(r, i.composePose), c = (e) => {
 		let t = [], n = e;

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

@@ -0,0 +1 @@
+{"version":3,"file":"nestedHit.js","names":["nestedHitTester","d","opts","AUTO_POSE_DESCRIPTOR","isGroup","worldOf","worldPoseLookup","adapter","ancestorChain","chain","cur","id","hitLeaf","objs","i","o","w","b","poseDescriptorForNode","wx","wy","leaf","alt","selection"],"sources":["../../../src/core/scene/nestedHit.ts"],"sourcesContent":["import { worldPoseLookup } from 'core/scene/composePose';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\n\n/** @internal */\ninterface HitAdapter<TNode extends { id: string }, TPose> {\n  getNode: (id: string) => TNode | undefined;\n  getNodes: () => TNode[];\n  getPose: (id: string) => TPose;\n  getParent: (id: string) => string | null;\n}\n\n/** Options for `nestedHitTester`. */\nexport interface NestedHitOpts<TNode extends { id: string }, TPose> {\n  /** Compose a child's local pose into world coords given its parent's world\n   *  pose. Same shape as `composeRectPose` (the default expectation). */\n  composePose: (parent: TPose, child: TPose) => TPose;\n  /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Predicate for \"this object is a nesting parent body\". The leaf scan\n   *  skips objects for which this returns true so a click on a parent's\n   *  painted body resolves to a child leaf, not the parent itself. Default:\n   *  never (treat every object as hittable). */\n  isGroup?: (id: string, obj: TNode | undefined) => boolean;\n}\n\n/** Hit-test entry points for a nested scene: one that always picks the\n *  outermost ancestor, and one that steps deeper on alt-click. */\nexport interface NestedHitTester {\n  /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a\n   *  casual click selects the whole top-level ancestor. Returns `null` on\n   *  empty space. */\n  pickOutermost: (worldX: number, worldY: number) => string | null;\n  /** Alt-aware selection-update pick. Without `alt`, returns the outermost\n   *  ancestor (same as `pickOutermost`). With `alt`, returns one level\n   *  deeper than the deepest currently-selected ancestor in the leaf's\n   *  chain — repeated alt-clicks step ancestor → descendant → leaf. With\n   *  `alt` and nothing in the chain selected, jumps straight to the leaf.\n   *  Plug into `useSelectTool({ pickBest })`. */\n  pickBest: (\n    worldX: number,\n    worldY: number,\n    alt: boolean,\n    selection: readonly string[],\n  ) => string | null;\n}\n\n/** Build hit-testers that respect containers: a plain click selects the\n *  top-level ancestor, and alt-clicking descends one level at a time toward\n *  the leaf actually under the pointer. */\nexport function nestedHitTester<TNode extends { id: string }, TPose>(\n  adapter: HitAdapter<TNode, TPose>,\n  opts: NestedHitOpts<TNode, TPose>,\n): NestedHitTester {\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const isGroup = opts.isGroup ?? (() => false);\n  const worldOf = worldPoseLookup(adapter, opts.composePose);\n\n  const ancestorChain = (id: string): string[] => {\n    const chain: string[] = [];\n    let cur: string | null = id;\n    while (cur !== null) {\n      chain.unshift(cur);\n      cur = adapter.getParent(cur);\n    }\n    return chain;\n  };\n\n  const hitLeaf = (wx: number, wy: number): string | null => {\n    const objs = adapter.getNodes();\n    for (let i = objs.length - 1; i >= 0; i--) {\n      const o = objs[i];\n      if (isGroup(o.id, o)) continue;\n      const w = worldOf(o.id);\n      if (!w) continue;\n      const b = poseDescriptorForNode(d, o).getBounds(w);\n      if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {\n        return o.id;\n      }\n    }\n    return null;\n  };\n\n  const pickOutermost = (wx: number, wy: number): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    return leaf === null ? null : ancestorChain(leaf)[0];\n  };\n\n  const pickBest = (\n    wx: number,\n    wy: number,\n    alt: boolean,\n    selection: readonly string[],\n  ): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    if (leaf === null) return null;\n    const chain = ancestorChain(leaf);\n    if (!alt) return chain[0];\n    for (let i = chain.length - 1; i >= 0; i--) {\n      if (selection.includes(chain[i])) {\n        return chain[Math.min(i + 1, chain.length - 1)];\n      }\n    }\n    return chain[chain.length - 1];\n  };\n\n  return { pickOutermost, pickBest };\n}\n"],"mappings":";;;;AAkDA,SAAgBA,EACd,GACA,GACiB;CACjB,IAAMC,IAAKC,EAAK,kBAAkBC,GAC5BC,IAAUF,EAAK,kBAAkB,KACjCG,IAAUC,EAAgBC,GAASL,EAAK,WAAW,GAEnDM,KAAiB,MAAyB;EAC9C,IAAMC,IAAkB,CAAC,GACrBC,IAAqBC;EACzB,OAAOD,MAAQ,OAEb,AADAD,EAAM,QAAQC,CAAG,GACjB,IAAMH,EAAQ,UAAUG,CAAG;EAE7B,OAAOD;CACT,GAEMG,KAAW,GAAY,MAA8B;EACzD,IAAMC,IAAON,EAAQ,SAAS;EAC9B,KAAK,IAAIO,IAAID,EAAK,SAAS,GAAGC,KAAK,GAAG,KAAK;GACzC,IAAMC,IAAIF,EAAKC;GACf,IAAIV,EAAQW,EAAE,IAAIA,CAAC,GAAG;GACtB,IAAMC,IAAIX,EAAQU,EAAE,EAAE;GACtB,IAAI,CAACC,GAAG;GACR,IAAMC,IAAIC,EAAsBjB,GAAGc,CAAC,CAAC,CAAC,UAAUC,CAAC;GACjD,IAAIG,KAAMF,EAAE,KAAKE,KAAMF,EAAE,IAAIA,EAAE,SAASG,KAAMH,EAAE,KAAKG,KAAMH,EAAE,IAAIA,EAAE,QACjE,OAAOF,EAAE;EAEb;EACA,OAAO;CACT;CAyBA,OAAO;EAAE,gBAvBc,GAAY,MAA8B;GAC/D,IAAMM,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,OAAOC,MAAS,OAAO,OAAOb,EAAca,CAAI,CAAC,CAAC;EACpD;EAoBwB,WAjBtB,GACA,GACA,GACA,MACkB;GAClB,IAAMA,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,IAAIC,MAAS,MAAM,OAAO;GAC1B,IAAMZ,IAAQD,EAAca,CAAI;GAChC,IAAI,CAACC,GAAK,OAAOb,EAAM;GACvB,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAIS,EAAU,SAASd,EAAMK,EAAE,GAC7B,OAAOL,EAAM,KAAK,IAAIK,IAAI,GAAGL,EAAM,SAAS,CAAC;GAGjD,OAAOA,EAAMA,EAAM,SAAS;EAC9B;CAEiC;AACnC"}

package/dist/core/scene/nodeFnFields.js

@@ -29,20 +29,19 @@ var e = [
 		lost: "layout"
 	}
 ];
-function t(t) {
+function t(t, n) {
 	return e.map((e) => {
-		let n = t[e.field], r = /* @__PURE__ */ new Map();
-		if (n) for (let [e, t] of Object.entries(n)) r.set(t, e);
-		let i = /* @__PURE__ */ new Map(), a = (t) => !e.containersOnly || t.kind === "container";
+		let r = t[e.field], i = /* @__PURE__ */ new Map();
+		if (r) for (let [e, t] of Object.entries(r)) i.set(t, e);
+		let a = (t) => !e.containersOnly || t.kind === "container";
 		return {
 			spec: e,
-			keyOf: (e) => r.get(e),
-			fnOf: (e) => n?.[e],
+			keyOf: (e) => i.get(e),
+			fnOf: (e) => r?.[e],
 			read: (t) => a(t) ? t[e.field] : void 0,
-			write: (t, n) => {
-				a(t) && (t[e.field] = n);
-			},
-			pending: i
+			write: (t, r) => {
+				a(t) && (t[e.field] = r, n?.(e.field, t));
+			}
 		};
 	});
 }
@@ -52,7 +51,7 @@ function n(e, t, n, r, i) {
 		i("scene", `${r}: ${e.spec.opKey} "${n}" not in this scene's registry — node "${t.id}" restored without its ${e.spec.lost}. Register a function with this key in the registry option to restore it.`);
 		return;
 	}
-	e.write(t, a), e.pending.set(t.id, a);
+	e.write(t, a);
 }
 function r(e, t, n, r) {
 	let i = {};

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

@@ -1 +1 @@
-{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","pending","applies","node","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * `clipFromPose`, `derivePath` and `derivePose` are live functions on a node,\n * and a function travels through neither a serializable op payload nor a JSON\n * snapshot. Each one therefore needs the same six things: a function→key\n * reverse map, a side-channel cache the `kit:add` redo path re-attaches from,\n * a name in the op payload, a name in the snapshot, a registry lookup on\n * restore, and a prune when history evicts the entry that could reach it.\n *\n * The first two fields were written out twice, and `types.ts` said in a\n * comment that a third should be the point it stopped being copied per field.\n * This is that point.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. Each field's real signature lives on `Node`.\n *  A container's `layout` is an object rather than a function, and rides the\n *  same table for the same reason — it travels by reference, not as data. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the three fields on it. The\n *  full `Node` type would make the table generic in `TData`/`TLayer` for no\n *  gain; nothing here looks at either. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n  /** The redo side-channel: `kit:add` replays without the original spec, so\n   *  the function it should re-attach is cached here by node id. */\n  readonly pending: Map<NodeId, NodeFn>;\n}\n\nexport function createNodeFnFields<TPose>(registry: SceneRegistry<TPose>): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const pending = new Map<NodeId, NodeFn>();\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (applies(node)) node[spec.field] = fn;\n      },\n      pending,\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`, seeding the redo cache so later\n * undo/redo cycles behave like the live path. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n  field.pending.set(node.id, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AA8CA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAmBA,SAAgBC,EAA0B,GAAwD;CAChG,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,oBAAU,IAAI,IAAoB,GAClCC,KAAW,MACf,CAACL,EAAK,kBAAkBM,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOL,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUG,EAAQC,CAAI,IAAIA,EAAKN,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAIK,EAAQC,CAAI,MAAG,EAAKN,EAAK,SAASG;GACxC;GACA;EACF;CACF,CAAC;AACH;AAQA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCI,EAAK,GAAG,yBAC5DE,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CAEA,AADAA,EAAM,MAAMF,GAAMH,CAAE,GACpBK,EAAM,QAAQ,IAAIF,EAAK,IAAIH,CAAE;AAC/B;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKF,CAAI;EAC1B,IAAIH,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMT,GACNK,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBM,EAAK,SAAS,aAAa;EACtD,IAAMH,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}
+{"version":3,"file":"nodeFnFields.js","names":["NODE_FN_FIELDS","createNodeFnFields","table","registry","spec","reverse","key","fn","applies","node","onWrite","restoreFn","field","site","fnKeysOf","out","fields","which","fnFieldsOfNode","src"],"sources":["../../../src/core/scene/nodeFnFields.ts"],"sourcesContent":["/**\n * The registry-keyed function fields a node can carry, as a table.\n *\n * These fields are live functions on a node, and a function travels through\n * neither a serializable op payload nor a JSON snapshot. Each one therefore\n * needs the same things: a function→key reverse map, a name in the op\n * payload, a name in the snapshot, and a registry lookup on restore.\n */\nimport type { NodeId, SceneRegistry } from './types';\n\n/** A node's function field, opaque here: the table moves these around by\n *  reference and never calls one. A container's `layout` is an object rather\n *  than a function, and rides the same table for the same reason. */\nexport type NodeFn = ((...args: never[]) => unknown) | object;\n\n/** A node as this module reads it — a bag with the function fields on it. */\nexport type FnBearingNode = { id: NodeId; kind: 'leaf' | 'container' } & {\n  [K in NodeFnFieldName]?: NodeFn;\n};\n\nexport type NodeFnFieldName = 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout';\n\nexport interface NodeFnFieldSpec {\n  /** The field's name on `Node` — and, deliberately, its name in\n   *  `SceneRegistry` too, so one string indexes both. */\n  readonly field: NodeFnFieldName;\n  /** Its key in the `kit:add` and `kit:remove` op payloads. `clipFromPose`'s\n   *  is the short one because a persisted history already carries that name. */\n  readonly opKey: string;\n  /** Its key in a `SerializedNode`. */\n  readonly jsonKey: string;\n  /** True for a field only a `ContainerNode` can carry. */\n  readonly containersOnly: boolean;\n  /** What a node loses when its key is not in the registry, for the warning. */\n  readonly lost: string;\n}\n\nexport const NODE_FN_FIELDS: readonly NodeFnFieldSpec[] = [\n  {\n    field: 'clipFromPose',\n    opKey: 'clipKey',\n    jsonKey: 'clipFromPoseKey',\n    containersOnly: true,\n    lost: 'clip',\n  },\n  {\n    field: 'derivePath',\n    opKey: 'derivePathKey',\n    jsonKey: 'derivePathKey',\n    containersOnly: false,\n    lost: 'derived path',\n  },\n  {\n    field: 'derivePose',\n    opKey: 'derivePoseKey',\n    jsonKey: 'derivePoseKey',\n    containersOnly: false,\n    lost: 'derived pose',\n  },\n  {\n    field: 'layout',\n    opKey: 'layoutKey',\n    jsonKey: 'layoutKey',\n    containersOnly: true,\n    lost: 'layout',\n  },\n];\n\n/** One field's per-scene state. */\nexport interface NodeFnField {\n  readonly spec: NodeFnFieldSpec;\n  /** `fn → registry key`, for writing a payload or a snapshot. */\n  keyOf(fn: NodeFn): string | undefined;\n  /** `registry key → fn`, for restoring one. */\n  fnOf(key: string): NodeFn | undefined;\n  /** The function on `node`, or `undefined` — including when the field is\n   *  container-only and `node` is a leaf. */\n  read(node: FnBearingNode): NodeFn | undefined;\n  /** Attach `fn` to `node`, ignoring a container-only field on a leaf. */\n  write(node: FnBearingNode, fn: NodeFn): void;\n}\n\nexport function createNodeFnFields<TPose>(\n  registry: SceneRegistry<TPose>,\n  /** Called after a field is written onto a node it applies to. */\n  onWrite?: (field: NodeFnFieldName, node: FnBearingNode) => void,\n): readonly NodeFnField[] {\n  return NODE_FN_FIELDS.map((spec) => {\n    const table = registry[spec.field] as Readonly<Record<string, NodeFn>> | undefined;\n    const reverse = new Map<NodeFn, string>();\n    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);\n    const applies = (node: FnBearingNode): boolean =>\n      !spec.containersOnly || node.kind === 'container';\n    return {\n      spec,\n      keyOf: (fn) => reverse.get(fn),\n      fnOf: (key) => table?.[key],\n      read: (node) => (applies(node) ? node[spec.field] : undefined),\n      write: (node, fn) => {\n        if (!applies(node)) return;\n        node[spec.field] = fn;\n        onWrite?.(spec.field, node);\n      },\n    };\n  });\n}\n\n/**\n * Attach the function `key` names to `node`. Warns and leaves the field\n * unset when the key is not in this scene's registry — a snapshot outliving\n * the code that registered its functions must still load.\n */\nexport function restoreFn(\n  field: NodeFnField,\n  node: FnBearingNode,\n  key: string,\n  site: string,\n  warn: (channel: string, message: string) => void,\n): void {\n  const fn = field.fnOf(key);\n  if (fn === undefined) {\n    warn(\n      'scene',\n      `${site}: ${field.spec.opKey} \"${key}\" not in this scene's registry — node \"${node.id}\" ` +\n        `restored without its ${field.spec.lost}. Register a function with this key in the ` +\n        `registry option to restore it.`,\n    );\n    return;\n  }\n  field.write(node, fn);\n}\n\n/** The `{ clipKey?, derivePathKey?, … }` an op payload or a snapshot carries\n *  for `node`. Empty when the node has no keyed function on it. */\nexport function fnKeysOf(\n  fields: readonly NodeFnField[],\n  node: FnBearingNode,\n  which: 'opKey' | 'jsonKey',\n  onUnregistered?: (field: NodeFnField) => never,\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const field of fields) {\n    const fn = field.read(node);\n    if (fn === undefined) continue;\n    const key = field.keyOf(fn);\n    if (key === undefined) {\n      onUnregistered?.(field);\n      continue;\n    }\n    out[field.spec[which]] = key;\n  }\n  return out;\n}\n\n/**\n * The function fields to carry from a live node into an `AddNodeSpec`. An\n * insert that drops them brings an edge back as a static path that never\n * follows its endpoints again, and a clipped container back with nothing\n * clipped.\n */\nexport function fnFieldsOfNode<T extends { kind: 'leaf' | 'container' }>(\n  node: T,\n): Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>> {\n  const src = node as Record<string, unknown>;\n  const out: Record<string, unknown> = {};\n  for (const spec of NODE_FN_FIELDS) {\n    if (spec.containersOnly && node.kind !== 'container') continue;\n    const fn = src[spec.field];\n    if (fn !== undefined) out[spec.field] = fn;\n  }\n  return out as Partial<Pick<T, Extract<NodeFnFieldName, keyof T>>>;\n}\n"],"mappings":";AAqCA,IAAaA,IAA6C;CACxD;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;CACA;EACE,OAAO;EACP,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,MAAM;CACR;AACF;AAgBA,SAAgBC,EACd,GAEA,GACwB;CACxB,OAAOD,EAAe,KAAK,MAAS;EAClC,IAAME,IAAQC,EAASC,EAAK,QACtBC,oBAAU,IAAI,IAAoB;EACxC,IAAIH,GAAO,KAAK,IAAM,CAACI,GAAKC,MAAO,OAAO,QAAQL,CAAK,GAAG,EAAQ,IAAIK,GAAID,CAAG;EAC7E,IAAME,KAAW,MACf,CAACJ,EAAK,kBAAkBK,EAAK,SAAS;EACxC,OAAO;GACL;GACA,QAAQ,MAAOJ,EAAQ,IAAIE,CAAE;GAC7B,OAAO,MAAQL,IAAQI;GACvB,OAAO,MAAUE,EAAQC,CAAI,IAAIA,EAAKL,EAAK,SAAS,KAAA;GACpD,QAAQ,GAAM,MAAO;IACnB,AAAKI,EAAQC,CAAI,MACjB,EAAKL,EAAK,SAASG,GACnBG,IAAUN,EAAK,OAAOK,CAAI;GAC5B;EACF;CACF,CAAC;AACH;AAOA,SAAgBE,EACd,GACA,GACA,GACA,GACA,GACM;CACN,IAAMJ,IAAKK,EAAM,KAAKN,CAAG;CACzB,IAAIC,MAAO,KAAA,GAAW;EACpB,EACE,SACA,GAAGM,EAAK,IAAID,EAAM,KAAK,MAAM,IAAIN,EAAI,yCAAyCG,EAAK,GAAG,yBAC5DG,EAAM,KAAK,KAAK,0EAE5C;EACA;CACF;CACA,EAAM,MAAMH,GAAMF,CAAE;AACtB;AAIA,SAAgBO,EACd,GACA,GACA,GACA,GACwB;CACxB,IAAMC,IAA8B,CAAC;CACrC,KAAK,IAAMH,KAASI,GAAQ;EAC1B,IAAMT,IAAKK,EAAM,KAAKH,CAAI;EAC1B,IAAIF,MAAO,KAAA,GAAW;EACtB,IAAMD,IAAMM,EAAM,MAAML,CAAE;EAC1B,IAAID,MAAQ,KAAA,GAAW;GACrB,IAAiBM,CAAK;GACtB;EACF;EACA,EAAIA,EAAM,KAAKK,MAAUX;CAC3B;CACA,OAAOS;AACT;AAQA,SAAgBG,EACd,GACqD;CACrD,IAAMC,IAAMV,GACNM,IAA+B,CAAC;CACtC,KAAK,IAAMX,KAAQJ,GAAgB;EACjC,IAAII,EAAK,kBAAkBK,EAAK,SAAS,aAAa;EACtD,IAAMF,IAAKY,EAAIf,EAAK;EACpB,AAAIG,MAAO,KAAA,MAAW,EAAIH,EAAK,SAASG;CAC1C;CACA,OAAOQ;AACT"}