@weasel-js/core 1.11.0 → 1.12.0

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

@@ -1 +1 @@
-{"version":3,"file":"arrivalWindow.js","names":[],"sources":["../../../src/core/scene/arrivalWindow.ts"],"sourcesContent":["/**\n * The scene's arrival window: what a live edit did to containers, collected\n * while it runs and handed to a layout handler before it closes.\n *\n * The window is open while a live edit is collecting the nodes that joined a\n * container, the ones that left one, and every container whose children or\n * size it changed; whoever opened the window settles it before the edit\n * closes. Undo, redo and journal replays never open it: they restore an\n * arrangement that was already decided.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport type { Op } from 'core/ops/types';\nimport { createArrangeOp, type ArrangedPose } from 'core/ops/arrange';\nimport { SceneArrivalRefused } from './arrivals';\nimport type { LayoutMove, Node, NodeId, SceneArrivalHandler } from './types';\n\n/** What the window needs from the scene it serves. */\nexport interface ArrivalWindowEnv<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  /** The pass over the scene's declared layouts, which settles arrivals once\n   *  a container has declared one. An installed handler takes its place. */\n  layoutPass: SceneArrivalHandler<TPose>;\n  /** Whether a bare scene call would record an edit of its own right now:\n   *  no batch is open and no history engine is driving. */\n  recordsBareEdits(): boolean;\n  /** Write one arranged pose. Bound into the arrange op, since not every\n   *  adapter an edit is applied through can write poses. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface ArrivalWindow<TPose> {\n  /** A container was given a layout: from here on the scene has arrivals to\n   *  settle even with no handler installed. */\n  layoutDeclared(): void;\n  /** Install the handler that settles arrivals. Returns its remover. */\n  setHandler(handler: SceneArrivalHandler<TPose>): () => void;\n  /** Hear the poses each live edit's settle wrote, after the edit lands. */\n  onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;\n  noteArrival(id: NodeId, parent: NodeId | null, from: NodeId | null): void;\n  noteDeparture(id: NodeId, from: NodeId | null, to: NodeId | null): void;\n  /** A container's child set or order changed, or it changed size. */\n  noteChange(id: NodeId | null): void;\n  /** Whether a bare scene call has to run as a batch of its own, so the\n   *  layout pass it triggers lands in its undo step. */\n  bareLayoutEdit(): boolean;\n  /** Open the window when a handler wants one — or `always`, for an edit that\n   *  may give the scene its first layout partway through — and no enclosing\n   *  edit holds it already; true when this caller now owns it. */\n  open(always?: boolean): boolean;\n  /** Close the window and ask the handler what the arrivals get. Throws\n   *  `SceneArrivalRefused` when it refuses, which reverts the edit. */\n  settle(): ArrangedPose[];\n  /** Report what the settled edit wrote, now that it has landed. */\n  emitReflow(): void;\n  /** Close the window with nothing settled or reported: its owner's edit is\n   *  over, however it ended. */\n  abandon(): void;\n  /** Run an op-driven edit that may carry arrivals: a refusal reverts it and\n   *  is swallowed, the way a drop onto a full container is — nothing lands.\n   *  Returns whether the edit landed. */\n  runEdit(ops: Op[], run: (ops: Op[]) => void): boolean;\n}\n\n/** Of the ids noted per container, those the landed edit bears out: still\n *  under it when `joined`, gone from it otherwise. A container that is itself\n *  gone is left out. */\nfunction heldMoves(\n  nodes: ReadonlyMap<NodeId, { parent: NodeId | null }>,\n  noted: ReadonlyMap<NodeId, NodeId[]>,\n  joined: boolean,\n): Map<NodeId, NodeId[]> {\n  const out = new Map<NodeId, NodeId[]>();\n  for (const [parent, ids] of noted) {\n    const held = ids.filter((id) => (nodes.get(id)?.parent === parent) === joined);\n    if (held.length > 0 && nodes.has(parent)) out.set(parent, held);\n  }\n  return out;\n}\n\nexport function createArrivalWindow<TData, TLayer extends string, TPose>(\n  env: ArrivalWindowEnv<TData, TLayer, TPose>,\n): ArrivalWindow<TPose> {\n  const { nodes } = env;\n  let installed: SceneArrivalHandler<TPose> | null = null;\n  let hasLayouts = false;\n  let arrivals: Map<NodeId, NodeId[]> | null = null;\n  let departures = new Map<NodeId, NodeId[]>();\n  let changed = new Set<NodeId>();\n  /** What the last settle wrote, reported to `onReflow` once its edit lands. */\n  let reflowDue: LayoutMove<TPose>[] | null = null;\n  const reflowListeners = createEmitter<[moves: readonly LayoutMove<TPose>[]]>();\n\n  const activeHandler = (): SceneArrivalHandler<TPose> | null => installed ?? (hasLayouts ? env.layoutPass : null);\n\n  function open(always = false): boolean {\n    if (arrivals !== null || (!always && activeHandler() === null)) return false;\n    arrivals = new Map();\n    departures = new Map();\n    changed = new Set();\n    reflowDue = null;\n    return true;\n  }\n\n  function emitReflow(): void {\n    const moves = reflowDue;\n    reflowDue = null;\n    if (moves === null || moves.length === 0) return;\n    reflowListeners.emit(moves);\n  }\n\n  function settle(): ArrangedPose[] {\n    const pending = arrivals;\n    arrivals = null;\n    const handler = activeHandler();\n    if (pending === null || handler === null) return [];\n    // Only what is still there once the edit's other mutations have landed.\n    const landed = heldMoves(nodes, pending, true);\n    // Only what is gone from the container once the edit has landed: a child\n    // that left and came back did not depart.\n    const left = heldMoves(nodes, departures, false);\n    departures = new Map();\n    const touched = new Set([...changed].filter((id) => nodes.get(id)?.kind === 'container'));\n    if (landed.size === 0 && touched.size === 0) return [];\n    const poses = handler(landed, touched, left);\n    if (poses === null) throw new SceneArrivalRefused(landed);\n    const out: ArrangedPose[] = [];\n    for (const [id, to] of poses) {\n      const node = nodes.get(id);\n      if (node) out.push({ id, from: node.pose, to });\n    }\n    reflowDue = out as LayoutMove<TPose>[];\n    return out;\n  }\n\n  function abandon(): void {\n    arrivals = null;\n    reflowDue = null;\n  }\n\n  /** `ops` plus the op that settles their arrivals, when this call owns the\n   *  window; `ops` unchanged otherwise. Opened even on a scene with no layout\n   *  yet: an edit's op list is fixed before it runs, and any op in it may give\n   *  the scene its first. The arrange op that settles nothing elides itself. */\n  function withArrivalOps(ops: Op[]): { ops: Op[]; owned: boolean } {\n    if (!open(true)) return { ops, owned: false };\n    return { ops: [...ops, createArrangeOp({}, settle, env.writePose)], owned: true };\n  }\n\n  return {\n    layoutDeclared: () => { hasLayouts = true; },\n    setHandler(handler) {\n      installed = handler;\n      return () => {\n        if (installed === handler) installed = null;\n      };\n    },\n    onReflow: reflowListeners.subscribe,\n    noteArrival(id, parent, from) {\n      if (arrivals === null || parent === null || parent === from) return;\n      changed.add(parent);\n      const list = arrivals.get(parent);\n      if (list === undefined) arrivals.set(parent, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteDeparture(id, from, to) {\n      if (arrivals === null || from === null || from === to) return;\n      changed.add(from);\n      // One that joined earlier in this edit was never there to leave.\n      if (arrivals.get(from)?.includes(id)) return;\n      const list = departures.get(from);\n      if (list === undefined) departures.set(from, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteChange(id) {\n      if (arrivals !== null && id !== null) changed.add(id);\n    },\n    bareLayoutEdit: () => activeHandler() !== null && arrivals === null && env.recordsBareEdits(),\n    open,\n    settle,\n    emitReflow,\n    abandon,\n    runEdit(ops, run) {\n      const { ops: all, owned } = withArrivalOps(ops);\n      // An edit inside another's window leaves a refusal to the one that owns\n      // it, which reverts the whole edit and answers for it.\n      if (!owned) return run(all), true;\n      try {\n        run(all);\n        emitReflow();\n        return true;\n      } catch (err) {\n        if (!(err instanceof SceneArrivalRefused)) throw err;\n        return false;\n      } finally {\n        abandon();\n      }\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"arrivalWindow.js","names":[],"sources":["../../../src/core/scene/arrivalWindow.ts"],"sourcesContent":["/**\n * The scene's arrival window: what a live edit did to containers, collected\n * while it runs and handed to a layout handler before it closes.\n *\n * The window is open while a live edit is collecting the nodes that joined a\n * container, the ones that left one, and every container whose children or\n * size it changed; whoever opened the window settles it before the edit\n * closes. Undo, redo and journal replays never open it: they restore an\n * arrangement that was already decided.\n */\nimport { createEmitter } from '@weasel-js/registry';\nimport type { Op } from 'core/ops/types';\nimport { createArrangeOp, type ArrangedPose } from 'core/ops/arrange';\nimport { SceneArrivalRefused } from './arrivals';\nimport type { LayoutMove, Node, NodeId, SceneArrivalHandler } from './types';\n\n/** What the window needs from the scene it serves. */\nexport interface ArrivalWindowEnv<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  /** The pass over the scene's declared layouts, which settles arrivals once\n   *  a container has declared one. An installed handler takes its place. */\n  layoutPass: SceneArrivalHandler<TPose>;\n  /** Whether a bare scene call would record an edit of its own right now:\n   *  no batch is open and no history engine is driving. */\n  recordsBareEdits(): boolean;\n  /** Write one arranged pose. Bound into the arrange op, since not every\n   *  adapter an edit is applied through can write poses. */\n  writePose(id: string, pose: unknown): void;\n}\n\nexport interface ArrivalWindow<TPose> {\n  /** A container was given a layout: from here on the scene has arrivals to\n   *  settle even with no handler installed. */\n  layoutDeclared(): void;\n  /** Install the handler that settles arrivals. Returns its remover. */\n  setHandler(handler: SceneArrivalHandler<TPose>): () => void;\n  /** Hear the poses each live edit's settle wrote, after the edit lands. */\n  onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;\n  noteArrival(id: NodeId, parent: NodeId | null, from: NodeId | null): void;\n  noteDeparture(id: NodeId, from: NodeId | null, to: NodeId | null): void;\n  /** A container's child set or order changed, it changed size, or a child was posed. */\n  noteChange(id: NodeId | null): void;\n  /** Whether a bare scene call has to run as a batch of its own, so the\n   *  layout pass it triggers lands in its undo step. */\n  bareLayoutEdit(): boolean;\n  /** Open the window when a handler wants one — or `always`, for an edit that\n   *  may give the scene its first layout partway through — and no enclosing\n   *  edit holds it already; true when this caller now owns it. */\n  open(always?: boolean): boolean;\n  /** Close the window and ask the handler what the arrivals get. Throws\n   *  `SceneArrivalRefused` when it refuses, which reverts the edit. */\n  settle(): ArrangedPose[];\n  /** Report what the settled edit wrote, now that it has landed. */\n  emitReflow(): void;\n  /** Close the window with nothing settled or reported: its owner's edit is\n   *  over, however it ended. */\n  abandon(): void;\n  /** Run an op-driven edit that may carry arrivals: a refusal reverts it and\n   *  is swallowed, the way a drop onto a full container is — nothing lands.\n   *  Returns whether the edit landed. */\n  runEdit(ops: Op[], run: (ops: Op[]) => void): boolean;\n}\n\n/** Of the ids noted per container, those the landed edit bears out: still\n *  under it when `joined`, gone from it otherwise. A container that is itself\n *  gone is left out. */\nfunction heldMoves(\n  nodes: ReadonlyMap<NodeId, { parent: NodeId | null }>,\n  noted: ReadonlyMap<NodeId, NodeId[]>,\n  joined: boolean,\n): Map<NodeId, NodeId[]> {\n  const out = new Map<NodeId, NodeId[]>();\n  for (const [parent, ids] of noted) {\n    const held = ids.filter((id) => (nodes.get(id)?.parent === parent) === joined);\n    if (held.length > 0 && nodes.has(parent)) out.set(parent, held);\n  }\n  return out;\n}\n\nexport function createArrivalWindow<TData, TLayer extends string, TPose>(\n  env: ArrivalWindowEnv<TData, TLayer, TPose>,\n): ArrivalWindow<TPose> {\n  const { nodes } = env;\n  let installed: SceneArrivalHandler<TPose> | null = null;\n  let hasLayouts = false;\n  let arrivals: Map<NodeId, NodeId[]> | null = null;\n  let departures = new Map<NodeId, NodeId[]>();\n  let changed = new Set<NodeId>();\n  /** What the last settle wrote, reported to `onReflow` once its edit lands. */\n  let reflowDue: LayoutMove<TPose>[] | null = null;\n  const reflowListeners = createEmitter<[moves: readonly LayoutMove<TPose>[]]>();\n\n  const activeHandler = (): SceneArrivalHandler<TPose> | null => installed ?? (hasLayouts ? env.layoutPass : null);\n\n  function open(always = false): boolean {\n    if (arrivals !== null || (!always && activeHandler() === null)) return false;\n    arrivals = new Map();\n    departures = new Map();\n    changed = new Set();\n    reflowDue = null;\n    return true;\n  }\n\n  function emitReflow(): void {\n    const moves = reflowDue;\n    reflowDue = null;\n    if (moves === null || moves.length === 0) return;\n    reflowListeners.emit(moves);\n  }\n\n  function settle(): ArrangedPose[] {\n    const pending = arrivals;\n    arrivals = null;\n    const handler = activeHandler();\n    if (pending === null || handler === null) return [];\n    // Only what is still there once the edit's other mutations have landed.\n    const landed = heldMoves(nodes, pending, true);\n    // Only what is gone from the container once the edit has landed: a child\n    // that left and came back did not depart.\n    const left = heldMoves(nodes, departures, false);\n    departures = new Map();\n    const touched = new Set([...changed].filter((id) => nodes.get(id)?.kind === 'container'));\n    if (landed.size === 0 && touched.size === 0) return [];\n    const poses = handler(landed, touched, left);\n    if (poses === null) throw new SceneArrivalRefused(landed);\n    const out: ArrangedPose[] = [];\n    for (const [id, to] of poses) {\n      const node = nodes.get(id);\n      if (node) out.push({ id, from: node.pose, to });\n    }\n    reflowDue = out as LayoutMove<TPose>[];\n    return out;\n  }\n\n  function abandon(): void {\n    arrivals = null;\n    reflowDue = null;\n  }\n\n  /** `ops` plus the op that settles their arrivals, when this call owns the\n   *  window; `ops` unchanged otherwise. Opened even on a scene with no layout\n   *  yet: an edit's op list is fixed before it runs, and any op in it may give\n   *  the scene its first. The arrange op that settles nothing elides itself. */\n  function withArrivalOps(ops: Op[]): { ops: Op[]; owned: boolean } {\n    if (!open(true)) return { ops, owned: false };\n    return { ops: [...ops, createArrangeOp({}, settle, env.writePose)], owned: true };\n  }\n\n  return {\n    layoutDeclared: () => { hasLayouts = true; },\n    setHandler(handler) {\n      installed = handler;\n      return () => {\n        if (installed === handler) installed = null;\n      };\n    },\n    onReflow: reflowListeners.subscribe,\n    noteArrival(id, parent, from) {\n      if (arrivals === null || parent === null || parent === from) return;\n      changed.add(parent);\n      const list = arrivals.get(parent);\n      if (list === undefined) arrivals.set(parent, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteDeparture(id, from, to) {\n      if (arrivals === null || from === null || from === to) return;\n      changed.add(from);\n      // One that joined earlier in this edit was never there to leave.\n      if (arrivals.get(from)?.includes(id)) return;\n      const list = departures.get(from);\n      if (list === undefined) departures.set(from, [id]);\n      else if (!list.includes(id)) list.push(id);\n    },\n    noteChange(id) {\n      if (arrivals !== null && id !== null) changed.add(id);\n    },\n    bareLayoutEdit: () => activeHandler() !== null && arrivals === null && env.recordsBareEdits(),\n    open,\n    settle,\n    emitReflow,\n    abandon,\n    runEdit(ops, run) {\n      const { ops: all, owned } = withArrivalOps(ops);\n      // An edit inside another's window leaves a refusal to the one that owns\n      // it, which reverts the whole edit and answers for it.\n      if (!owned) return run(all), true;\n      try {\n        run(all);\n        emitReflow();\n        return true;\n      } catch (err) {\n        if (!(err instanceof SceneArrivalRefused)) throw err;\n        return false;\n      } finally {\n        abandon();\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/carryDescendants.js

@@ -0,0 +1,51 @@
+import { composeWorldPose, composesFrames, frameAtOrAbove, rebaseLocalPose } from "./composeFrame.js";
+import { scenePoseAdapter } from "./scenePoseAdapter.js";
+
+//#region src/core/scene/carryDescendants.ts
+/**
+* Bringing a node's descendants along when something writes the node's pose
+* and nothing writes theirs: a layout restacking a container, a drop landing
+* one, a page move. Under absolute poses a descendant stores its own world
+* pose, so it stays behind unless it is written too.
+*/
+/** A {@link CarrySource} over a scene's document poses. */
+function sceneCarrySource(scene) {
+	return {
+		childrenOf: (id) => scene.childrenOf(id),
+		poses: scenePoseAdapter(scene),
+		composition: scene.composition
+	};
+}
+/**
+* The stored poses that bring `root`'s descendants along with it: each one's
+* world pose put through `translate`, rebased into the frame it is stored in.
+* A descendant stored in the frame of `root` or of a node under it is left
+* out, since that frame carries it, and so is one `translate` answers null
+* for. A descendant `moving` names is moving on its own: it and everything
+* under it are left to whoever moves it.
+*/
+function carriedDescendants(source, root, translate, moving = () => false) {
+	const { poses, composition } = source;
+	const framed = composesFrames(composition);
+	const under = /* @__PURE__ */ new Set([root]);
+	const out = /* @__PURE__ */ new Map();
+	const walk = (at) => {
+		for (const id of source.childrenOf(at)) {
+			if (moving(id)) continue;
+			under.add(id);
+			const parent = poses.getParent(id);
+			const frame = framed ? frameAtOrAbove(poses, parent) : null;
+			if (frame === null || !under.has(frame)) {
+				const world = translate(composeWorldPose(poses, id, composition.compose), id);
+				if (world !== null) out.set(id, rebaseLocalPose(poses, world, parent, composition.compose, composition.decompose));
+			}
+			walk(id);
+		}
+	};
+	walk(root);
+	return out;
+}
+
+//#endregion
+export { carriedDescendants, sceneCarrySource };
+//# sourceMappingURL=carryDescendants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"carryDescendants.js","names":[],"sources":["../../../src/core/scene/carryDescendants.ts"],"sourcesContent":["/**\n * Bringing a node's descendants along when something writes the node's pose\n * and nothing writes theirs: a layout restacking a container, a drop landing\n * one, a page move. Under absolute poses a descendant stores its own world\n * pose, so it stays behind unless it is written too.\n */\nimport { composeWorldPose, composesFrames, frameAtOrAbove, rebaseLocalPose, type PoseAdapter, type PoseComposition } from './composeFrame';\nimport { scenePoseAdapter } from './scenePoseAdapter';\nimport type { NodeId, Scene } from './types';\n\n/** What carrying reads: the tree, every stored pose, and how poses compose. */\nexport interface CarrySource<TPose> {\n  childrenOf(id: NodeId): readonly NodeId[];\n  poses: PoseAdapter<TPose>;\n  composition: PoseComposition<TPose>;\n}\n\n/** A {@link CarrySource} over a scene's document poses. */\nexport function sceneCarrySource(scene: Scene<unknown, string, unknown>): CarrySource<unknown> {\n  return {\n    childrenOf: (id) => scene.childrenOf(id),\n    poses: scenePoseAdapter(scene),\n    composition: scene.composition,\n  };\n}\n\n/**\n * The stored poses that bring `root`'s descendants along with it: each one's\n * world pose put through `translate`, rebased into the frame it is stored in.\n * A descendant stored in the frame of `root` or of a node under it is left\n * out, since that frame carries it, and so is one `translate` answers null\n * for. A descendant `moving` names is moving on its own: it and everything\n * under it are left to whoever moves it.\n */\nexport function carriedDescendants<TPose>(\n  source: CarrySource<TPose>,\n  root: NodeId,\n  translate: (world: TPose, id: NodeId) => TPose | null,\n  moving: (id: NodeId) => boolean = () => false,\n): Map<NodeId, TPose> {\n  const { poses, composition } = source;\n  const framed = composesFrames(composition);\n  const under = new Set<NodeId>([root]);\n  const out = new Map<NodeId, TPose>();\n  const walk = (at: NodeId): void => {\n    for (const id of source.childrenOf(at)) {\n      if (moving(id)) continue;\n      under.add(id);\n      const parent = poses.getParent(id);\n      const frame = framed ? frameAtOrAbove(poses, parent) : null;\n      if (frame === null || !under.has(frame as NodeId)) {\n        const world = translate(composeWorldPose(poses, id, composition.compose), id);\n        if (world !== null) out.set(id, rebaseLocalPose(poses, world, parent, composition.compose, composition.decompose));\n      }\n      walk(id);\n    }\n  };\n  walk(root);\n  return out;\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,iBAAiB,OAA8D;CAC7F,OAAO;EACL,aAAa,OAAO,MAAM,WAAW,EAAE;EACvC,OAAO,iBAAiB,KAAK;EAC7B,aAAa,MAAM;CACrB;AACF;;;;;;;;;AAUA,SAAgB,mBACd,QACA,MACA,WACA,eAAwC,OACpB;CACpB,MAAM,EAAE,OAAO,gBAAgB;CAC/B,MAAM,SAAS,eAAe,WAAW;CACzC,MAAM,wBAAQ,IAAI,IAAY,CAAC,IAAI,CAAC;CACpC,MAAM,sBAAM,IAAI,IAAmB;CACnC,MAAM,QAAQ,OAAqB;EACjC,KAAK,MAAM,MAAM,OAAO,WAAW,EAAE,GAAG;GACtC,IAAI,OAAO,EAAE,GAAG;GAChB,MAAM,IAAI,EAAE;GACZ,MAAM,SAAS,MAAM,UAAU,EAAE;GACjC,MAAM,QAAQ,SAAS,eAAe,OAAO,MAAM,IAAI;GACvD,IAAI,UAAU,QAAQ,CAAC,MAAM,IAAI,KAAe,GAAG;IACjD,MAAM,QAAQ,UAAU,iBAAiB,OAAO,IAAI,YAAY,OAAO,GAAG,EAAE;IAC5E,IAAI,UAAU,MAAM,IAAI,IAAI,IAAI,gBAAgB,OAAO,OAAO,QAAQ,YAAY,SAAS,YAAY,SAAS,CAAC;GACnH;GACA,KAAK,EAAE;EACT;CACF;CACA,KAAK,IAAI;CACT,OAAO;AACT"}

package/dist/core/scene/clipNothing.js

@@ -0,0 +1,13 @@
+//#region src/core/scene/clipNothing.ts
+/** Registry key for {@link clipNothing}; every scene's registry carries it. */
+var CLIP_NOTHING = "kit:clipNothing";
+/**
+* A container's `clipFromPose` that clips nothing, for a container whose
+* children may draw outside it. A container without one clips its children to
+* its painter's silhouette.
+*/
+var clipNothing = () => null;
+
+//#endregion
+export { CLIP_NOTHING, clipNothing };
+//# sourceMappingURL=clipNothing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clipNothing.js","names":[],"sources":["../../../src/core/scene/clipNothing.ts"],"sourcesContent":["/** Registry key for {@link clipNothing}; every scene's registry carries it. */\nexport const CLIP_NOTHING = 'kit:clipNothing';\n\n/**\n * A container's `clipFromPose` that clips nothing, for a container whose\n * children may draw outside it. A container without one clips its children to\n * its painter's silhouette.\n */\nexport const clipNothing = (): null => null;\n"],"mappings":";;AACA,IAAa,eAAe;;;;;;AAO5B,IAAa,oBAA0B"}

package/dist/core/scene/depMemo.js

@@ -1,3 +1,4 @@
+import { fontGeneration, noteFontRead, withFontReads } from "./fontReads.js";
 import { samePoseValue, snapshotPose } from "./poseSnapshot.js";
 
 //#region src/core/scene/depMemo.ts
@@ -7,7 +8,8 @@ function emptyDepRecord() {
 		poses: [],
 		data: [],
 		layers: [],
-		paths: []
+		paths: [],
+		faces: null
 	};
 }
 /** A dependency as the derivation is handed it, noting a read of its path. A
@@ -37,20 +39,25 @@ function deriveRecorded(into, deps, derive) {
 	into.data.length = 0;
 	into.layers.length = 0;
 	into.paths.length = 0;
-	return derive(deps.map((dep, i) => {
+	const handed = deps.map((dep, i) => {
 		into.nodes.push(dep?.node);
 		into.poses.push(dep === void 0 ? void 0 : snapshotPose(dep.pose));
 		into.data.push(dep?.node.data);
 		into.layers.push(dep?.node.layer);
 		into.paths.push(void 0);
 		return dep === void 0 ? void 0 : new RecordedDep(dep, into.paths, i);
-	}));
+	});
+	const generation = fontGeneration();
+	const { value, fonts } = withFontReads(() => derive(handed));
+	into.faces = fonts ? generation : null;
+	return value;
 }
 /** Whether the dependencies still resolve to what the record was taken from.
 *  Resolves them one at a time rather than taking an array: this is the hit
 *  path, and it walks every derived node's every dependency on every frame. */
 function sameDeps(record, ids, depOf) {
 	if (record.nodes.length !== ids.length) return false;
+	if (record.faces !== null && record.faces !== fontGeneration()) return false;
 	for (let i = 0; i < ids.length; i++) {
 		const dep = depOf(ids[i]);
 		if (record.nodes[i] !== (dep === void 0 ? void 0 : dep.node)) return false;
@@ -60,6 +67,7 @@ function sameDeps(record, ids, depOf) {
 		const path = record.paths[i];
 		if (path !== void 0 && path !== dep.path) return false;
 	}
+	if (record.faces !== null) noteFontRead();
 	return true;
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"depMemo.js","names":[],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [] };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  return derive(handed);\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  return true;\n}\n"],"mappings":";;;AA8BA,SAAgB,iBAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;CAAE;AACjE;;;AAIA,IAAM,cAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,KACA,OACA,OACA;EAHiB,KAAA,MAAA;EACA,KAAA,QAAA;EACA,KAAA,QAAA;EAEjB,KAAK,OAAO,IAAI;EAChB,KAAK,OAAO,IAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;;;AAIA,SAAgB,eACd,MACA,MACA,QACG;CACH,KAAK,MAAM,SAAS;CACpB,KAAK,MAAM,SAAS;CACpB,KAAK,KAAK,SAAS;CACnB,KAAK,OAAO,SAAS;CACrB,KAAK,MAAM,SAAS;CASpB,OAAO,OARQ,KAAK,KAAK,KAAK,MAAM;EAClC,KAAK,MAAM,KAAK,KAAK,IAAI;EACzB,KAAK,MAAM,KAAK,QAAQ,SAAY,SAAY,aAAa,IAAI,IAAI,CAAC;EACtE,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI;EAC7B,KAAK,OAAO,KAAK,KAAK,KAAK,KAAK;EAChC,KAAK,MAAM,KAAK,MAAS;EACzB,OAAO,QAAQ,SAAY,SAAY,IAAI,YAAY,KAAK,KAAK,OAAO,CAAC;CAC3E,CACc,CAAM;AACtB;;;;AAKA,SAAgB,SACd,QACA,KACA,OACS;CACT,IAAI,OAAO,MAAM,WAAW,IAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,MAAM,MAAM,IAAI,EAAE;EACxB,IAAI,OAAO,MAAM,QAAQ,QAAQ,SAAY,SAAY,IAAI,OAAO,OAAO;EAC3E,IAAI,QAAQ,QAAW;EACvB,IAAI,OAAO,KAAK,OAAO,IAAI,KAAK,QAAQ,OAAO,OAAO,OAAO,IAAI,KAAK,OAAO,OAAO;EACpF,IAAI,CAAC,cAAc,OAAO,MAAM,IAAI,IAAI,IAAI,GAAG,OAAO;EACtD,MAAM,OAAO,OAAO,MAAM;EAC1B,IAAI,SAAS,UAAa,SAAS,IAAI,MAAM,OAAO;CACtD;CACA,OAAO;AACT"}
+{"version":3,"file":"depMemo.js","names":[],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that changed with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing, a lookup\n * answering nodes no scene edits — is invisible to that key. Recording what\n * the derivation was handed and comparing it on the hit path is what notices\n * it without a trigger.\n *\n * What is recorded is what a derivation may read of a dependency: its node (an\n * identity), its pose (by value), its `data` (a reference, which every edit\n * replaces), its `layer`, and its path where the derivation read it. Anything\n * else on the node — its parent, its children — still needs a push. A\n * derivation that read glyph outlines also records the face generation, since\n * a face landing changes its result with nothing in the scene changed.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { fontGeneration, noteFontRead, withFontReads } from './fontReads';\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, Node, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — with a copy of the pose it resolved to, its `data` and `layer`, and\n *  the path it answered, `undefined` where the derivation never asked. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n  data: unknown[];\n  layers: (string | undefined)[];\n  paths: (Path | null | undefined)[];\n  /** The face generation it was derived under, or `null` when it read no\n   *  glyph outlines. */\n  faces: number | null;\n}\n\nexport function emptyDepRecord<TPose>(): DepRecord<TPose> {\n  return { nodes: [], poses: [], data: [], layers: [], paths: [], faces: null };\n}\n\n/** A dependency as the derivation is handed it, noting a read of its path. A\n *  class for the reason `SceneDep` is one: a prototype accessor is cheap. */\nclass RecordedDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(\n    private readonly dep: DerivedDep<TPose>,\n    private readonly paths: (Path | null | undefined)[],\n    private readonly index: number,\n  ) {\n    this.node = dep.node;\n    this.pose = dep.pose;\n  }\n\n  get path(): Path | null {\n    return (this.paths[this.index] = this.dep.path);\n  }\n}\n\n/** Run `derive` against `deps`, recording in place what it was run against.\n *  Mutating the record is what updates the memo slot, which holds this object. */\nexport function deriveRecorded<TPose, T>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  derive: (deps: readonly (DerivedDep<TPose> | undefined)[]) => T,\n): T {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  into.data.length = 0;\n  into.layers.length = 0;\n  into.paths.length = 0;\n  const handed = deps.map((dep, i) => {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n    into.data.push(dep?.node.data);\n    into.layers.push(dep?.node.layer);\n    into.paths.push(undefined);\n    return dep === undefined ? undefined : new RecordedDep(dep, into.paths, i);\n  });\n  const generation = fontGeneration();\n  const { value, fonts } = withFontReads(() => derive(handed));\n  into.faces = fonts ? generation : null;\n  return value;\n}\n\n/** Whether the dependencies still resolve to what the record was taken from.\n *  Resolves them one at a time rather than taking an array: this is the hit\n *  path, and it walks every derived node's every dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  if (record.faces !== null && record.faces !== fontGeneration()) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep === undefined) continue;\n    if (record.data[i] !== dep.node.data || record.layers[i] !== dep.node.layer) return false;\n    if (!samePoseValue(record.poses[i], dep.pose)) return false;\n    const path = record.paths[i];\n    if (path !== undefined && path !== dep.path) return false;\n  }\n  // A hit is still a read, for any derivation enclosing this one.\n  if (record.faces !== null) noteFontRead();\n  return true;\n}\n"],"mappings":";;;;AAoCA,SAAgB,iBAA0C;CACxD,OAAO;EAAE,OAAO,CAAC;EAAG,OAAO,CAAC;EAAG,MAAM,CAAC;EAAG,QAAQ,CAAC;EAAG,OAAO,CAAC;EAAG,OAAO;CAAK;AAC9E;;;AAIA,IAAM,cAAN,MAAsD;CAKjC;CACA;CACA;CANnB;CACA;CAEA,YACE,KACA,OACA,OACA;EAHiB,KAAA,MAAA;EACA,KAAA,QAAA;EACA,KAAA,QAAA;EAEjB,KAAK,OAAO,IAAI;EAChB,KAAK,OAAO,IAAI;CAClB;CAEA,IAAI,OAAoB;EACtB,OAAQ,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI;CAC5C;AACF;;;AAIA,SAAgB,eACd,MACA,MACA,QACG;CACH,KAAK,MAAM,SAAS;CACpB,KAAK,MAAM,SAAS;CACpB,KAAK,KAAK,SAAS;CACnB,KAAK,OAAO,SAAS;CACrB,KAAK,MAAM,SAAS;CACpB,MAAM,SAAS,KAAK,KAAK,KAAK,MAAM;EAClC,KAAK,MAAM,KAAK,KAAK,IAAI;EACzB,KAAK,MAAM,KAAK,QAAQ,SAAY,SAAY,aAAa,IAAI,IAAI,CAAC;EACtE,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI;EAC7B,KAAK,OAAO,KAAK,KAAK,KAAK,KAAK;EAChC,KAAK,MAAM,KAAK,MAAS;EACzB,OAAO,QAAQ,SAAY,SAAY,IAAI,YAAY,KAAK,KAAK,OAAO,CAAC;CAC3E,CAAC;CACD,MAAM,aAAa,eAAe;CAClC,MAAM,EAAE,OAAO,UAAU,oBAAoB,OAAO,MAAM,CAAC;CAC3D,KAAK,QAAQ,QAAQ,aAAa;CAClC,OAAO;AACT;;;;AAKA,SAAgB,SACd,QACA,KACA,OACS;CACT,IAAI,OAAO,MAAM,WAAW,IAAI,QAAQ,OAAO;CAC/C,IAAI,OAAO,UAAU,QAAQ,OAAO,UAAU,eAAe,GAAG,OAAO;CACvE,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,MAAM,MAAM,IAAI,EAAE;EACxB,IAAI,OAAO,MAAM,QAAQ,QAAQ,SAAY,SAAY,IAAI,OAAO,OAAO;EAC3E,IAAI,QAAQ,QAAW;EACvB,IAAI,OAAO,KAAK,OAAO,IAAI,KAAK,QAAQ,OAAO,OAAO,OAAO,IAAI,KAAK,OAAO,OAAO;EACpF,IAAI,CAAC,cAAc,OAAO,MAAM,IAAI,IAAI,IAAI,GAAG,OAAO;EACtD,MAAM,OAAO,OAAO,MAAM;EAC1B,IAAI,SAAS,UAAa,SAAS,IAAI,MAAM,OAAO;CACtD;CAEA,IAAI,OAAO,UAAU,MAAM,aAAa;CACxC,OAAO;AACT"}

package/dist/core/scene/dependents.js

@@ -1,5 +1,11 @@
 //#region src/core/scene/dependents.ts
 var NONE = Object.freeze([]);
+/** The nodes in `scene` that list `id` in their `dependsOn`, directly or through others, less any inside `id`'s own
+*  subtree. */
+function sceneDependentsOf(scene, id) {
+	if (!scene.get(id)) return NONE;
+	return scene.removalClosure([id]).filter((d) => d !== id && !scene.ancestorsOf(d).includes(id));
+}
 /**
 * The nodes `node`'s geometry derives from: the ids it named, or its own
 * children when it named `'children'`.
@@ -90,5 +96,5 @@ function sameDependsOn(a, b) {
 }
 
 //#endregion
-export { createDependentsIndex, dependencyIdsOf, sameDependsOn };
+export { createDependentsIndex, dependencyIdsOf, sameDependsOn, sceneDependentsOf };
 //# sourceMappingURL=dependents.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"dependents.js","names":[],"sources":["../../../src/core/scene/dependents.ts"],"sourcesContent":["/**\n * Which nodes must recompute when a given node's pose changes — the reverse\n * index, plus {@link dependencyIdsOf}, the forward read it is built from.\n */\nimport type { NodeId } from './types';\n\nconst NONE: readonly NodeId[] = Object.freeze([]);\n\n/**\n * The nodes `node`'s geometry derives from: the ids it named, or its own\n * children when it named `'children'`.\n *\n * The `'children'` form is deliberately absent from the reverse index — a\n * container is not a dependent of the children it hugs, or deleting one child\n * would cascade the whole group away. Its invalidation is the ancestor walk in\n * `scene.ts` instead.\n */\nexport function dependencyIdsOf(\n  node: { id: NodeId; dependsOn?: readonly NodeId[] | 'children' },\n  childrenOf: (id: NodeId) => readonly NodeId[],\n): readonly NodeId[] {\n  const deps = node.dependsOn;\n  if (deps === undefined) return NONE;\n  return deps === 'children' ? childrenOf(node.id) : deps;\n}\n\nexport interface DependentsIndex {\n  add(id: NodeId, deps: readonly NodeId[]): void;\n  /** Forget what `id` declared. Deliberately not symmetric: who depends on\n   *  `id` is those nodes' declaration, not `id`'s, and outlives its removal. */\n  remove(id: NodeId): void;\n  /** Forget every registration. */\n  clear(): void;\n  /** True when nothing derives from anything. */\n  isEmpty(): boolean;\n  dependentsOf(id: NodeId): Iterable<NodeId>;\n  /** Nodes that derive from `id` directly or through a chain. Excludes `id`\n   *  itself unless a cycle leads back to it. */\n  transitiveDependentsOf(id: NodeId): Iterable<NodeId>;\n}\n\nexport function createDependentsIndex(): DependentsIndex {\n  /** dependency -> nodes deriving from it */\n  const forward = new Map<NodeId, Set<NodeId>>();\n  /** dependent -> the dependencies it registered against */\n  const reverse = new Map<NodeId, readonly NodeId[]>();\n\n  /** Drop `id`'s registrations against its current dependencies. Shared by\n   *  `add` (which re-registers after) and `remove` (which does not). */\n  function detachOwnDeps(id: NodeId): void {\n    const old = reverse.get(id);\n    if (old === undefined) return;\n    for (const dep of old) {\n      const set = forward.get(dep);\n      if (set === undefined) continue;\n      set.delete(id);\n      if (set.size === 0) forward.delete(dep);\n    }\n    reverse.delete(id);\n  }\n\n  return {\n    add(id, deps) {\n      detachOwnDeps(id);\n      if (deps.length === 0) return;\n      reverse.set(id, [...deps]);\n      for (const dep of deps) {\n        let set = forward.get(dep);\n        if (set === undefined) { set = new Set(); forward.set(dep, set); }\n        set.add(id);\n      }\n    },\n\n    remove(id) {\n      detachOwnDeps(id);\n    },\n\n    clear() {\n      forward.clear();\n      reverse.clear();\n    },\n\n    isEmpty() {\n      return forward.size === 0;\n    },\n\n    dependentsOf(id) {\n      const set = forward.get(id);\n      return set === undefined ? NONE : [...set];\n    },\n\n    transitiveDependentsOf(id) {\n      // Runs per node per frame; the miss must not allocate.\n      const direct = forward.get(id);\n      if (direct === undefined) return NONE;\n      const out = new Set<NodeId>();\n      const stack: NodeId[] = [...direct];\n      while (stack.length > 0) {\n        const next = stack.pop()!;\n        if (out.has(next)) continue;   // also what stops a cycle\n        out.add(next);\n        for (const d of forward.get(next) ?? []) stack.push(d);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * Whether two `dependsOn` values name the same thing, so a retarget to what a\n * node already declares can be elided. Order is part of it: a router reads its\n * ends positionally, and swapping them reverses the edge.\n */\nexport function sameDependsOn(\n  a: readonly NodeId[] | 'children' | undefined,\n  b: readonly NodeId[] | 'children' | undefined,\n): boolean {\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a === 'children' || b === 'children') return false;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";AAMA,IAAM,OAA0B,OAAO,OAAO,CAAC,CAAC;;;;;;;;;;AAWhD,SAAgB,gBACd,MACA,YACmB;CACnB,MAAM,OAAO,KAAK;CAClB,IAAI,SAAS,QAAW,OAAO;CAC/B,OAAO,SAAS,aAAa,WAAW,KAAK,EAAE,IAAI;AACrD;AAiBA,SAAgB,wBAAyC;;CAEvD,MAAM,0BAAU,IAAI,IAAyB;;CAE7C,MAAM,0BAAU,IAAI,IAA+B;;;CAInD,SAAS,cAAc,IAAkB;EACvC,MAAM,MAAM,QAAQ,IAAI,EAAE;EAC1B,IAAI,QAAQ,QAAW;EACvB,KAAK,MAAM,OAAO,KAAK;GACrB,MAAM,MAAM,QAAQ,IAAI,GAAG;GAC3B,IAAI,QAAQ,QAAW;GACvB,IAAI,OAAO,EAAE;GACb,IAAI,IAAI,SAAS,GAAG,QAAQ,OAAO,GAAG;EACxC;EACA,QAAQ,OAAO,EAAE;CACnB;CAEA,OAAO;EACL,IAAI,IAAI,MAAM;GACZ,cAAc,EAAE;GAChB,IAAI,KAAK,WAAW,GAAG;GACvB,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC;GACzB,KAAK,MAAM,OAAO,MAAM;IACtB,IAAI,MAAM,QAAQ,IAAI,GAAG;IACzB,IAAI,QAAQ,QAAW;KAAE,sBAAM,IAAI,IAAI;KAAG,QAAQ,IAAI,KAAK,GAAG;IAAG;IACjE,IAAI,IAAI,EAAE;GACZ;EACF;EAEA,OAAO,IAAI;GACT,cAAc,EAAE;EAClB;EAEA,QAAQ;GACN,QAAQ,MAAM;GACd,QAAQ,MAAM;EAChB;EAEA,UAAU;GACR,OAAO,QAAQ,SAAS;EAC1B;EAEA,aAAa,IAAI;GACf,MAAM,MAAM,QAAQ,IAAI,EAAE;GAC1B,OAAO,QAAQ,SAAY,OAAO,CAAC,GAAG,GAAG;EAC3C;EAEA,uBAAuB,IAAI;GAEzB,MAAM,SAAS,QAAQ,IAAI,EAAE;GAC7B,IAAI,WAAW,QAAW,OAAO;GACjC,MAAM,sBAAM,IAAI,IAAY;GAC5B,MAAM,QAAkB,CAAC,GAAG,MAAM;GAClC,OAAO,MAAM,SAAS,GAAG;IACvB,MAAM,OAAO,MAAM,IAAI;IACvB,IAAI,IAAI,IAAI,IAAI,GAAG;IACnB,IAAI,IAAI,IAAI;IACZ,KAAK,MAAM,KAAK,QAAQ,IAAI,IAAI,KAAK,CAAC,GAAG,MAAM,KAAK,CAAC;GACvD;GACA,OAAO;EACT;CACF;AACF;;;;;;AAOA,SAAgB,cACd,GACA,GACS;CACT,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,UAAa,MAAM,QAAW,OAAO;CAC/C,IAAI,MAAM,cAAc,MAAM,YAAY,OAAO;CACjD,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;CAC7D,OAAO;AACT"}
+{"version":3,"file":"dependents.js","names":[],"sources":["../../../src/core/scene/dependents.ts"],"sourcesContent":["/**\n * Which nodes must recompute when a given node's pose changes — the reverse\n * index, plus {@link dependencyIdsOf}, the forward read it is built from.\n */\nimport type { NodeId, Scene } from './types';\n\nconst NONE: readonly NodeId[] = Object.freeze([]);\n\n/** The nodes in `scene` that list `id` in their `dependsOn`, directly or through others, less any inside `id`'s own\n *  subtree. */\nexport function sceneDependentsOf<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  id: NodeId,\n): readonly NodeId[] {\n  if (!scene.get(id)) return NONE;\n  return scene.removalClosure([id]).filter((d) => d !== id && !scene.ancestorsOf(d).includes(id));\n}\n\n/**\n * The nodes `node`'s geometry derives from: the ids it named, or its own\n * children when it named `'children'`.\n *\n * The `'children'` form is deliberately absent from the reverse index — a\n * container is not a dependent of the children it hugs, or deleting one child\n * would cascade the whole group away. Its invalidation is the ancestor walk in\n * `scene.ts` instead.\n */\nexport function dependencyIdsOf(\n  node: { id: NodeId; dependsOn?: readonly NodeId[] | 'children' },\n  childrenOf: (id: NodeId) => readonly NodeId[],\n): readonly NodeId[] {\n  const deps = node.dependsOn;\n  if (deps === undefined) return NONE;\n  return deps === 'children' ? childrenOf(node.id) : deps;\n}\n\nexport interface DependentsIndex {\n  add(id: NodeId, deps: readonly NodeId[]): void;\n  /** Forget what `id` declared. Deliberately not symmetric: who depends on\n   *  `id` is those nodes' declaration, not `id`'s, and outlives its removal. */\n  remove(id: NodeId): void;\n  /** Forget every registration. */\n  clear(): void;\n  /** True when nothing derives from anything. */\n  isEmpty(): boolean;\n  dependentsOf(id: NodeId): Iterable<NodeId>;\n  /** Nodes that derive from `id` directly or through a chain. Excludes `id`\n   *  itself unless a cycle leads back to it. */\n  transitiveDependentsOf(id: NodeId): Iterable<NodeId>;\n}\n\nexport function createDependentsIndex(): DependentsIndex {\n  /** dependency -> nodes deriving from it */\n  const forward = new Map<NodeId, Set<NodeId>>();\n  /** dependent -> the dependencies it registered against */\n  const reverse = new Map<NodeId, readonly NodeId[]>();\n\n  /** Drop `id`'s registrations against its current dependencies. Shared by\n   *  `add` (which re-registers after) and `remove` (which does not). */\n  function detachOwnDeps(id: NodeId): void {\n    const old = reverse.get(id);\n    if (old === undefined) return;\n    for (const dep of old) {\n      const set = forward.get(dep);\n      if (set === undefined) continue;\n      set.delete(id);\n      if (set.size === 0) forward.delete(dep);\n    }\n    reverse.delete(id);\n  }\n\n  return {\n    add(id, deps) {\n      detachOwnDeps(id);\n      if (deps.length === 0) return;\n      reverse.set(id, [...deps]);\n      for (const dep of deps) {\n        let set = forward.get(dep);\n        if (set === undefined) { set = new Set(); forward.set(dep, set); }\n        set.add(id);\n      }\n    },\n\n    remove(id) {\n      detachOwnDeps(id);\n    },\n\n    clear() {\n      forward.clear();\n      reverse.clear();\n    },\n\n    isEmpty() {\n      return forward.size === 0;\n    },\n\n    dependentsOf(id) {\n      const set = forward.get(id);\n      return set === undefined ? NONE : [...set];\n    },\n\n    transitiveDependentsOf(id) {\n      // Runs per node per frame; the miss must not allocate.\n      const direct = forward.get(id);\n      if (direct === undefined) return NONE;\n      const out = new Set<NodeId>();\n      const stack: NodeId[] = [...direct];\n      while (stack.length > 0) {\n        const next = stack.pop()!;\n        if (out.has(next)) continue;   // also what stops a cycle\n        out.add(next);\n        for (const d of forward.get(next) ?? []) stack.push(d);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * Whether two `dependsOn` values name the same thing, so a retarget to what a\n * node already declares can be elided. Order is part of it: a router reads its\n * ends positionally, and swapping them reverses the edge.\n */\nexport function sameDependsOn(\n  a: readonly NodeId[] | 'children' | undefined,\n  b: readonly NodeId[] | 'children' | undefined,\n): boolean {\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a === 'children' || b === 'children') return false;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";AAMA,IAAM,OAA0B,OAAO,OAAO,CAAC,CAAC;;;AAIhD,SAAgB,kBACd,OACA,IACmB;CACnB,IAAI,CAAC,MAAM,IAAI,EAAE,GAAG,OAAO;CAC3B,OAAO,MAAM,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,MAAM,MAAM,MAAM,CAAC,MAAM,YAAY,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;AAChG;;;;;;;;;;AAWA,SAAgB,gBACd,MACA,YACmB;CACnB,MAAM,OAAO,KAAK;CAClB,IAAI,SAAS,QAAW,OAAO;CAC/B,OAAO,SAAS,aAAa,WAAW,KAAK,EAAE,IAAI;AACrD;AAiBA,SAAgB,wBAAyC;;CAEvD,MAAM,0BAAU,IAAI,IAAyB;;CAE7C,MAAM,0BAAU,IAAI,IAA+B;;;CAInD,SAAS,cAAc,IAAkB;EACvC,MAAM,MAAM,QAAQ,IAAI,EAAE;EAC1B,IAAI,QAAQ,QAAW;EACvB,KAAK,MAAM,OAAO,KAAK;GACrB,MAAM,MAAM,QAAQ,IAAI,GAAG;GAC3B,IAAI,QAAQ,QAAW;GACvB,IAAI,OAAO,EAAE;GACb,IAAI,IAAI,SAAS,GAAG,QAAQ,OAAO,GAAG;EACxC;EACA,QAAQ,OAAO,EAAE;CACnB;CAEA,OAAO;EACL,IAAI,IAAI,MAAM;GACZ,cAAc,EAAE;GAChB,IAAI,KAAK,WAAW,GAAG;GACvB,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC;GACzB,KAAK,MAAM,OAAO,MAAM;IACtB,IAAI,MAAM,QAAQ,IAAI,GAAG;IACzB,IAAI,QAAQ,QAAW;KAAE,sBAAM,IAAI,IAAI;KAAG,QAAQ,IAAI,KAAK,GAAG;IAAG;IACjE,IAAI,IAAI,EAAE;GACZ;EACF;EAEA,OAAO,IAAI;GACT,cAAc,EAAE;EAClB;EAEA,QAAQ;GACN,QAAQ,MAAM;GACd,QAAQ,MAAM;EAChB;EAEA,UAAU;GACR,OAAO,QAAQ,SAAS;EAC1B;EAEA,aAAa,IAAI;GACf,MAAM,MAAM,QAAQ,IAAI,EAAE;GAC1B,OAAO,QAAQ,SAAY,OAAO,CAAC,GAAG,GAAG;EAC3C;EAEA,uBAAuB,IAAI;GAEzB,MAAM,SAAS,QAAQ,IAAI,EAAE;GAC7B,IAAI,WAAW,QAAW,OAAO;GACjC,MAAM,sBAAM,IAAI,IAAY;GAC5B,MAAM,QAAkB,CAAC,GAAG,MAAM;GAClC,OAAO,MAAM,SAAS,GAAG;IACvB,MAAM,OAAO,MAAM,IAAI;IACvB,IAAI,IAAI,IAAI,IAAI,GAAG;IACnB,IAAI,IAAI,IAAI;IACZ,KAAK,MAAM,KAAK,QAAQ,IAAI,IAAI,KAAK,CAAC,GAAG,MAAM,KAAK,CAAC;GACvD;GACA,OAAO;EACT;CACF;AACF;;;;;;AAOA,SAAgB,cACd,GACA,GACS;CACT,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,UAAa,MAAM,QAAW,OAAO;CAC/C,IAAI,MAAM,cAAc,MAAM,YAAY,OAAO;CACjD,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;CAC7D,OAAO;AACT"}

package/dist/core/scene/derivedParts.js

@@ -1,16 +1,15 @@
 import { cubicContoursToPath, pathToCubicContours } from "@weasel-js/geom";
+import { resolveFill, resolveStroke } from "@weasel-js/paint";
 
 //#region src/core/scene/derivedParts.ts
-/**
-* A derived path that paints in several parts, each with its own fill and
-* stroke: the steps of a blend, the copies of a repeat.
-*
-* A derivation returns one `Path`, which is what picking, bounds and every
-* reader of `DerivedDep.path` see. {@link pathFromParts} makes that path out
-* of the parts and remembers the parts against it, so the derived-node
-* painter, handed the path, can paint each part as itself. The parts live as
-* long as the path does — in the derivation's memo.
-*/
+/** What `part` paints, its `INHERIT` taken from `own`, the deriving node's
+*  data — whose own `INHERIT` takes `inherited`, its container's. */
+function resolvePartPaint(part, own, inherited) {
+	return {
+		fill: resolveFill(part.fill, resolveFill(own?.fill, inherited?.fill)),
+		stroke: resolveStroke(part.stroke, resolveStroke(own?.stroke, inherited?.stroke))
+	};
+}
 var PARTS = /* @__PURE__ */ new WeakMap();
 /**
 * One path holding every part's outline, with the parts remembered against
@@ -54,5 +53,5 @@ function concatPaths(paths) {
 }
 
 //#endregion
-export { derivedPartsOf, pathFromParts };
+export { derivedPartsOf, pathFromParts, resolvePartPaint };
 //# sourceMappingURL=derivedParts.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"derivedParts.js","names":[],"sources":["../../../src/core/scene/derivedParts.ts"],"sourcesContent":["/**\n * A derived path that paints in several parts, each with its own fill and\n * stroke: the steps of a blend, the copies of a repeat.\n *\n * A derivation returns one `Path`, which is what picking, bounds and every\n * reader of `DerivedDep.path` see. {@link pathFromParts} makes that path out\n * of the parts and remembers the parts against it, so the derived-node\n * painter, handed the path, can paint each part as itself. The parts live as\n * long as the path does — in the derivation's memo.\n */\nimport { pathToCubicContours, cubicContoursToPath, type Path, type PolygonPath } from '@weasel-js/geom';\nimport type { Fill, Stroke } from '@weasel-js/paint';\n\n/** One painted piece of a derived path. */\nexport interface DerivedPart {\n  path: Path;\n  /** The part's fill. Absent, the node's own `data.fill` paints it; `null`\n   *  paints none. */\n  fill?: Fill | null;\n  /** The part's stroke, on the same terms as `fill`. */\n  stroke?: Stroke | null;\n}\n\nconst PARTS = new WeakMap<Path, readonly DerivedPart[]>();\n\n/**\n * One path holding every part's outline, with the parts remembered against\n * it for the painter. Return it from a `derivePath`. `null` for no parts.\n */\nexport function pathFromParts(parts: readonly DerivedPart[]): Path | null {\n  if (parts.length === 0) return null;\n  const whole = parts.length === 1 ? parts[0]!.path : concatPaths(parts.map((p) => p.path));\n  // A one-part path is the part's own, which another reader may hold; the\n  // painter must not mistake that path for a painted one elsewhere.\n  const key = whole === parts[0]!.path ? { ...whole } as Path : whole;\n  PARTS.set(key, parts);\n  return key;\n}\n\n/** The parts `path` was made from by {@link pathFromParts}, or `undefined`\n *  for any other path. */\nexport function derivedPartsOf(path: Path | null | undefined): readonly DerivedPart[] | undefined {\n  return path == null ? undefined : PARTS.get(path);\n}\n\nfunction concatPaths(paths: readonly Path[]): PolygonPath {\n  const polys = paths.map((p) => (p.kind === 'rect' ? cubicContoursToPath(pathToCubicContours(p)) : p));\n  let commands = 0;\n  let coords = 0;\n  for (const p of polys) {\n    commands += p.commands.length;\n    coords += p.coords.length;\n  }\n  const out: PolygonPath = {\n    kind: 'polygon',\n    commands: new Uint8Array(commands),\n    coords: new Float32Array(coords),\n    fillRule: 'nonzero',\n  };\n  let ci = 0;\n  let xi = 0;\n  for (const p of polys) {\n    out.commands.set(p.commands, ci);\n    out.coords.set(p.coords, xi);\n    ci += p.commands.length;\n    xi += p.coords.length;\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;AAuBA,IAAM,wBAAQ,IAAI,QAAsC;;;;;AAMxD,SAAgB,cAAc,OAA4C;CACxE,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,MAAM,QAAQ,MAAM,WAAW,IAAI,MAAM,EAAE,CAAE,OAAO,YAAY,MAAM,KAAK,MAAM,EAAE,IAAI,CAAC;CAGxF,MAAM,MAAM,UAAU,MAAM,EAAE,CAAE,OAAO,EAAE,GAAG,MAAM,IAAY;CAC9D,MAAM,IAAI,KAAK,KAAK;CACpB,OAAO;AACT;;;AAIA,SAAgB,eAAe,MAAmE;CAChG,OAAO,QAAQ,OAAO,SAAY,MAAM,IAAI,IAAI;AAClD;AAEA,SAAS,YAAY,OAAqC;CACxD,MAAM,QAAQ,MAAM,KAAK,MAAO,EAAE,SAAS,SAAS,oBAAoB,oBAAoB,CAAC,CAAC,IAAI,CAAE;CACpG,IAAI,WAAW;CACf,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OAAO;EACrB,YAAY,EAAE,SAAS;EACvB,UAAU,EAAE,OAAO;CACrB;CACA,MAAM,MAAmB;EACvB,MAAM;EACN,UAAU,IAAI,WAAW,QAAQ;EACjC,QAAQ,IAAI,aAAa,MAAM;EAC/B,UAAU;CACZ;CACA,IAAI,KAAK;CACT,IAAI,KAAK;CACT,KAAK,MAAM,KAAK,OAAO;EACrB,IAAI,SAAS,IAAI,EAAE,UAAU,EAAE;EAC/B,IAAI,OAAO,IAAI,EAAE,QAAQ,EAAE;EAC3B,MAAM,EAAE,SAAS;EACjB,MAAM,EAAE,OAAO;CACjB;CACA,OAAO;AACT"}
+{"version":3,"file":"derivedParts.js","names":[],"sources":["../../../src/core/scene/derivedParts.ts"],"sourcesContent":["/**\n * A derived path that paints in several parts, each with its own fill and\n * stroke: the steps of a blend, the copies of a repeat.\n *\n * A derivation returns one `Path`, which is what picking, bounds and every\n * reader of `DerivedDep.path` see. {@link pathFromParts} makes that path out\n * of the parts and remembers the parts against it, so the derived-node\n * painter, handed the path, can paint each part as itself. The parts live as\n * long as the path does — in the derivation's memo.\n */\nimport type { InheritedPaint } from './inheritedPaint';\nimport { pathToCubicContours, cubicContoursToPath, type Path, type PolygonPath } from '@weasel-js/geom';\nimport {\n  resolveFill, resolveStroke, type Fill, type Inherit, type PaintedFill, type PaintedStroke, type Stroke,\n} from '@weasel-js/paint';\n\n/** One painted piece of a derived path. */\nexport interface DerivedPart {\n  path: Path;\n  /** The part's fill, read as a node's is: absent paints none, and\n   *  `INHERIT` takes the node's own `data.fill`. */\n  fill?: Fill | Inherit | null;\n  /** The part's stroke, on the same terms as `fill`. */\n  stroke?: Stroke | Inherit | null;\n}\n\n/** What `part` paints, its `INHERIT` taken from `own`, the deriving node's\n *  data — whose own `INHERIT` takes `inherited`, its container's. */\nexport function resolvePartPaint(\n  part: DerivedPart,\n  own: { fill?: Fill | Inherit | null; stroke?: Stroke | Inherit | null } | null | undefined,\n  inherited?: InheritedPaint,\n): { fill: PaintedFill | null; stroke: PaintedStroke | null } {\n  return {\n    fill: resolveFill(part.fill, resolveFill(own?.fill, inherited?.fill)),\n    stroke: resolveStroke(part.stroke, resolveStroke(own?.stroke, inherited?.stroke)),\n  };\n}\n\nconst PARTS = new WeakMap<Path, readonly DerivedPart[]>();\n\n/**\n * One path holding every part's outline, with the parts remembered against\n * it for the painter. Return it from a `derivePath`. `null` for no parts.\n */\nexport function pathFromParts(parts: readonly DerivedPart[]): Path | null {\n  if (parts.length === 0) return null;\n  const whole = parts.length === 1 ? parts[0]!.path : concatPaths(parts.map((p) => p.path));\n  // A one-part path is the part's own, which another reader may hold; the\n  // painter must not mistake that path for a painted one elsewhere.\n  const key = whole === parts[0]!.path ? { ...whole } as Path : whole;\n  PARTS.set(key, parts);\n  return key;\n}\n\n/** The parts `path` was made from by {@link pathFromParts}, or `undefined`\n *  for any other path. */\nexport function derivedPartsOf(path: Path | null | undefined): readonly DerivedPart[] | undefined {\n  return path == null ? undefined : PARTS.get(path);\n}\n\nfunction concatPaths(paths: readonly Path[]): PolygonPath {\n  const polys = paths.map((p) => (p.kind === 'rect' ? cubicContoursToPath(pathToCubicContours(p)) : p));\n  let commands = 0;\n  let coords = 0;\n  for (const p of polys) {\n    commands += p.commands.length;\n    coords += p.coords.length;\n  }\n  const out: PolygonPath = {\n    kind: 'polygon',\n    commands: new Uint8Array(commands),\n    coords: new Float32Array(coords),\n    fillRule: 'nonzero',\n  };\n  let ci = 0;\n  let xi = 0;\n  for (const p of polys) {\n    out.commands.set(p.commands, ci);\n    out.coords.set(p.coords, xi);\n    ci += p.commands.length;\n    xi += p.coords.length;\n  }\n  return out;\n}\n"],"mappings":";;;;;;AA4BA,SAAgB,iBACd,MACA,KACA,WAC4D;CAC5D,OAAO;EACL,MAAM,YAAY,KAAK,MAAM,YAAY,KAAK,MAAM,WAAW,IAAI,CAAC;EACpE,QAAQ,cAAc,KAAK,QAAQ,cAAc,KAAK,QAAQ,WAAW,MAAM,CAAC;CAClF;AACF;AAEA,IAAM,wBAAQ,IAAI,QAAsC;;;;;AAMxD,SAAgB,cAAc,OAA4C;CACxE,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,MAAM,QAAQ,MAAM,WAAW,IAAI,MAAM,EAAE,CAAE,OAAO,YAAY,MAAM,KAAK,MAAM,EAAE,IAAI,CAAC;CAGxF,MAAM,MAAM,UAAU,MAAM,EAAE,CAAE,OAAO,EAAE,GAAG,MAAM,IAAY;CAC9D,MAAM,IAAI,KAAK,KAAK;CACpB,OAAO;AACT;;;AAIA,SAAgB,eAAe,MAAmE;CAChG,OAAO,QAAQ,OAAO,SAAY,MAAM,IAAI,IAAI;AAClD;AAEA,SAAS,YAAY,OAAqC;CACxD,MAAM,QAAQ,MAAM,KAAK,MAAO,EAAE,SAAS,SAAS,oBAAoB,oBAAoB,CAAC,CAAC,IAAI,CAAE;CACpG,IAAI,WAAW;CACf,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OAAO;EACrB,YAAY,EAAE,SAAS;EACvB,UAAU,EAAE,OAAO;CACrB;CACA,MAAM,MAAmB;EACvB,MAAM;EACN,UAAU,IAAI,WAAW,QAAQ;EACjC,QAAQ,IAAI,aAAa,MAAM;EAC/B,UAAU;CACZ;CACA,IAAI,KAAK;CACT,IAAI,KAAK;CACT,KAAK,MAAM,KAAK,OAAO;EACrB,IAAI,SAAS,IAAI,EAAE,UAAU,EAAE;EAC/B,IAAI,OAAO,IAAI,EAAE,QAAQ,EAAE;EAC3B,MAAM,EAAE,SAAS;EACjB,MAAM,EAAE,OAAO;CACjB;CACA,OAAO;AACT"}

package/dist/core/scene/docValues.js

@@ -0,0 +1,57 @@
+import { deepEqual } from "@weasel-js/registry";
+
+//#region src/core/scene/docValues.ts
+/**
+* Document state that is not a node — a document's pages, its theme — held as
+* named JSON values beside the tree, saved in its snapshot and undone with it.
+*/
+var SET_DOC = "kit:setDoc";
+function write(values, key, to) {
+	if (to === void 0) values.delete(key);
+	else values.set(key, to);
+}
+/** The snapshot side of a scene's document values, kept in `values`. */
+function createDocStore(values) {
+	return {
+		/** The values as a snapshot holds them, or `undefined` when there are none. */
+		toJSON() {
+			return values.size === 0 ? void 0 : Object.fromEntries(values);
+		},
+		/** Replace every value, outside history. */
+		reset(next) {
+			values.clear();
+			for (const [key, value] of Object.entries(next ?? {})) write(values, key, value);
+		}
+	};
+}
+/** Register `kit:setDoc` and answer with the `SceneDoc` that records it. */
+function createSceneDoc(env) {
+	const { values } = env;
+	env.register(SET_DOC, {
+		apply: (p) => {
+			const { key, to } = p;
+			write(values, key, to);
+		},
+		revert: (p) => {
+			const { key, from } = p;
+			write(values, key, from);
+		}
+	});
+	return {
+		get: (key) => values.get(key),
+		set(key, to) {
+			const from = values.get(key);
+			if (deepEqual(from, to)) return;
+			env.record(SET_DOC, {
+				key,
+				from,
+				to
+			}, "setDoc");
+		},
+		keys: () => [...values.keys()]
+	};
+}
+
+//#endregion
+export { createDocStore, createSceneDoc };
+//# sourceMappingURL=docValues.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docValues.js","names":[],"sources":["../../../src/core/scene/docValues.ts"],"sourcesContent":["/**\n * Document state that is not a node — a document's pages, its theme — held as\n * named JSON values beside the tree, saved in its snapshot and undone with it.\n */\nimport { deepEqual } from '@weasel-js/registry';\nimport type { RegisteredOp } from './types';\n\n/**\n * A scene's document values. Keys are namespaced by their owner\n * (`core:pages`, `diagram:theme`); values are JSON, and are not to be mutated\n * once set. A `set` is a scene edit: undoable, part of an enclosing `batch`,\n * skipped when the value is deep-equal to the current one, and heard by\n * `subscribe`. Setting `undefined` removes the key.\n */\nexport interface SceneDoc {\n  get<T = unknown>(key: string): T | undefined;\n  set(key: string, value: unknown): void;\n  keys(): readonly string[];\n}\n\n/** The part of `Scene` that carries its document values. */\nexport interface SceneDocValues {\n  readonly doc: SceneDoc;\n}\n\n/** A snapshot's document values. */\nexport type SerializedDoc = Readonly<Record<string, unknown>>;\n\n/** `undefined` on either side means the key is absent there. */\ninterface SetDocPayload { key: string; from?: unknown; to?: unknown }\n\nconst SET_DOC = 'kit:setDoc';\n\nfunction write(values: Map<string, unknown>, key: string, to: unknown): void {\n  if (to === undefined) values.delete(key);\n  else values.set(key, to);\n}\n\n/** The snapshot side of a scene's document values, kept in `values`. */\nexport function createDocStore(values: Map<string, unknown>) {\n  return {\n    /** The values as a snapshot holds them, or `undefined` when there are none. */\n    toJSON(): SerializedDoc | undefined {\n      return values.size === 0 ? undefined : Object.fromEntries(values);\n    },\n    /** Replace every value, outside history. */\n    reset(next: SerializedDoc | undefined): void {\n      values.clear();\n      for (const [key, value] of Object.entries(next ?? {})) write(values, key, value);\n    },\n  };\n}\n\nexport interface SceneDocEnv {\n  values: Map<string, unknown>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  record(kind: string, payload: unknown, label: string): void;\n}\n\n/** Register `kit:setDoc` and answer with the `SceneDoc` that records it. */\nexport function createSceneDoc(env: SceneDocEnv): SceneDoc {\n  const { values } = env;\n  env.register(SET_DOC, {\n    apply: (p) => { const { key, to } = p as SetDocPayload; write(values, key, to); },\n    revert: (p) => { const { key, from } = p as SetDocPayload; write(values, key, from); },\n  });\n  return {\n    get: <T>(key: string) => values.get(key) as T | undefined,\n    set(key, to) {\n      const from = values.get(key);\n      if (deepEqual(from, to)) return;\n      env.record(SET_DOC, { key, from, to } satisfies SetDocPayload, 'setDoc');\n    },\n    keys: () => [...values.keys()],\n  };\n}\n"],"mappings":";;;;;;;AA+BA,IAAM,UAAU;AAEhB,SAAS,MAAM,QAA8B,KAAa,IAAmB;CAC3E,IAAI,OAAO,QAAW,OAAO,OAAO,GAAG;MAClC,OAAO,IAAI,KAAK,EAAE;AACzB;;AAGA,SAAgB,eAAe,QAA8B;CAC3D,OAAO;;EAEL,SAAoC;GAClC,OAAO,OAAO,SAAS,IAAI,SAAY,OAAO,YAAY,MAAM;EAClE;;EAEA,MAAM,MAAuC;GAC3C,OAAO,MAAM;GACb,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAAC,CAAC,GAAG,MAAM,QAAQ,KAAK,KAAK;EACjF;CACF;AACF;;AASA,SAAgB,eAAe,KAA4B;CACzD,MAAM,EAAE,WAAW;CACnB,IAAI,SAAS,SAAS;EACpB,QAAQ,MAAM;GAAE,MAAM,EAAE,KAAK,OAAO;GAAoB,MAAM,QAAQ,KAAK,EAAE;EAAG;EAChF,SAAS,MAAM;GAAE,MAAM,EAAE,KAAK,SAAS;GAAoB,MAAM,QAAQ,KAAK,IAAI;EAAG;CACvF,CAAC;CACD,OAAO;EACL,MAAS,QAAgB,OAAO,IAAI,GAAG;EACvC,IAAI,KAAK,IAAI;GACX,MAAM,OAAO,OAAO,IAAI,GAAG;GAC3B,IAAI,UAAU,MAAM,EAAE,GAAG;GACzB,IAAI,OAAO,SAAS;IAAE;IAAK;IAAM;GAAG,GAA2B,QAAQ;EACzE;EACA,YAAY,CAAC,GAAG,OAAO,KAAK,CAAC;CAC/B;AACF"}

package/dist/core/scene/editPass.js

@@ -0,0 +1,111 @@
+//#region src/core/scene/editPass.ts
+var emptyCollecting = () => ({
+	added: /* @__PURE__ */ new Set(),
+	removed: /* @__PURE__ */ new Set(),
+	posed: /* @__PURE__ */ new Set(),
+	reparented: /* @__PURE__ */ new Set(),
+	dataChanged: /* @__PURE__ */ new Set(),
+	docChanged: /* @__PURE__ */ new Set()
+});
+var snapshot = (c) => ({
+	added: new Set(c.added),
+	removed: new Set(c.removed),
+	posed: new Set(c.posed),
+	reparented: new Set(c.reparented),
+	dataChanged: new Set(c.dataChanged),
+	docChanged: new Set(c.docChanged)
+});
+var NOOP = {
+	name: "editPass",
+	args: {},
+	elideNoop: true,
+	apply: () => "noop",
+	invert: () => NOOP
+};
+/** Note one kit op's ids into `into`. */
+function noteInto(into, kind, payload) {
+	const p = payload;
+	switch (kind) {
+		case "kit:add":
+			into.added.add(p.id);
+			break;
+		case "kit:remove":
+			for (const n of p.nodes ?? []) into.removed.add(n.id);
+			break;
+		case "kit:setPose":
+			into.posed.add(p.id);
+			break;
+		case "kit:setData":
+			into.dataChanged.add(p.id);
+			break;
+		case "kit:setDoc":
+			into.docChanged.add(p.key);
+			break;
+		case "kit:move": if (p.fromParent !== p.toParent) into.reparented.add(p.id);
+	}
+}
+function createEditPasses(env) {
+	/** Sorted by order; equal orders keep the order they were added in. */
+	const passes = [];
+	let collecting = null;
+	function run() {
+		const summary = collecting;
+		if (summary === null) return 0;
+		let applied = 0;
+		try {
+			for (const { pass } of [...passes]) {
+				const ops = pass(snapshot(summary));
+				if (ops === null) continue;
+				const adapter = env.adapter();
+				for (const op of ops) {
+					op.apply(adapter);
+					applied++;
+				}
+			}
+		} finally {
+			collecting = null;
+		}
+		return applied;
+	}
+	return {
+		add(pass, opts) {
+			const entry = {
+				pass,
+				order: opts?.order ?? 0
+			};
+			const at = passes.findIndex((p) => p.order > entry.order);
+			passes.splice(at < 0 ? passes.length : at, 0, entry);
+			return () => {
+				const i = passes.indexOf(entry);
+				if (i >= 0) passes.splice(i, 1);
+			};
+		},
+		any: () => passes.length > 0,
+		open() {
+			if (collecting !== null || passes.length === 0) return false;
+			collecting = emptyCollecting();
+			return true;
+		},
+		note(kind, payload) {
+			if (collecting !== null && !env.untracked()) noteInto(collecting, kind, payload);
+		},
+		run,
+		abandon() {
+			collecting = null;
+		},
+		op() {
+			return {
+				name: "editPass",
+				args: {},
+				label: "Edit pass",
+				elideNoop: true,
+				apply: () => run() > 0 ? void 0 : "noop",
+				invert: () => NOOP
+			};
+		}
+	};
+}
+
+//#endregion
+export { createEditPasses };
+//# sourceMappingURL=editPass.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editPass.js","names":[],"sources":["../../../src/core/scene/editPass.ts"],"sourcesContent":["/**\n * Scene edit passes: functions that hear what a live edit did, once its own\n * mutations and the arrival handler have run, and answer with ops that join\n * the same undo entry.\n *\n * Passes run by ascending order, and each hears the edit's own changes plus\n * every write the passes before it made. A pass still runs once per edit, so\n * none re-triggers itself or another. Undo, redo, and history replays never\n * run passes: they restore an edit whose passes already ran.\n */\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from './types';\n\n/** What one live edit did to the scene's nodes, by id. */\nexport interface SceneEditSummary {\n  added: ReadonlySet<NodeId>;\n  removed: ReadonlySet<NodeId>;\n  posed: ReadonlySet<NodeId>;\n  /** Nodes that changed parent. A reorder among siblings is not here. */\n  reparented: ReadonlySet<NodeId>;\n  dataChanged: ReadonlySet<NodeId>;\n  /** The document-value keys (`scene.doc`) set. */\n  docChanged: ReadonlySet<string>;\n}\n\n/** Where a pass runs among the others. */\nexport interface SceneEditPassOptions {\n  /** Passes run by ascending order, ties in the order they were added.\n   *  Default 0. */\n  order?: number;\n}\n\n/** A scene edit pass: the ops `summary`'s edit also makes, or null for none. */\nexport type SceneEditPass = (summary: SceneEditSummary) => readonly Op[] | null;\n\n/** The scene's edit-pass member. */\nexport interface SceneEditPasses {\n  /** Add a pass that hears each live edit once its own mutations and the\n   *  arrival handler have run, and answers with ops that join the same undo\n   *  entry. A bare scene call runs as an edit of its own while any pass is\n   *  added. A pass hears what the passes ordered before it wrote, never what\n   *  it or a later one writes, and undo, redo, and history replays never run\n   *  it. Returns the pass's remover. */\n  addEditPass(pass: SceneEditPass, opts?: SceneEditPassOptions): () => void;\n}\n\n/** What the passes need from the scene they serve. */\nexport interface EditPassEnv {\n  /** The adapter a pass's ops apply through. */\n  adapter(): unknown;\n  /** Whether an edit made now is untracked, and so not summarized. */\n  untracked(): boolean;\n}\n\nexport interface EditPasses {\n  /** Add a pass after every one of its order or lower. Returns its remover. */\n  add(pass: SceneEditPass, opts?: SceneEditPassOptions): () => void;\n  /** Whether any pass is installed. */\n  any(): boolean;\n  /** Start summarizing an edit when a pass is installed and no enclosing edit\n   *  is summarizing already; true when this caller now owns the summary. */\n  open(): boolean;\n  /** Note what a live kit op is about to write. */\n  note(kind: string, payload: unknown): void;\n  /** Run every pass in order, each over the summary as it stands at its\n   *  turn, applying its ops into that summary; then close it. Answers how\n   *  many ops applied. */\n  run(): number;\n  /** Close the summary with nothing run. */\n  abandon(): void;\n  /** An op that runs the passes when it first applies, for the end of an\n   *  op-driven edit whose summary the caller owns. */\n  op(): Op;\n}\n\ninterface Collecting {\n  added: Set<NodeId>;\n  removed: Set<NodeId>;\n  posed: Set<NodeId>;\n  reparented: Set<NodeId>;\n  dataChanged: Set<NodeId>;\n  docChanged: Set<string>;\n}\n\nconst emptyCollecting = (): Collecting => ({\n  added: new Set(), removed: new Set(), posed: new Set(), reparented: new Set(), dataChanged: new Set(), docChanged: new Set(),\n});\n\nconst snapshot = (c: Collecting): SceneEditSummary => ({\n  added: new Set(c.added),\n  removed: new Set(c.removed),\n  posed: new Set(c.posed),\n  reparented: new Set(c.reparented),\n  dataChanged: new Set(c.dataChanged),\n  docChanged: new Set(c.docChanged),\n});\n\nconst NOOP: Op = { name: 'editPass', args: {}, elideNoop: true, apply: () => 'noop', invert: () => NOOP };\n\n/** Note one kit op's ids into `into`. */\nfunction noteInto(into: Collecting, kind: string, payload: unknown): void {\n  const p = payload as { id?: NodeId; key?: string; nodes?: readonly { id: NodeId }[]; fromParent?: NodeId | null; toParent?: NodeId | null };\n  switch (kind) {\n    case 'kit:add': into.added.add(p.id!); break;\n    case 'kit:remove': for (const n of p.nodes ?? []) into.removed.add(n.id); break;\n    case 'kit:setPose': into.posed.add(p.id!); break;\n    case 'kit:setData': into.dataChanged.add(p.id!); break;\n    case 'kit:setDoc': into.docChanged.add(p.key!); break;\n    case 'kit:move': if (p.fromParent !== p.toParent) into.reparented.add(p.id!); break;\n    default: break;\n  }\n}\n\nexport function createEditPasses(env: EditPassEnv): EditPasses {\n  /** Sorted by order; equal orders keep the order they were added in. */\n  const passes: { pass: SceneEditPass; order: number }[] = [];\n  let collecting: Collecting | null = null;\n\n  function run(): number {\n    const summary = collecting;\n    if (summary === null) return 0;\n    let applied = 0;\n    try {\n      for (const { pass } of [...passes]) {\n        const ops = pass(snapshot(summary));\n        if (ops === null) continue;\n        const adapter = env.adapter();\n        for (const op of ops) {\n          op.apply(adapter);\n          applied++;\n        }\n      }\n    } finally {\n      collecting = null;\n    }\n    return applied;\n  }\n\n  return {\n    add(pass, opts) {\n      const entry = { pass, order: opts?.order ?? 0 };\n      const at = passes.findIndex((p) => p.order > entry.order);\n      passes.splice(at < 0 ? passes.length : at, 0, entry);\n      return () => {\n        const i = passes.indexOf(entry);\n        if (i >= 0) passes.splice(i, 1);\n      };\n    },\n    any: () => passes.length > 0,\n    open() {\n      if (collecting !== null || passes.length === 0) return false;\n      collecting = emptyCollecting();\n      return true;\n    },\n    note(kind, payload) {\n      if (collecting !== null && !env.untracked()) noteInto(collecting, kind, payload);\n    },\n    run,\n    abandon() {\n      collecting = null;\n    },\n    op() {\n      return {\n        name: 'editPass',\n        args: {},\n        label: 'Edit pass',\n        elideNoop: true,\n        apply: () => (run() > 0 ? undefined : 'noop'),\n        invert: () => NOOP,\n      };\n    },\n  };\n}\n"],"mappings":";AAoFA,IAAM,yBAAqC;CACzC,uBAAO,IAAI,IAAI;CAAG,yBAAS,IAAI,IAAI;CAAG,uBAAO,IAAI,IAAI;CAAG,4BAAY,IAAI,IAAI;CAAG,6BAAa,IAAI,IAAI;CAAG,4BAAY,IAAI,IAAI;AAC7H;AAEA,IAAM,YAAY,OAAqC;CACrD,OAAO,IAAI,IAAI,EAAE,KAAK;CACtB,SAAS,IAAI,IAAI,EAAE,OAAO;CAC1B,OAAO,IAAI,IAAI,EAAE,KAAK;CACtB,YAAY,IAAI,IAAI,EAAE,UAAU;CAChC,aAAa,IAAI,IAAI,EAAE,WAAW;CAClC,YAAY,IAAI,IAAI,EAAE,UAAU;AAClC;AAEA,IAAM,OAAW;CAAE,MAAM;CAAY,MAAM,CAAC;CAAG,WAAW;CAAM,aAAa;CAAQ,cAAc;AAAK;;AAGxG,SAAS,SAAS,MAAkB,MAAc,SAAwB;CACxE,MAAM,IAAI;CACV,QAAQ,MAAR;EACE,KAAK;GAAW,KAAK,MAAM,IAAI,EAAE,EAAG;GAAG;EACvC,KAAK;GAAc,KAAK,MAAM,KAAK,EAAE,SAAS,CAAC,GAAG,KAAK,QAAQ,IAAI,EAAE,EAAE;GAAG;EAC1E,KAAK;GAAe,KAAK,MAAM,IAAI,EAAE,EAAG;GAAG;EAC3C,KAAK;GAAe,KAAK,YAAY,IAAI,EAAE,EAAG;GAAG;EACjD,KAAK;GAAc,KAAK,WAAW,IAAI,EAAE,GAAI;GAAG;EAChD,KAAK,YAAY,IAAI,EAAE,eAAe,EAAE,UAAU,KAAK,WAAW,IAAI,EAAE,EAAG;CAE7E;AACF;AAEA,SAAgB,iBAAiB,KAA8B;;CAE7D,MAAM,SAAmD,CAAC;CAC1D,IAAI,aAAgC;CAEpC,SAAS,MAAc;EACrB,MAAM,UAAU;EAChB,IAAI,YAAY,MAAM,OAAO;EAC7B,IAAI,UAAU;EACd,IAAI;GACF,KAAK,MAAM,EAAE,UAAU,CAAC,GAAG,MAAM,GAAG;IAClC,MAAM,MAAM,KAAK,SAAS,OAAO,CAAC;IAClC,IAAI,QAAQ,MAAM;IAClB,MAAM,UAAU,IAAI,QAAQ;IAC5B,KAAK,MAAM,MAAM,KAAK;KACpB,GAAG,MAAM,OAAO;KAChB;IACF;GACF;EACF,UAAU;GACR,aAAa;EACf;EACA,OAAO;CACT;CAEA,OAAO;EACL,IAAI,MAAM,MAAM;GACd,MAAM,QAAQ;IAAE;IAAM,OAAO,MAAM,SAAS;GAAE;GAC9C,MAAM,KAAK,OAAO,WAAW,MAAM,EAAE,QAAQ,MAAM,KAAK;GACxD,OAAO,OAAO,KAAK,IAAI,OAAO,SAAS,IAAI,GAAG,KAAK;GACnD,aAAa;IACX,MAAM,IAAI,OAAO,QAAQ,KAAK;IAC9B,IAAI,KAAK,GAAG,OAAO,OAAO,GAAG,CAAC;GAChC;EACF;EACA,WAAW,OAAO,SAAS;EAC3B,OAAO;GACL,IAAI,eAAe,QAAQ,OAAO,WAAW,GAAG,OAAO;GACvD,aAAa,gBAAgB;GAC7B,OAAO;EACT;EACA,KAAK,MAAM,SAAS;GAClB,IAAI,eAAe,QAAQ,CAAC,IAAI,UAAU,GAAG,SAAS,YAAY,MAAM,OAAO;EACjF;EACA;EACA,UAAU;GACR,aAAa;EACf;EACA,KAAK;GACH,OAAO;IACL,MAAM;IACN,MAAM,CAAC;IACP,OAAO;IACP,WAAW;IACX,aAAc,IAAI,IAAI,IAAI,SAAY;IACtC,cAAc;GAChB;EACF;CACF;AACF"}

package/dist/core/scene/effectivePose.js

@@ -86,6 +86,12 @@ function run(node, derive, deps, into) {
 function derivedDepOf(source, id, reader) {
 	return reader === void 0 ? depIn(source, id, "effective") : depsAsRead(source, reader, "effective")(id);
 }
+/** `id` as {@link derivedDepOf} answers it, but at the pose and path the
+*  document holds: no override anywhere down its dependencies counts. For a
+*  reader that must not see an in-flight gesture, such as an edit pass. */
+function documentDepOf(source, id) {
+	return depIn(source, id, "document");
+}
 /** `(id) => that dependency as `reader`'s derivation is handed it`: its pose
 *  in `reader`'s frame where the scene composes frames. A `'children'`
 *  dependent shares its children's frame, so it reads them as they are. */
@@ -189,9 +195,14 @@ function effectivePose(source, node) {
 * frame — and the composition fold passes over it.
 */
 function definesFrame(node) {
-	return !(node.dependsOn === "children" && node.derivePose !== void 0);
+	return !isEnvelope(node);
+}
+/** Whether `node` derives its pose from its children: a group that is its
+*  members, so moving them moves it. */
+function isEnvelope(node) {
+	return node.dependsOn === "children" && node.derivePose !== void 0;
 }
 
 //#endregion
-export { definesFrame, derivedDepOf, derivedPose, documentPose, effectivePose };
+export { definesFrame, derivedDepOf, derivedPose, documentDepOf, documentPose, effectivePose, isEnvelope };
 //# sourceMappingURL=effectivePose.js.map