@weasel-js/core 1.9.4 → 1.10.1

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

@@ -1 +1 @@
-{"version":3,"file":"nodeStore.js","names":["createNodeStore","dependents","createDependentsIndex","childDerived","invalidateDependents","invalidateChildDerivedFrom","state","id","subtree","src","dep","node","dropPoseKeyedMemoSlots","cursor","start","d","trackChildDerived","dependsOn","retarget","requireNode","n","siblingsOf","parent","p","detach","sibs","idx","invalidateOrder","attach","index","descendants","c","out","removalClosure","ids","removing","take","sub","s","root","rootIds","i","addedFns","patchNodeFunctions","attached","field","fnFields","fn","spec","payload","restoreNodeFunctions","keys","target","key","restoreFn","dwarn"],"sources":["../../../src/core/scene/nodeStore.ts"],"sourcesContent":["/**\n * The scene's node store: the tree links, the reverse index of who derives\n * from whom, and the function fields a node carries beside its data.\n *\n * Everything here reads and writes `state.nodes` and `state.roots` directly;\n * none of it records. The kit ops call it from both of their directions.\n */\nimport { dwarn } from 'debug/flag';\nimport { createDependentsIndex } from './dependents';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { restoreFn, type FnBearingNode, type NodeFn, type NodeFnField } from './nodeFnFields';\nimport type { AddNodeSpec, Node, NodeId } from './types';\n\n/** What the store keeps of a scene's state. */\nexport interface NodeStoreState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n}\n\nexport function createNodeStore<TData, TLayer extends string, TPose>(\n  state: NodeStoreState<TData, TLayer, TPose>,\n  /** Called on every edit to the tree's links. */\n  invalidateOrder: () => void,\n  fnFields: readonly NodeFnField[],\n) {\n  /** Maintained from `kit:add` / `kit:remove` — the only two places a node is\n   *  created or destroyed, and unlike `add`/`remove` they replay on undo/redo.\n   *  Only explicit `dependsOn` id lists are registered here; `'children'` is\n   *  the ancestor walk in `invalidateDependents` instead. */\n  const dependents = createDependentsIndex();\n\n  /** Nodes carrying `dependsOn: 'children'`. Empty in every scene that has no\n   *  container hugging its contents, which is what keeps the ancestor walk off\n   *  the hot path. */\n  const childDerived = new Set<NodeId>();\n\n  /** Walks `id`'s whole subtree: under a composing pose strategy a container's\n   *  move carries every descendant, and whatever derives from one. */\n  function invalidateDependents(id: NodeId): void {\n    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);\n    if (dependents.isEmpty()) return;\n    const subtree: NodeId[] = [id];\n    descendants(id, subtree);\n    for (const src of subtree) {\n      for (const dep of dependents.transitiveDependentsOf(src)) {\n        const node = state.nodes.get(dep);\n        if (node !== undefined) dropPoseKeyedMemoSlots(node);\n      }\n    }\n  }\n\n  /** A `dependsOn: 'children'` container derives from nodes the reverse index\n   *  never sees, so its invalidation runs the other way: up the parent chain\n   *  from `start` inclusive, and on to each such ancestor's own dependents.\n   *\n   *  Callers that removed or reparented a node pass the parent explicitly —\n   *  a gone node cannot say who its parent was. */\n  function invalidateChildDerivedFrom(start: NodeId | null): void {\n    if (childDerived.size === 0) return;\n    let cursor = start;\n    while (cursor !== null) {\n      const node = state.nodes.get(cursor);\n      if (node === undefined) return;\n      if (childDerived.has(cursor)) {\n        dropPoseKeyedMemoSlots(node);\n        for (const dep of dependents.transitiveDependentsOf(cursor)) {\n          const d = state.nodes.get(dep);\n          if (d !== undefined) dropPoseKeyedMemoSlots(d);\n        }\n      }\n      cursor = node.parent;\n    }\n  }\n\n  /** Track (or forget) a node whose `dependsOn` is `'children'`. Paired with\n   *  `dependents.add` / `.remove` at every site a node is created or destroyed. */\n  function trackChildDerived(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    if (dependsOn === 'children') childDerived.add(id);\n    else childDerived.delete(id);\n  }\n\n  /** Point `id` at a different set of dependencies, keeping both indices and\n   *  every memo that reads them in step. Shared by `kit:setDependsOn`'s two\n   *  directions, which differ only in which value they install.\n   *\n   *  `id`'s own memo is dropped as well as its dependents': its derivation now\n   *  reads different sources, and nothing else would clear it. */\n  function retarget(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    const node = requireNode(id) as { dependsOn?: readonly NodeId[] | 'children' };\n    if (dependsOn === undefined) delete node.dependsOn;\n    else node.dependsOn = dependsOn;\n    dependents.add(id, dependsOn === undefined || dependsOn === 'children' ? [] : dependsOn);\n    trackChildDerived(id, dependsOn);\n    dropPoseKeyedMemoSlots(requireNode(id));\n    invalidateDependents(id);\n  }\n\n  function requireNode(id: NodeId): Node<TData, TLayer, TPose> {\n    const n = state.nodes.get(id);\n    if (!n) throw new Error(`Scene: unknown node id \"${id}\"`);\n    return n;\n  }\n\n  function siblingsOf(parent: NodeId | null): NodeId[] {\n    if (parent === null) return state.roots;\n    const p = requireNode(parent);\n    if (p.kind !== 'container') {\n      throw new Error(`Scene: parent \"${parent}\" is not a container`);\n    }\n    return p.children;\n  }\n\n  function detach(id: NodeId): { parent: NodeId | null; index: number } {\n    const node = requireNode(id);\n    const sibs = siblingsOf(node.parent);\n    const idx = sibs.indexOf(id);\n    if (idx < 0) throw new Error(`Scene: node \"${id}\" not found in its parent's children`);\n    sibs.splice(idx, 1);\n    invalidateOrder();\n    return { parent: node.parent, index: idx };\n  }\n\n  function attach(id: NodeId, parent: NodeId | null, index: number): void {\n    const sibs = siblingsOf(parent);\n    const i = Math.max(0, Math.min(index, sibs.length));\n    sibs.splice(i, 0, id);\n    const node = requireNode(id);\n    (node as { parent: NodeId | null }).parent = parent;\n    invalidateOrder();\n  }\n\n  function descendants(id: NodeId, out: NodeId[]): void {\n    const n = state.nodes.get(id);\n    if (!n || n.kind !== 'container') return;\n    for (const c of n.children) {\n      out.push(c);\n      descendants(c, out);\n    }\n  }\n\n  /** Everything removing `rootIds` takes with it: each root's subtree, then\n   *  every node deriving from any of those, then those nodes' subtrees in turn.\n   *  A dependent is not a descendant, so the second pass is a separate\n   *  reachability walk; `ids` grows as it runs, which is what carries the\n   *  cascade transitively and upward through a dependent's own ancestors.\n   *\n   *  Published as {@link Scene.removalClosure}, which is what the delete op and\n   *  `buildDeleteOps` ask instead of rebuilding the walk from `dependsOn` and\n   *  `children` — a third cascade relation is then added here alone. */\n  function removalClosure(rootIds: readonly NodeId[]): {\n    ids: NodeId[];\n    removing: Set<NodeId>;\n  } {\n    const ids: NodeId[] = [];\n    const removing = new Set<NodeId>();\n    function take(id: NodeId): void {\n      if (removing.has(id)) return;\n      removing.add(id);\n      ids.push(id);\n      const sub: NodeId[] = [];\n      descendants(id, sub);\n      for (const s of sub) {\n        if (removing.has(s)) continue;\n        removing.add(s);\n        ids.push(s);\n      }\n    }\n    for (const root of rootIds) take(root);\n    for (let i = 0; i < ids.length; i++) {\n      for (const dep of dependents.transitiveDependentsOf(ids[i])) take(dep);\n    }\n    return { ids, removing };\n  }\n\n  /** The functions a live `scene.add` attached, by the `kit:add` payload it\n   *  recorded: redo replays that payload without the spec. Keyed on the\n   *  payload rather than the node id because an id is reusable, and each\n   *  add of it owns its own functions. */\n  const addedFns = new WeakMap<object, Map<NodeFnField, NodeFn>>();\n\n  /** Post-patch the registry-keyed function fields onto a node after its\n   *  `kit:add` op runs. A function cannot travel through the serializable op\n   *  payload, so it is attached to the live node here, and kept against\n   *  `payload` for redo when there is one. `dependsOn` is plain data and\n   *  rides the payload instead. */\n  function patchNodeFunctions(\n    spec: AddNodeSpec<TData, TLayer, TPose>,\n    id: NodeId,\n    payload: object | null,\n  ): void {\n    const node = state.nodes.get(id) as FnBearingNode | undefined;\n    if (node === undefined) return;\n    const attached = new Map<NodeFnField, NodeFn>();\n    for (const field of fnFields) {\n      const fn = (spec as unknown as Record<string, unknown>)[field.spec.field] as NodeFn | undefined;\n      if (fn === undefined) continue;\n      if (field.spec.containersOnly && spec.kind !== 'container') continue;\n      field.write(node, fn);\n      attached.set(field, fn);\n    }\n    if (payload && attached.size > 0) addedFns.set(payload, attached);\n  }\n\n  /** Re-attach those fields to a node restored from a `kit:remove` snapshot.\n   *  In-session the clone already carries them; a persisted history does not,\n   *  so the registry keys are what is left. */\n  function restoreNodeFunctions(\n    node: Node<TData, TLayer, TPose>,\n    keys: Record<string, string | undefined> | undefined,\n  ): void {\n    if (!keys) return;\n    const target = node as unknown as FnBearingNode;\n    for (const field of fnFields) {\n      if (field.read(target) !== undefined) continue;\n      const key = keys[field.spec.opKey];\n      if (key === undefined) continue;\n      restoreFn(field, target, key, 'kit:remove', dwarn);\n    }\n  }\n\n  return {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, siblingsOf, detach, attach, descendants, removalClosure, addedFns, patchNodeFunctions,\n    restoreNodeFunctions,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"nodeStore.js","names":["createNodeStore","dependents","createDependentsIndex","childDerived","invalidateDependents","invalidateChildDerivedFrom","state","id","subtree","src","dep","node","dropPoseKeyedMemoSlots","cursor","start","d","trackChildDerived","dependsOn","retarget","requireNode","n","SceneMembershipError","siblingsOf","parent","p","detach","sibs","idx","invalidateOrder","attach","index","descendants","c","out","removalClosure","ids","removing","take","sub","s","root","rootIds","i","addedFns","patchNodeFunctions","attached","field","fnFields","fn","spec","payload","restoreNodeFunctions","keys","target","key","restoreFn","dwarn"],"sources":["../../../src/core/scene/nodeStore.ts"],"sourcesContent":["/**\n * The scene's node store: the tree links, the reverse index of who derives\n * from whom, and the function fields a node carries beside its data.\n *\n * Everything here reads and writes `state.nodes` and `state.roots` directly;\n * none of it records. The kit ops call it from both of their directions.\n */\nimport { dwarn } from 'debug/flag';\nimport { createDependentsIndex } from './dependents';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { restoreFn, type FnBearingNode, type NodeFn, type NodeFnField } from './nodeFnFields';\nimport { SceneMembershipError } from './staleReplay';\nimport type { AddNodeSpec, Node, NodeId } from './types';\n\n/** What the store keeps of a scene's state. */\nexport interface NodeStoreState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n}\n\nexport function createNodeStore<TData, TLayer extends string, TPose>(\n  state: NodeStoreState<TData, TLayer, TPose>,\n  /** Called on every edit to the tree's links. */\n  invalidateOrder: () => void,\n  fnFields: readonly NodeFnField[],\n) {\n  /** Maintained from `kit:add` / `kit:remove` — the only two places a node is\n   *  created or destroyed, and unlike `add`/`remove` they replay on undo/redo.\n   *  Only explicit `dependsOn` id lists are registered here; `'children'` is\n   *  the ancestor walk in `invalidateDependents` instead. */\n  const dependents = createDependentsIndex();\n\n  /** Nodes carrying `dependsOn: 'children'`. Empty in every scene that has no\n   *  container hugging its contents, which is what keeps the ancestor walk off\n   *  the hot path. */\n  const childDerived = new Set<NodeId>();\n\n  /** Walks `id`'s whole subtree: under a composing pose strategy a container's\n   *  move carries every descendant, and whatever derives from one. */\n  function invalidateDependents(id: NodeId): void {\n    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);\n    if (dependents.isEmpty()) return;\n    const subtree: NodeId[] = [id];\n    descendants(id, subtree);\n    for (const src of subtree) {\n      for (const dep of dependents.transitiveDependentsOf(src)) {\n        const node = state.nodes.get(dep);\n        if (node !== undefined) dropPoseKeyedMemoSlots(node);\n      }\n    }\n  }\n\n  /** A `dependsOn: 'children'` container derives from nodes the reverse index\n   *  never sees, so its invalidation runs the other way: up the parent chain\n   *  from `start` inclusive, and on to each such ancestor's own dependents.\n   *\n   *  Callers that removed or reparented a node pass the parent explicitly —\n   *  a gone node cannot say who its parent was. */\n  function invalidateChildDerivedFrom(start: NodeId | null): void {\n    if (childDerived.size === 0) return;\n    let cursor = start;\n    while (cursor !== null) {\n      const node = state.nodes.get(cursor);\n      if (node === undefined) return;\n      if (childDerived.has(cursor)) {\n        dropPoseKeyedMemoSlots(node);\n        for (const dep of dependents.transitiveDependentsOf(cursor)) {\n          const d = state.nodes.get(dep);\n          if (d !== undefined) dropPoseKeyedMemoSlots(d);\n        }\n      }\n      cursor = node.parent;\n    }\n  }\n\n  /** Track (or forget) a node whose `dependsOn` is `'children'`. Paired with\n   *  `dependents.add` / `.remove` at every site a node is created or destroyed. */\n  function trackChildDerived(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    if (dependsOn === 'children') childDerived.add(id);\n    else childDerived.delete(id);\n  }\n\n  /** Point `id` at a different set of dependencies, keeping both indices and\n   *  every memo that reads them in step. Shared by `kit:setDependsOn`'s two\n   *  directions, which differ only in which value they install.\n   *\n   *  `id`'s own memo is dropped as well as its dependents': its derivation now\n   *  reads different sources, and nothing else would clear it. */\n  function retarget(id: NodeId, dependsOn: Node<TData, TLayer, TPose>['dependsOn']): void {\n    const node = requireNode(id) as { dependsOn?: readonly NodeId[] | 'children' };\n    if (dependsOn === undefined) delete node.dependsOn;\n    else node.dependsOn = dependsOn;\n    dependents.add(id, dependsOn === undefined || dependsOn === 'children' ? [] : dependsOn);\n    trackChildDerived(id, dependsOn);\n    dropPoseKeyedMemoSlots(requireNode(id));\n    invalidateDependents(id);\n  }\n\n  function requireNode(id: NodeId): Node<TData, TLayer, TPose> {\n    const n = state.nodes.get(id);\n    if (!n) throw new SceneMembershipError(`Scene: unknown node id \"${id}\"`);\n    return n;\n  }\n\n  function siblingsOf(parent: NodeId | null): NodeId[] {\n    if (parent === null) return state.roots;\n    const p = requireNode(parent);\n    if (p.kind !== 'container') {\n      throw new Error(`Scene: parent \"${parent}\" is not a container`);\n    }\n    return p.children;\n  }\n\n  function detach(id: NodeId): { parent: NodeId | null; index: number } {\n    const node = requireNode(id);\n    const sibs = siblingsOf(node.parent);\n    const idx = sibs.indexOf(id);\n    if (idx < 0) throw new Error(`Scene: node \"${id}\" not found in its parent's children`);\n    sibs.splice(idx, 1);\n    invalidateOrder();\n    return { parent: node.parent, index: idx };\n  }\n\n  function attach(id: NodeId, parent: NodeId | null, index: number): void {\n    const sibs = siblingsOf(parent);\n    const i = Math.max(0, Math.min(index, sibs.length));\n    sibs.splice(i, 0, id);\n    const node = requireNode(id);\n    (node as { parent: NodeId | null }).parent = parent;\n    invalidateOrder();\n  }\n\n  function descendants(id: NodeId, out: NodeId[]): void {\n    const n = state.nodes.get(id);\n    if (!n || n.kind !== 'container') return;\n    for (const c of n.children) {\n      out.push(c);\n      descendants(c, out);\n    }\n  }\n\n  /** Everything removing `rootIds` takes with it: each root's subtree, then\n   *  every node deriving from any of those, then those nodes' subtrees in turn.\n   *  A dependent is not a descendant, so the second pass is a separate\n   *  reachability walk; `ids` grows as it runs, which is what carries the\n   *  cascade transitively and upward through a dependent's own ancestors.\n   *\n   *  Published as {@link Scene.removalClosure}, which is what the delete op and\n   *  `buildDeleteOps` ask instead of rebuilding the walk from `dependsOn` and\n   *  `children` — a third cascade relation is then added here alone. */\n  function removalClosure(rootIds: readonly NodeId[]): {\n    ids: NodeId[];\n    removing: Set<NodeId>;\n  } {\n    const ids: NodeId[] = [];\n    const removing = new Set<NodeId>();\n    function take(id: NodeId): void {\n      if (removing.has(id)) return;\n      removing.add(id);\n      ids.push(id);\n      const sub: NodeId[] = [];\n      descendants(id, sub);\n      for (const s of sub) {\n        if (removing.has(s)) continue;\n        removing.add(s);\n        ids.push(s);\n      }\n    }\n    for (const root of rootIds) take(root);\n    for (let i = 0; i < ids.length; i++) {\n      for (const dep of dependents.transitiveDependentsOf(ids[i])) take(dep);\n    }\n    return { ids, removing };\n  }\n\n  /** The functions a live `scene.add` attached, by the `kit:add` payload it\n   *  recorded: redo replays that payload without the spec. Keyed on the\n   *  payload rather than the node id because an id is reusable, and each\n   *  add of it owns its own functions. */\n  const addedFns = new WeakMap<object, Map<NodeFnField, NodeFn>>();\n\n  /** Post-patch the registry-keyed function fields onto a node after its\n   *  `kit:add` op runs. A function cannot travel through the serializable op\n   *  payload, so it is attached to the live node here, and kept against\n   *  `payload` for redo when there is one. `dependsOn` is plain data and\n   *  rides the payload instead. */\n  function patchNodeFunctions(\n    spec: AddNodeSpec<TData, TLayer, TPose>,\n    id: NodeId,\n    payload: object | null,\n  ): void {\n    const node = state.nodes.get(id) as FnBearingNode | undefined;\n    if (node === undefined) return;\n    const attached = new Map<NodeFnField, NodeFn>();\n    for (const field of fnFields) {\n      const fn = (spec as unknown as Record<string, unknown>)[field.spec.field] as NodeFn | undefined;\n      if (fn === undefined) continue;\n      if (field.spec.containersOnly && spec.kind !== 'container') continue;\n      field.write(node, fn);\n      attached.set(field, fn);\n    }\n    if (payload && attached.size > 0) addedFns.set(payload, attached);\n  }\n\n  /** Re-attach those fields to a node restored from a `kit:remove` snapshot.\n   *  In-session the clone already carries them; a persisted history does not,\n   *  so the registry keys are what is left. */\n  function restoreNodeFunctions(\n    node: Node<TData, TLayer, TPose>,\n    keys: Record<string, string | undefined> | undefined,\n  ): void {\n    if (!keys) return;\n    const target = node as unknown as FnBearingNode;\n    for (const field of fnFields) {\n      if (field.read(target) !== undefined) continue;\n      const key = keys[field.spec.opKey];\n      if (key === undefined) continue;\n      restoreFn(field, target, key, 'kit:remove', dwarn);\n    }\n  }\n\n  return {\n    dependents, childDerived, invalidateDependents, invalidateChildDerivedFrom, trackChildDerived, retarget,\n    requireNode, siblingsOf, detach, attach, descendants, removalClosure, addedFns, patchNodeFunctions,\n    restoreNodeFunctions,\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/notifier.js

@@ -0,0 +1,37 @@
+import { createEmitter as e } from "@weasel-js/registry";
+//#region src/core/scene/notifier.ts
+function t() {
+	let t = e(), n = 0, r = 0, i = !1;
+	return {
+		notify() {
+			if (n++, r > 0) {
+				i = !0;
+				return;
+			}
+			t.emit();
+		},
+		version: () => n,
+		subscribe: t.subscribe,
+		deferred(e, n) {
+			r++;
+			try {
+				return e();
+			} finally {
+				r--, n?.(), r === 0 && i && (i = !1, t.emit());
+			}
+		},
+		muted(e) {
+			let t = i;
+			r++;
+			try {
+				return e();
+			} finally {
+				r--, i = t;
+			}
+		}
+	};
+}
+//#endregion
+export { t as createNotifier };
+
+//# sourceMappingURL=notifier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.js","names":["createNotifier","changed","createEmitter","version","held","pending","fn","settle","was"],"sources":["../../../src/core/scene/notifier.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\n\n/**\n * The scene's change notice: its version, its subscribers, and when a change\n * reaches them.\n */\nexport interface Notifier {\n  /** Count a change, and call the subscribers unless the call is held. */\n  notify(): void;\n  version(): number;\n  subscribe(listener: () => void): () => void;\n  /** Run `fn` with the calls it causes held, then make one for all of them\n   *  once the outermost holder is done. `settle` runs between the two: after\n   *  this holder has let go, before any subscriber is called. */\n  deferred<T>(fn: () => T, settle?: () => void): T;\n  /** Run `fn` with the calls it causes held and then dropped: its caller\n   *  notifies once itself. The version still counts each one. */\n  muted<T>(fn: () => T): T;\n}\n\nexport function createNotifier(): Notifier {\n  const changed = createEmitter();\n  let version = 0;\n  let held = 0;\n  let pending = false;\n\n  return {\n    notify() {\n      version++;\n      if (held > 0) {\n        pending = true;\n        return;\n      }\n      changed.emit();\n    },\n    version: () => version,\n    subscribe: changed.subscribe,\n    deferred(fn, settle) {\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        settle?.();\n        if (held === 0 && pending) {\n          pending = false;\n          changed.emit();\n        }\n      }\n    },\n    muted(fn) {\n      const was = pending;\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        pending = was;\n      }\n    },\n  };\n}\n"],"mappings":";;AAoBA,SAAgBA,IAA2B;CACzC,IAAMC,IAAUC,EAAc,GAC1BC,IAAU,GACVC,IAAO,GACPC,IAAU;CAEd,OAAO;EACL,SAAS;GAEP,IADA,KACID,IAAO,GAAG;IACZ,IAAU;IACV;GACF;GACA,EAAQ,KAAK;EACf;EACA,eAAeD;EACf,WAAWF,EAAQ;EACnB,SAAS,GAAI,GAAQ;GACnB;GACA,IAAI;IACF,OAAOK,EAAG;GACZ,UAAU;IAGR,AAFA,KACAC,IAAS,GACLH,MAAS,KAAKC,MAChB,IAAU,IACVJ,EAAQ,KAAK;GAEjB;EACF;EACA,MAAM,GAAI;GACR,IAAMO,IAAMH;GACZ;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IAER,AADA,KACA,IAAUE;GACZ;EACF;CACF;AACF"}

package/dist/core/scene/opTable.js

@@ -0,0 +1,50 @@
+//#region src/core/scene/opTable.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Map();
+	function n(e) {
+		let n = t.get(e);
+		if (!n) throw Error(`Scene: no registered op for kind "${e}"`);
+		return n;
+	}
+	function r(e, n) {
+		let r;
+		if (e.startsWith("kit:")) {
+			if (typeof n != "object" || !n) return;
+			let e = n;
+			r = typeof e.id == "string" ? e.id : typeof e.layer == "string" ? e.layer : void 0;
+		} else r = t.get(e)?.coalesceKey?.(n);
+		return r === void 0 ? void 0 : `${e}:${r}`;
+	}
+	function i(t, a, o = !0) {
+		return n(t), {
+			name: t,
+			args: a,
+			coalesceKey: r(t, a),
+			apply: () => {
+				let r = () => {
+					let r = n(t);
+					if (e.skips(t, a, o)) return "noop";
+					(o ? r.apply : r.revert)(a), e.applied(t, a, !o);
+				};
+				if (e.driven()) return r();
+				let i;
+				return e.replayAlone(() => {
+					i = r();
+				}), i;
+			},
+			invert: () => i(t, a, !o)
+		};
+	}
+	return {
+		handlers: t,
+		register: (e, n) => {
+			t.set(e, n);
+		},
+		run: (e, t) => n(e).apply(t),
+		op: (e, t) => i(e, t)
+	};
+}
+//#endregion
+export { e as createOpTable };
+
+//# sourceMappingURL=opTable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opTable.js","names":["createOpTable","handlers","handlerFor","handler","kind","coalesceKeyFor","token","payload","p","op","run","env","forward","result"],"sources":["../../../src/core/scene/opTable.ts"],"sourcesContent":["/**\n * The scene's registered ops: the kit's own kinds and a consumer's, each a\n * pair of functions over a serializable payload, and the engine `Op` built\n * from one.\n */\nimport type { Op } from 'core/ops/types';\nimport type { RegisteredOp } from './types';\n\n/** What the table asks of the scene when one of its ops runs. */\nexport interface OpTableEnv {\n  /** Whether replaying this op would address a node that is no longer where\n   *  its entry left it; such an op reports a no-op. */\n  skips(kind: string, payload: unknown, forward: boolean): boolean;\n  /** Called after an op built by {@link OpTable.op} has applied, with the\n   *  direction it ran in. */\n  applied(kind: string, payload: unknown, reverted: boolean): void;\n  /** Whether an edit of the scene's is running. An op applied outside one\n   *  is a replay by a history the scene does not own: a mode journal's undo,\n   *  redo or cancel. */\n  driven(): boolean;\n  /** Run `step` as a replay step of its own, and notify. */\n  replayAlone(step: () => void): void;\n}\n\nexport interface OpTable {\n  handlers: ReadonlyMap<string, RegisteredOp<unknown>>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  /** Apply a kind's forward half. Throws when nothing is registered for it. */\n  run(kind: string, payload: unknown): void;\n  /** A registered op as an engine `Op`. `invert()` flips the direction with\n   *  the same payload, so undo replays `revert` and redo replays `apply`.\n   *  The handler is looked up at apply time, so a re-registered kind takes\n   *  effect on replay; that one exists is checked here, to fail at the call\n   *  site. */\n  op(kind: string, payload: unknown): Op;\n}\n\nexport function createOpTable(env: OpTableEnv): OpTable {\n  const handlers = new Map<string, RegisteredOp<unknown>>();\n\n  function handlerFor(kind: string): RegisteredOp<unknown> {\n    const handler = handlers.get(kind);\n    if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    return handler;\n  }\n\n  /** Coalesce-grouping key. Kit ops are keyed by the node or layer they\n   *  address; a consumer kind only by the `coalesceKey` it declares. Keys\n   *  take effect only under `UseSceneOptions.coalesceWindowMs`. */\n  function coalesceKeyFor(kind: string, payload: unknown): string | undefined {\n    let token: string | undefined;\n    if (kind.startsWith('kit:')) {\n      if (payload === null || typeof payload !== 'object') return undefined;\n      const p = payload as { id?: unknown; layer?: unknown };\n      token =\n        typeof p.id === 'string' ? p.id\n        : typeof p.layer === 'string' ? p.layer\n        : undefined;\n    } else {\n      token = handlers.get(kind)?.coalesceKey?.(payload);\n    }\n    return token === undefined ? undefined : `${kind}:${token}`;\n  }\n\n  function op(kind: string, payload: unknown, forward = true): Op {\n    handlerFor(kind);\n    return {\n      name: kind,\n      args: payload,\n      coalesceKey: coalesceKeyFor(kind, payload),\n      apply: () => {\n        const run = (): 'noop' | undefined => {\n          const handler = handlerFor(kind);\n          if (env.skips(kind, payload, forward)) return 'noop';\n          (forward ? handler.apply : handler.revert)(payload);\n          env.applied(kind, payload, !forward);\n          return undefined;\n        };\n        if (env.driven()) return run();\n        let result: 'noop' | undefined;\n        env.replayAlone(() => { result = run(); });\n        return result;\n      },\n      invert: () => op(kind, payload, !forward),\n    };\n  }\n\n  return {\n    handlers,\n    register: (kind, handler) => { handlers.set(kind, handler); },\n    run: (kind, payload) => handlerFor(kind).apply(payload),\n    op: (kind, payload) => op(kind, payload),\n  };\n}\n"],"mappings":";AAqCA,SAAgBA,EAAc,GAA0B;CACtD,IAAMC,oBAAW,IAAI,IAAmC;CAExD,SAASC,EAAW,GAAqC;EACvD,IAAMC,IAAUF,EAAS,IAAIG,CAAI;EACjC,IAAI,CAACD,GAAS,MAAU,MAAM,qCAAqCC,EAAK,EAAE;EAC1E,OAAOD;CACT;CAKA,SAASE,EAAe,GAAc,GAAsC;EAC1E,IAAIC;EACJ,IAAIF,EAAK,WAAW,MAAM,GAAG;GAC3B,IAAwB,OAAOG,KAAY,aAAvCA,GAAiD;GACrD,IAAMC,IAAID;GACV,IACE,OAAOC,EAAE,MAAO,WAAWA,EAAE,KAC3B,OAAOA,EAAE,SAAU,WAAWA,EAAE,QAChC,KAAA;EACN,OACE,IAAQP,EAAS,IAAIG,CAAI,CAAC,EAAE,cAAcG,CAAO;EAEnD,OAAOD,MAAU,KAAA,IAAY,KAAA,IAAY,GAAGF,EAAK,GAAGE;CACtD;CAEA,SAASG,EAAG,GAAc,GAAkB,IAAU,IAAU;EAE9D,OADAP,EAAWE,CAAI,GACR;GACL,MAAMA;GACN,MAAMG;GACN,aAAaF,EAAeD,GAAMG,CAAO;GACzC,aAAa;IACX,IAAMG,UAAgC;KACpC,IAAMP,IAAUD,EAAWE,CAAI;KAC/B,IAAIO,EAAI,MAAMP,GAAMG,GAASK,CAAO,GAAG,OAAO;KAE9C,CADCA,IAAUT,EAAQ,QAAQA,EAAQ,OAAA,CAAQI,CAAO,GAClDI,EAAI,QAAQP,GAAMG,GAAS,CAACK,CAAO;IAErC;IACA,IAAID,EAAI,OAAO,GAAG,OAAOD,EAAI;IAC7B,IAAIG;IAEJ,OADAF,EAAI,kBAAkB;KAAE,IAASD,EAAI;IAAG,CAAC,GAClCG;GACT;GACA,cAAcJ,EAAGL,GAAMG,GAAS,CAACK,CAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,GAAM,MAAY;GAAE,EAAS,IAAIR,GAAMD,CAAO;EAAG;EAC5D,MAAM,GAAM,MAAYD,EAAWE,CAAI,CAAC,CAAC,MAAMG,CAAO;EACtD,KAAK,GAAM,MAAYE,EAAGL,GAAMG,CAAO;CACzC;AACF"}

package/dist/core/scene/outerOps.js

@@ -0,0 +1,67 @@
+import { rebuildOp as e } from "../ops/registry.js";
+import { bindOpToAdapter as t, bindOpToHistoryAdapter as n } from "./boundOps.js";
+//#region src/core/scene/outerOps.ts
+function r(e, t) {
+	let n = t === void 0 || e.coalesceKey === void 0 ? void 0 : `${t}>${e.coalesceKey}`;
+	return {
+		name: e.name,
+		args: e.args,
+		coalesceKey: n,
+		apply: e.apply,
+		invert: e.invert
+	};
+}
+function i(i) {
+	let a = null, o = i.getActiveJournal;
+	function s(e, t = e) {
+		if (e.caused) return e;
+		let n = [t];
+		return {
+			get name() {
+				return e.name;
+			},
+			get args() {
+				return e.args;
+			},
+			label: e.label,
+			get coalesceKey() {
+				return e.coalesceKey;
+			},
+			elideNoop: e.elideNoop,
+			apply(a) {
+				let { result: o, ops: s } = i.recorder().capturing(() => t.apply(a));
+				return s.length > 0 && (n = s.map((t) => r(t, e.coalesceKey))), o;
+			},
+			caused: () => n,
+			invert: () => t.invert()
+		};
+	}
+	return {
+		rebuild(t, r) {
+			let o = i.own(t, r);
+			if (o !== null) return o;
+			let s = e(t, r);
+			return s === null ? null : n(s, () => a);
+		},
+		causing: (e) => s(e),
+		apply(e, n, r, a) {
+			if (i.recorder().joins()) return i.recorder().join(n, a);
+			let c = o?.() ?? null;
+			i.driving(() => {
+				let i = n.map((e) => s(e, t(e, a)));
+				c ? c.applyBatch(i, r) : e.applyOps(i, r);
+			});
+		},
+		setHistoryAdapter(e) {
+			a = e;
+		},
+		setActiveJournalAccessor(e) {
+			o = e;
+		},
+		activeJournal: () => o?.() ?? null
+	};
+}
+//#endregion
+export { i as createOuterOps };
+
+//# sourceMappingURL=outerOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp","keyed","key","outerKey","kit","createOuterOps","historyAdapter","activeJournal","env","causing","op","caused","given","adapter","ops","result","own","name","args","rebuilt","rebuildOp","bindOpToHistoryAdapter","journal","bound","bindOpToAdapter","label","engine","fn"],"sources":["../../../src/core/scene/outerOps.ts"],"sourcesContent":["/**\n * Ops built outside the scene and handed to `applyBatch` or `scene.history`.\n *\n * An undo entry holds the scene's own ops, so an outer op is recorded as the\n * kit ops it caused. One that wrote no scene state is recorded as itself, and\n * needs an adapter to replay through: the one it was applied with, or after a\n * reload the one `setHistoryAdapter` supplies.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { rebuildOp as rebuildGlobalOp } from 'core/ops/registry';\nimport { bindOpToAdapter, bindOpToHistoryAdapter } from './boundOps';\nimport type { Recorder } from './recorder';\n\n/** What the outer ops need from the scene they are applied to. */\nexport interface OuterOpsEnv {\n  /** The scene's own op for a kind it has registered, or `null`. */\n  own(name: string, args: unknown): Op | null;\n  /** The scene's recorder, built after this is. */\n  recorder(): Pick<Recorder, 'capturing' | 'joins' | 'join'>;\n  /** Run a step that applies ops through a history engine: all-or-nothing,\n   *  unrecorded by the scene, with subscribers called once after. */\n  driving(step: () => void): void;\n  /** Where `applyBatch` looks for an open journal until an accessor is set. */\n  getActiveJournal: (() => Journal | null) | null;\n}\n\nexport interface OuterOps {\n  /** The op a restored history names: the scene's own, or an outer op bound\n   *  to the adapter `setHistoryAdapter` supplies. `null` when nothing knows\n   *  the name, and the engine places its no-op placeholder. */\n  rebuild(name: string, args: unknown): Op | null;\n  /** `op` as an engine applies it: its entry records the kit ops it caused,\n   *  or the op itself when it caused none. */\n  causing(op: Op): Op;\n  /** Apply `ops` against `adapter` as one entry: part of the open `batch`\n   *  when there is one, else on the active journal, else on `engine`. */\n  apply(engine: History, ops: Op[], label: string, adapter: unknown): void;\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n  setActiveJournalAccessor(fn: (() => Journal | null) | null): void;\n  /** The journal edits go to now, or null for the scene's own history. */\n  activeJournal(): Journal | null;\n}\n\n/** A kit op under the key of the outer op that caused it, so two edits merge\n *  when their outer ops would have. */\nfunction keyed(kit: Op, outerKey: string | undefined): Op {\n  const key = outerKey === undefined || kit.coalesceKey === undefined ? undefined : `${outerKey}>${kit.coalesceKey}`;\n  return { name: kit.name, args: kit.args, coalesceKey: key, apply: kit.apply, invert: kit.invert };\n}\n\nexport function createOuterOps(env: OuterOpsEnv): OuterOps {\n  let historyAdapter: (() => unknown) | null = null;\n  let activeJournal = env.getActiveJournal;\n\n  function causing(op: Op, given: Op = op): Op {\n    if (op.caused) return op;\n    let caused: Op[] = [given];\n    return {\n      get name() { return op.name; },\n      get args() { return op.args; },\n      label: op.label,\n      // Read when asked: an arrange op has no key until it has applied.\n      get coalesceKey() { return op.coalesceKey; },\n      elideNoop: op.elideNoop,\n      apply(adapter) {\n        const { result, ops } = env.recorder().capturing(() => given.apply(adapter));\n        if (ops.length > 0) caused = ops.map((kit) => keyed(kit, op.coalesceKey));\n        return result;\n      },\n      caused: () => caused,\n      invert: () => given.invert(),\n    };\n  }\n\n  return {\n    rebuild(name, args) {\n      const own = env.own(name, args);\n      if (own !== null) return own;\n      const rebuilt = rebuildGlobalOp(name, args);\n      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt, () => historyAdapter);\n    },\n    causing: (op) => causing(op),\n    apply(engine, ops, label, adapter) {\n      if (env.recorder().joins()) return env.recorder().join(ops, adapter);\n      const journal = activeJournal?.() ?? null;\n      env.driving(() => {\n        // Neither engine was built with an adapter, so an op is bound to\n        // this call's before either applies or stores it.\n        const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));\n        if (journal) journal.applyBatch(bound, label);\n        else engine.applyOps(bound, label);\n      });\n    },\n    setHistoryAdapter(fn) {\n      historyAdapter = fn;\n    },\n    setActiveJournalAccessor(fn) {\n      activeJournal = fn;\n    },\n    activeJournal: () => activeJournal?.() ?? null,\n  };\n}\n"],"mappings":";;;AA8CA,SAASC,EAAM,GAAS,GAAkC;CACxD,IAAMC,IAAMC,MAAa,KAAA,KAAaC,EAAI,gBAAgB,KAAA,IAAY,KAAA,IAAY,GAAGD,EAAS,GAAGC,EAAI;CACrG,OAAO;EAAE,MAAMA,EAAI;EAAM,MAAMA,EAAI;EAAM,aAAaF;EAAK,OAAOE,EAAI;EAAO,QAAQA,EAAI;CAAO;AAClG;AAEA,SAAgBC,EAAe,GAA4B;CACzD,IAAIC,IAAyC,MACzCC,IAAgBC,EAAI;CAExB,SAASC,EAAQ,GAAQ,IAAYC,GAAQ;EAC3C,IAAIA,EAAG,QAAQ,OAAOA;EACtB,IAAIC,IAAe,CAACC,CAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAOF,EAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAOA,EAAG;GAAM;GAC7B,OAAOA,EAAG;GAEV,IAAI,cAAc;IAAE,OAAOA,EAAG;GAAa;GAC3C,WAAWA,EAAG;GACd,MAAM,GAAS;IACb,IAAM,EAAE,WAAQ,WAAQF,EAAI,SAAS,CAAC,CAAC,gBAAgBI,EAAM,MAAMC,CAAO,CAAC;IAE3E,OADIC,EAAI,SAAS,MAAG,IAASA,EAAI,KAAK,MAAQb,EAAMG,GAAKM,EAAG,WAAW,CAAC,IACjEK;GACT;GACA,cAAcJ;GACd,cAAcC,EAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,GAAM,GAAM;GAClB,IAAMI,IAAMR,EAAI,IAAIS,GAAMC,CAAI;GAC9B,IAAIF,MAAQ,MAAM,OAAOA;GACzB,IAAMG,IAAUnB,EAAgBiB,GAAMC,CAAI;GAC1C,OAAOC,MAAY,OAAO,OAAOE,EAAuBF,SAAeb,CAAc;EACvF;EACA,UAAU,MAAOG,EAAQC,CAAE;EAC3B,MAAM,GAAQ,GAAK,GAAO,GAAS;GACjC,IAAIF,EAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAOA,EAAI,SAAS,CAAC,CAAC,KAAKM,GAAKD,CAAO;GACnE,IAAMS,IAAUf,IAAgB,KAAK;GACrC,EAAI,cAAc;IAGhB,IAAMgB,IAAQT,EAAI,KAAK,MAAOL,EAAQC,GAAIc,EAAgBd,GAAIG,CAAO,CAAC,CAAC;IACvE,AAAIS,IAASA,EAAQ,WAAWC,GAAOE,CAAK,IACvCC,EAAO,SAASH,GAAOE,CAAK;GACnC,CAAC;EACH;EACA,kBAAkB,GAAI;GACpB,IAAiBE;EACnB;EACA,yBAAyB,GAAI;GAC3B,IAAgBA;EAClB;EACA,qBAAqBpB,IAAgB,KAAK;CAC5C;AACF"}

package/dist/core/scene/poseHold.js

@@ -0,0 +1,39 @@
+//#region src/core/scene/poseHold.ts
+function e(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+	return {
+		set(r) {
+			n.clear();
+			for (let [i, a] of r) {
+				n.add(i);
+				let r = t.get(i);
+				if (r) {
+					r.pose = a;
+					continue;
+				}
+				let o = { pose: a };
+				t.set(i, o), e.set(i, o);
+			}
+			for (let [r, i] of t) n.has(r) || (t.delete(r), e.get(r) === i && e.clear(r));
+			e.commit();
+		},
+		others() {
+			let n = /* @__PURE__ */ new Map();
+			for (let r of e.ids()) {
+				let i = e.get(r);
+				i !== void 0 && i !== t.get(r) && i.pose !== void 0 && n.set(r, i.pose);
+			}
+			return n;
+		},
+		drop() {
+			if (t.size !== 0) {
+				for (let [n, r] of t) e.get(n) === r && e.clear(n);
+				t.clear(), e.commit();
+			}
+		}
+	};
+}
+//#endregion
+export { e as createPoseHold };
+
+//# sourceMappingURL=poseHold.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseHold.js","names":["createPoseHold","held","seen","id","pose","poses","existing","entry","table","out"],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose> = Pick<PoseOverrides<TPose>, 'set' | 'get' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. */\nexport function createPoseHold<TPose>(table: HoldTable<TPose>): PoseHold<TPose> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose>>();\n  const seen = new Set<NodeId>();\n\n  return {\n    set(poses) {\n      seen.clear();\n      for (const [id, pose] of poses) {\n        seen.add(id);\n        const existing = held.get(id);\n        if (existing) {\n          existing.pose = pose;\n          continue;\n        }\n        const entry: PoseOverride<TPose> = { pose };\n        held.set(id, entry);\n        // `table.set` notifies per call, so an id is set once and mutated after.\n        table.set(id, entry);\n      }\n      for (const [id, entry] of held) {\n        if (seen.has(id)) continue;\n        held.delete(id);\n        if (table.get(id) === entry) table.clear(id);\n      }\n      table.commit();\n    },\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const entry = table.get(id);\n        if (entry === undefined || entry === held.get(id) || entry.pose === undefined) continue;\n        out.set(id, entry.pose);\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) {\n        if (table.get(id) === entry) table.clear(id);\n      }\n      held.clear();\n      table.commit();\n    },\n  };\n}\n"],"mappings":";AAMA,SAAgBA,EAAsB,GAA0C;CAE9E,IAAMC,oBAAO,IAAI,IAAiC,GAC5CC,oBAAO,IAAI,IAAY;CAE7B,OAAO;EACL,IAAI,GAAO;GACT,EAAK,MAAM;GACX,KAAK,IAAM,CAACC,GAAIC,MAASC,GAAO;IAC9B,EAAK,IAAIF,CAAE;IACX,IAAMG,IAAWL,EAAK,IAAIE,CAAE;IAC5B,IAAIG,GAAU;KACZ,EAAS,OAAOF;KAChB;IACF;IACA,IAAMG,IAA6B,EAAE,QAAK;IAG1C,AAFAN,EAAK,IAAIE,GAAII,CAAK,GAElBC,EAAM,IAAIL,GAAII,CAAK;GACrB;GACA,KAAK,IAAM,CAACJ,GAAII,MAAUN,GACxB,AAAIC,EAAK,IAAIC,CAAE,MACfF,EAAK,OAAOE,CAAE,GACVK,EAAM,IAAIL,CAAE,MAAMI,KAAOC,EAAM,MAAML,CAAE;GAE7C,EAAM,OAAO;EACf;EACA,SAAS;GACP,IAAMM,oBAAM,IAAI,IAAmB;GACnC,KAAK,IAAMN,KAAMK,EAAM,IAAI,GAAG;IAC5B,IAAMD,IAAQC,EAAM,IAAIL,CAAE;IAC1B,AAAII,MAAU,KAAA,KAAaA,MAAUN,EAAK,IAAIE,CAAE,KAAKI,EAAM,SAAS,KAAA,KACpEE,EAAI,IAAIN,GAAII,EAAM,IAAI;GACxB;GACA,OAAOE;EACT;EACA,OAAO;GACL,IAAIR,EAAK,SAAS,GAClB;SAAK,IAAM,CAACE,GAAII,MAAUN,GACxB,AAAIO,EAAM,IAAIL,CAAE,MAAMI,KAAOC,EAAM,MAAML,CAAE;IAG7C,AADAF,EAAK,MAAM,GACXO,EAAM,OAAO;GAHgC;EAI/C;CACF;AACF"}

package/dist/core/scene/poseOverrides.js

@@ -1,68 +1,76 @@
 import { dropPoseKeyedMemoSlots as e } from "./nodeMemo.js";
-import { createEmitter as t } from "@weasel-js/registry";
-import { kit as n, last as r, mix as i, mul as a, patch as o } from "@msb235/blits";
+import { createPoseHold as t } from "./poseHold.js";
+import { createEmitter as n } from "@weasel-js/registry";
+import { kit as r, last as i, mix as a, mul as o, patch as s } from "@msb235/blits";
 //#region src/core/scene/poseOverrides.ts
-var s = Object.freeze({});
-function c(c, l) {
-	let u = /* @__PURE__ */ new Map(), d = t(), f = 0, p = i(n({
-		pose: r(),
-		alpha: a()
+var c = Object.freeze({});
+function l(l, u) {
+	let d = /* @__PURE__ */ new Map(), f = n(), p = 0, m = a(r({
+		pose: i(),
+		alpha: o(),
+		path: i()
 	}));
-	p.cue({ patch: o(0, (e, t) => u.get(t) ?? s, { writes: ["pose", "alpha"] }) });
-	let m = 0;
-	p.sync(m);
-	let h = /* @__PURE__ */ new Map();
-	function g(t) {
-		let n = c(t);
-		n && e(n), l?.(t);
+	m.cue({ patch: s(0, (e, t) => d.get(t) ?? c, { writes: [
+		"pose",
+		"alpha",
+		"path"
+	] }) });
+	let h = 0;
+	m.sync(h);
+	let g = /* @__PURE__ */ new Map();
+	function _(t) {
+		let n = l(t);
+		n && e(n), u?.(t);
 	}
-	function _() {
-		f++, p.sync(++m), d.emit();
+	function v() {
+		p++, m.sync(++h), f.emit();
 	}
-	function v(e) {
-		h.delete(e), p.drop(e);
+	function y(e) {
+		g.delete(e), m.drop(e);
 	}
-	return {
+	let b = {
 		set(e, t) {
-			u.set(e, t), g(e), _();
+			d.set(e, t), _(e), v();
 		},
 		get(e) {
-			return u.get(e);
+			return d.get(e);
 		},
 		read(e) {
-			if (!u.has(e)) return;
-			let t = h.get(e);
+			if (!d.has(e)) return;
+			let t = g.get(e);
 			return t === void 0 && (t = {
 				out: {},
 				at: -1
-			}, h.set(e, t)), t.at !== f && (p.probe(e, t.out), t.at = f), t.out;
+			}, g.set(e, t)), t.at !== p && (m.probe(e, t.out), t.at = p), t.out;
 		},
 		has(e) {
-			return u.has(e);
+			return d.has(e);
 		},
 		ids() {
-			return [...u.keys()];
+			return [...d.keys()];
 		},
 		clear(e) {
-			u.delete(e) && (v(e), g(e), _());
+			d.delete(e) && (y(e), _(e), v());
 		},
 		clearAll() {
-			if (u.size !== 0) {
-				for (let e of u.keys()) v(e), g(e);
-				u.clear(), _();
+			if (d.size !== 0) {
+				for (let e of d.keys()) y(e), _(e);
+				d.clear(), v();
 			}
 		},
 		commit() {
-			for (let e of u.keys()) g(e);
-			_();
+			for (let e of d.keys()) _(e);
+			v();
 		},
-		subscribe: d.subscribe,
+		subscribe: f.subscribe,
 		getGeneration() {
-			return f;
-		}
+			return p;
+		},
+		hold: () => t(b)
 	};
+	return b;
 }
 //#endregion
-export { c as createPoseOverrides };
+export { l as createPoseOverrides };
 
 //# sourceMappingURL=poseOverrides.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseOverrides.js","names":["NOTHING","createPoseOverrides","entries","listeners","createEmitter","generation","folded","mix","kit","last","mul","patch","id","clock","reads","invalidate","node","getNode","dropPoseKeyedMemoSlots","onInvalidate","published","forget","entry","held"],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport { kit, last, mix, mul, patch } from '@msb235/blits';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/** What the table's voice says about a node it holds no entry for. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on —\n * the only thing this module needs from the scene, and the reason it doesn't\n * import one. `onInvalidate` lets the scene invalidate derived nodes from the\n * same chokepoint.\n *\n * What `read` answers is a blits mix folded per node. The entries a writer\n * `set`s are one voice on it, and the nodes holding an entry are the mix's\n * reach: a node outside it is never probed.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = createEmitter();\n  let generation = 0;\n\n  const folded = mix<NodeId, PoseOverride<TPose>>(\n    kit<PoseOverride<TPose>>({ pose: last<NonNullable<TPose>>(), alpha: mul() }),\n  );\n  folded.cue({\n    patch: patch<NodeId, PoseOverride<TPose>>(\n      0,\n      (_phase, id) => entries.get(id) ?? (NOTHING as PoseOverride<TPose>),\n      { writes: ['pose', 'alpha'] },\n    ),\n  });\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  folded.sync(clock);\n\n  /** Per node: the object `read` folds into and returns, and the generation\n   *  it was last folded at. */\n  const reads = new Map<NodeId, { out: PoseOverride<TPose>; at: number }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    folded.sync(++clock);\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    folded.drop(id);\n  }\n\n  return {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    read(id) {\n      if (!entries.has(id)) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        folded.probe(id, held.out);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n  };\n}\n"],"mappings":";;;;AAMA,IAAMA,IAA+B,OAAO,OAAO,CAAC,CAAC;AAcrD,SAAgBC,EACd,GACA,GACsB;CACtB,IAAMC,oBAAU,IAAI,IAAiC,GAC/CC,IAAYC,EAAc,GAC5BC,IAAa,GAEXC,IAASC,EACbC,EAAyB;EAAE,MAAMC,EAAyB;EAAG,OAAOC,EAAI;CAAE,CAAC,CAC7E;CACA,EAAO,IAAI,EACT,OAAOC,EACL,IACC,GAAQ,MAAOT,EAAQ,IAAIU,CAAE,KAAMZ,GACpC,EAAE,QAAQ,CAAC,QAAQ,OAAO,EAAE,CAC9B,EACF,CAAC;CAGD,IAAIa,IAAQ;CACZ,EAAO,KAAKA,CAAK;CAIjB,IAAMC,oBAAQ,IAAI,IAAsD;CAExE,SAASC,EAAW,GAAkB;EACpC,IAAMC,IAAOC,EAAQL,CAAE;EAEvB,AADII,KAAME,EAAuBF,CAAI,GACrCG,IAAeP,CAAE;CACnB;CAEA,SAASQ,IAAkB;EAGzB,AAFA,KACAd,EAAO,KAAK,EAAEO,CAAK,GACnBV,EAAU,KAAK;CACjB;CAEA,SAASkB,EAAO,GAAkB;EAEhC,AADAP,EAAM,OAAOF,CAAE,GACfN,EAAO,KAAKM,CAAE;CAChB;CAEA,OAAO;EACL,IAAI,GAAI,GAAO;GAGb,AAFAV,EAAQ,IAAIU,GAAIU,CAAK,GACrBP,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,IAAI,GAAI;GACN,OAAOlB,EAAQ,IAAIU,CAAE;EACvB;EACA,KAAK,GAAI;GACP,IAAI,CAACV,EAAQ,IAAIU,CAAE,GAAG;GACtB,IAAIW,IAAOT,EAAM,IAAIF,CAAE;GASvB,OARIW,MAAS,KAAA,MACX,IAAO;IAAE,KAAK,CAAC;IAAG,IAAI;GAAG,GACzBT,EAAM,IAAIF,GAAIW,CAAI,IAEhBA,EAAK,OAAOlB,MACdC,EAAO,MAAMM,GAAIW,EAAK,GAAG,GACzB,EAAK,KAAKlB,IAELkB,EAAK;EACd;EACA,IAAI,GAAI;GACN,OAAOrB,EAAQ,IAAIU,CAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAGV,EAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,GAAI;GACR,AAAKA,EAAQ,OAAOU,CAAE,MACtBS,EAAOT,CAAE,GACTG,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,WAAW;GACT,IAAIlB,EAAQ,SAAS,GACrB;SAAK,IAAMU,KAAMV,EAAQ,KAAK,GAE5B,AADAmB,EAAOT,CAAE,GACTG,EAAWH,CAAE;IAGf,AADAV,EAAQ,MAAM,GACdkB,EAAU;GAFV;EAGF;EACA,SAAS;GACP,KAAK,IAAMR,KAAMV,EAAQ,KAAK,GAAG,EAAWU,CAAE;GAC9C,EAAU;EACZ;EACA,WAAWT,EAAU;EACrB,gBAAgB;GACd,OAAOE;EACT;CACF;AACF"}
+{"version":3,"file":"poseOverrides.js","names":["NOTHING","createPoseOverrides","entries","listeners","createEmitter","generation","folded","mix","kit","last","mul","patch","id","clock","reads","invalidate","node","getNode","dropPoseKeyedMemoSlots","onInvalidate","published","forget","table","entry","held","createPoseHold"],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { createEmitter } from '@weasel-js/registry';\nimport { kit, last, mix, mul, patch } from '@msb235/blits';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { createPoseHold } from './poseHold';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/** What the table's voice says about a node it holds no entry for. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on.\n * `onInvalidate` lets the scene invalidate derived nodes from the same\n * chokepoint.\n *\n * What `read` answers is a blits mix folded per node. The entries a writer\n * `set`s are one voice on it, and a node holding no entry is never probed.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = createEmitter();\n  let generation = 0;\n\n  const folded = mix<NodeId, PoseOverride<TPose>>(\n    kit<PoseOverride<TPose>>({ pose: last<NonNullable<TPose>>(), alpha: mul(), path: last<Path>() }),\n  );\n  folded.cue({\n    patch: patch<NodeId, PoseOverride<TPose>>(\n      0,\n      (_phase, id) => entries.get(id) ?? (NOTHING as PoseOverride<TPose>),\n      { writes: ['pose', 'alpha', 'path'] },\n    ),\n  });\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  folded.sync(clock);\n\n  /** Per node: the object `read` folds into and returns, and the generation\n   *  it was last folded at. */\n  const reads = new Map<NodeId, { out: PoseOverride<TPose>; at: number }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    folded.sync(++clock);\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    folded.drop(id);\n  }\n\n  const table: PoseOverrides<TPose> = {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    read(id) {\n      if (!entries.has(id)) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        folded.probe(id, held.out);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n    hold: () => createPoseHold(table),\n  };\n  return table;\n}\n"],"mappings":";;;;;AAQA,IAAMA,IAA+B,OAAO,OAAO,CAAC,CAAC;AAYrD,SAAgBC,EACd,GACA,GACsB;CACtB,IAAMC,oBAAU,IAAI,IAAiC,GAC/CC,IAAYC,EAAc,GAC5BC,IAAa,GAEXC,IAASC,EACbC,EAAyB;EAAE,MAAMC,EAAyB;EAAG,OAAOC,EAAI;EAAG,MAAMD,EAAW;CAAE,CAAC,CACjG;CACA,EAAO,IAAI,EACT,OAAOE,EACL,IACC,GAAQ,MAAOT,EAAQ,IAAIU,CAAE,KAAMZ,GACpC,EAAE,QAAQ;EAAC;EAAQ;EAAS;CAAM,EAAE,CACtC,EACF,CAAC;CAGD,IAAIa,IAAQ;CACZ,EAAO,KAAKA,CAAK;CAIjB,IAAMC,oBAAQ,IAAI,IAAsD;CAExE,SAASC,EAAW,GAAkB;EACpC,IAAMC,IAAOC,EAAQL,CAAE;EAEvB,AADII,KAAME,EAAuBF,CAAI,GACrCG,IAAeP,CAAE;CACnB;CAEA,SAASQ,IAAkB;EAGzB,AAFA,KACAd,EAAO,KAAK,EAAEO,CAAK,GACnBV,EAAU,KAAK;CACjB;CAEA,SAASkB,EAAO,GAAkB;EAEhC,AADAP,EAAM,OAAOF,CAAE,GACfN,EAAO,KAAKM,CAAE;CAChB;CAEA,IAAMU,IAA8B;EAClC,IAAI,GAAI,GAAO;GAGb,AAFApB,EAAQ,IAAIU,GAAIW,CAAK,GACrBR,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,IAAI,GAAI;GACN,OAAOlB,EAAQ,IAAIU,CAAE;EACvB;EACA,KAAK,GAAI;GACP,IAAI,CAACV,EAAQ,IAAIU,CAAE,GAAG;GACtB,IAAIY,IAAOV,EAAM,IAAIF,CAAE;GASvB,OARIY,MAAS,KAAA,MACX,IAAO;IAAE,KAAK,CAAC;IAAG,IAAI;GAAG,GACzBV,EAAM,IAAIF,GAAIY,CAAI,IAEhBA,EAAK,OAAOnB,MACdC,EAAO,MAAMM,GAAIY,EAAK,GAAG,GACzB,EAAK,KAAKnB,IAELmB,EAAK;EACd;EACA,IAAI,GAAI;GACN,OAAOtB,EAAQ,IAAIU,CAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAGV,EAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,GAAI;GACR,AAAKA,EAAQ,OAAOU,CAAE,MACtBS,EAAOT,CAAE,GACTG,EAAWH,CAAE,GACbQ,EAAU;EACZ;EACA,WAAW;GACT,IAAIlB,EAAQ,SAAS,GACrB;SAAK,IAAMU,KAAMV,EAAQ,KAAK,GAE5B,AADAmB,EAAOT,CAAE,GACTG,EAAWH,CAAE;IAGf,AADAV,EAAQ,MAAM,GACdkB,EAAU;GAFV;EAGF;EACA,SAAS;GACP,KAAK,IAAMR,KAAMV,EAAQ,KAAK,GAAG,EAAWU,CAAE;GAC9C,EAAU;EACZ;EACA,WAAWT,EAAU;EACrB,gBAAgB;GACd,OAAOE;EACT;EACA,YAAYoB,EAAeH,CAAK;CAClC;CACA,OAAOA;AACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"poseSnapshot.js","names":["DEPTH","isTypedArray","v","snapshotPose","depth","value","isPlainObject","out","key","field","samePoseValue","snapshot","proto","isPlainPrototype","a","b","count","left","right","_key","i"],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved. A pose override mutates\n * its buffer in place, so holding the pose object and comparing references\n * sees nothing; holding a *copy* of its values and comparing those sees the\n * move without anyone pushing an invalidation.\n *\n * `TPose` is opaque to the kit — a consumer's pose is whatever it declared —\n * so both sides walk plain objects, arrays and typed arrays, and fall back to\n * reference identity for anything else (a class instance, a `Map`). A pose of\n * that shape mutated in place still needs the scene's pushed invalidation,\n * which is unchanged either way.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;AAkBA,IAAMA,IAAQ;AAEd,SAASC,EAAa,GAA2D;CAC/E,OAAO,YAAY,OAAOC,CAAC,KAAK,EAAEA,aAAa;AACjD;AAGA,SAAgBC,EAAgB,GAAU,IAAQH,GAAU;CAC1D,IAAII,KAAS,GAAG,OAAOC;CACvB,IAAI,MAAM,QAAQA,CAAK,GACrB,OAAOA,EAAM,KAAK,MAAMF,EAAaD,GAAGE,IAAQ,CAAC,CAAC;CAEpD,IAAIH,EAAaI,CAAK,GAAG,OAAOA,EAAM,MAAM;CAC5C,IAAIC,EAAcD,CAAK,GAAG;EAIxB,IAAME,IAA+B,EAAE,GAAGF,EAAM;EAChD,KAAK,IAAMG,KAAOD,GAAK;GACrB,IAAME,IAAQF,EAAIC;GAClB,AAAI,OAAOC,KAAU,YAAYA,MAAgB,EAAID,KAAOL,EAAaM,GAAOL,IAAQ,CAAC;EAC3F;EACA,OAAOG;CACT;CACA,OAAOF;AACT;AAKA,SAAgBK,EAAc,GAAmB,GAAgB,IAAQV,GAAgB;CACvF,IAAIW,MAAaN,GAAO,OAAO;CAC/B,IAAI,OAAOM,KAAa,aAAYA,KAC/B,OAAON,KAAU,aAAYA,GAAgB,OAAO,OAAO,GAAGM,GAAUN,CAAK;CAClF,IAAID,KAAS,GAAG,OAAO;CAEvB,IAAMQ,IAAQ,OAAO,eAAeD,CAAQ;CAC5C,IAAIE,EAAiBD,CAAK,GAAG;EAC3B,IAAI,CAACC,EAAiB,OAAO,eAAeR,CAAK,CAAkB,GAAG,OAAO;EAC7E,IAAMS,IAAIH,GACJI,IAAIV,GACNW,IAAQ;EACZ,KAAK,IAAMR,KAAOM,GAAG;GACnB;GACA,IAAMG,IAAOH,EAAEN,IACTU,IAAQH,EAAEP;GAChB,IAAIS,MAASC,GAAO;IAClB,IAAIA,MAAU,KAAA,KAAa,EAAEV,KAAOO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAACL,EAAcO,GAAMC,GAAOd,IAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,IAAMe,KAAQJ,GAAG,IAAI,EAAEC,IAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQL,CAAQ,KAAKV,EAAaU,CAAQ,GAAG;EACrD,IAAMG,IAAIH;EACV,IAAI,EAAE,MAAM,QAAQN,CAAK,KAAKJ,EAAaI,CAAK,IAAI,OAAO;EAC3D,IAAMU,IAAIV;EACV,IAAIS,EAAE,WAAWC,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAIK,IAAI,GAAGA,IAAIN,EAAE,QAAQ,KAC5B,IAAI,CAACJ,EAAcI,EAAEM,IAAIL,EAAEK,IAAIhB,IAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}
+{"version":3,"file":"poseSnapshot.js","names":["DEPTH","isTypedArray","v","snapshotPose","depth","value","isPlainObject","out","key","field","samePoseValue","snapshot","proto","isPlainPrototype","a","b","count","left","right","_key","i"],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved: a pose override mutates\n * its buffer in place, so comparing references sees nothing.\n *\n * `TPose` is opaque to the kit, so both sides walk plain objects, arrays, and\n * typed arrays, and fall back to reference identity for anything else (a\n * class instance, a `Map`). A pose of that shape mutated in place still needs\n * the scene's pushed invalidation.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;AAeA,IAAMA,IAAQ;AAEd,SAASC,EAAa,GAA2D;CAC/E,OAAO,YAAY,OAAOC,CAAC,KAAK,EAAEA,aAAa;AACjD;AAGA,SAAgBC,EAAgB,GAAU,IAAQH,GAAU;CAC1D,IAAII,KAAS,GAAG,OAAOC;CACvB,IAAI,MAAM,QAAQA,CAAK,GACrB,OAAOA,EAAM,KAAK,MAAMF,EAAaD,GAAGE,IAAQ,CAAC,CAAC;CAEpD,IAAIH,EAAaI,CAAK,GAAG,OAAOA,EAAM,MAAM;CAC5C,IAAIC,EAAcD,CAAK,GAAG;EAIxB,IAAME,IAA+B,EAAE,GAAGF,EAAM;EAChD,KAAK,IAAMG,KAAOD,GAAK;GACrB,IAAME,IAAQF,EAAIC;GAClB,AAAI,OAAOC,KAAU,YAAYA,MAAgB,EAAID,KAAOL,EAAaM,GAAOL,IAAQ,CAAC;EAC3F;EACA,OAAOG;CACT;CACA,OAAOF;AACT;AAKA,SAAgBK,EAAc,GAAmB,GAAgB,IAAQV,GAAgB;CACvF,IAAIW,MAAaN,GAAO,OAAO;CAC/B,IAAI,OAAOM,KAAa,aAAYA,KAC/B,OAAON,KAAU,aAAYA,GAAgB,OAAO,OAAO,GAAGM,GAAUN,CAAK;CAClF,IAAID,KAAS,GAAG,OAAO;CAEvB,IAAMQ,IAAQ,OAAO,eAAeD,CAAQ;CAC5C,IAAIE,EAAiBD,CAAK,GAAG;EAC3B,IAAI,CAACC,EAAiB,OAAO,eAAeR,CAAK,CAAkB,GAAG,OAAO;EAC7E,IAAMS,IAAIH,GACJI,IAAIV,GACNW,IAAQ;EACZ,KAAK,IAAMR,KAAOM,GAAG;GACnB;GACA,IAAMG,IAAOH,EAAEN,IACTU,IAAQH,EAAEP;GAChB,IAAIS,MAASC,GAAO;IAClB,IAAIA,MAAU,KAAA,KAAa,EAAEV,KAAOO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAACL,EAAcO,GAAMC,GAAOd,IAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,IAAMe,KAAQJ,GAAG,IAAI,EAAEC,IAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQL,CAAQ,KAAKV,EAAaU,CAAQ,GAAG;EACrD,IAAMG,IAAIH;EACV,IAAI,EAAE,MAAM,QAAQN,CAAK,KAAKJ,EAAaI,CAAK,IAAI,OAAO;EAC3D,IAAMU,IAAIV;EACV,IAAIS,EAAE,WAAWC,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAIK,IAAI,GAAGA,IAAIN,EAAE,QAAQ,KAC5B,IAAI,CAACJ,EAAcI,EAAEM,IAAIL,EAAEK,IAAIhB,IAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}

package/dist/core/scene/reconcileSpecs.js

@@ -6,7 +6,7 @@ function t(e, t, a) {
 		let n = s.get(e);
 		(n === void 0 || r(t, n)) && c.push(e);
 	}
-	let l = e.removalClosure(c.filter((t) => e.get(t) !== void 0)), u = new Set(l);
+	let l = e.removalClosure(c.filter((t) => e.get(t) !== void 0)), u = new Set(l), d = e.getSelection();
 	e.untracked(() => {
 		e.removeMany(l);
 		for (let t of a) {
@@ -16,8 +16,9 @@ function t(e, t, a) {
 				continue;
 			}
 			let a = t.parent ?? null;
-			a !== (r.parent ?? null) && e.move(n, a), t.layer !== r.layer && e.setLayer(n, t.layer), i(t.data, r.data) || e.update(n, { data: t.data }), i(t.dependsOn, r.dependsOn) || e.setDependsOn(n, t.dependsOn), i(t.pose, r.pose) || e.setPose(n, t.pose);
+			a !== (r.parent ?? null) && e.move(n, a), t.layer !== r.layer && e.setLayer(n, t.layer), i(t.data, r.data) || e.update(n, { data: t.data }), i(t.dependsOn, r.dependsOn) || e.setDependsOn(n, t.dependsOn), t.kind === "container" && !i(t.units, r.units) && e.setUnits(n, t.units ?? null), i(t.pose, r.pose) || e.setPose(n, t.pose);
 		}
+		d.some((e) => u.has(e)) && e.setSelection(d.filter((t) => e.get(t) !== void 0));
 	});
 }
 function n(e) {
@@ -30,7 +31,7 @@ function n(e) {
 	return t;
 }
 function r(e, t) {
-	return e.kind !== t.kind || e.pickable !== t.pickable || e.derivePath !== t.derivePath || e.derivePose !== t.derivePose || e.clipFromPose !== t.clipFromPose || e.layout !== t.layout;
+	return e.kind !== t.kind || e.pickable !== t.pickable || e.derivePath !== t.derivePath || e.derivePose !== t.derivePose || e.clipFromPose !== t.clipFromPose || e.copiesFromPose !== t.copiesFromPose || e.layout !== t.layout;
 }
 function i(t, n) {
 	if (Object.is(t, n)) return !0;

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

@@ -1 +1 @@
-{"version":3,"file":"reconcileSpecs.js","names":["reconcileSpecs","prevById","byId","prev","nextById","next","gone","id","before","after","needsReplace","removing","scene","removed","spec","parent","same","out","specs","a","b","v","i","isPlainObject","ka","k"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":";;AAiBA,SAAgBA,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAWC,EAAKC,CAAI,GACpBC,IAAWF,EAAKG,CAAI,GACpBC,IAAiB,CAAC;CACxB,KAAK,IAAM,CAACC,GAAIC,MAAWP,GAAU;EACnC,IAAMQ,IAAQL,EAAS,IAAIG,CAAE;EAC7B,CAAIE,MAAU,KAAA,KAAaC,EAAaF,GAAQC,CAAK,MAAGH,EAAK,KAAKC,CAAE;CACtE;CACA,IAAMI,IAAWC,EAAM,eAAeN,EAAK,QAAQ,MAAOM,EAAM,IAAIL,CAAE,MAAM,KAAA,CAAS,CAAC,GAChFM,IAAU,IAAI,IAAIF,CAAQ;CAEhC,EAAM,gBAAgB;EACpB,EAAM,WAAWA,CAAQ;EACzB,KAAK,IAAMG,KAAQT,GAAM;GACvB,IAAME,IAAKO,EAAK,IACVN,IAASP,EAAS,IAAIM,CAAE;GAC9B,IAAIK,EAAM,IAAIL,CAAE,MAAM,KAAA,KAAaC,MAAW,KAAA,KAAaK,EAAQ,IAAIN,CAAE,GAAG;IAC1E,EAAM,IAAIO,CAAI;IACd;GACF;GACA,IAAMC,IAASD,EAAK,UAAU;GAK9B,AAJIC,OAAYP,EAAO,UAAU,SAAOI,EAAM,KAAKL,GAAIQ,CAAM,GACzDD,EAAK,UAAUN,EAAO,SAAOI,EAAM,SAASL,GAAIO,EAAK,KAAK,GACzDE,EAAKF,EAAK,MAAMN,EAAO,IAAI,KAAGI,EAAM,OAAOL,GAAI,EAAE,MAAMO,EAAK,KAAK,CAAC,GAClEE,EAAKF,EAAK,WAAWN,EAAO,SAAS,KAAGI,EAAM,aAAaL,GAAIO,EAAK,SAAS,GAC7EE,EAAKF,EAAK,MAAMN,EAAO,IAAI,KAAGI,EAAM,QAAQL,GAAIO,EAAK,IAAI;EAChE;CACF,CAAC;AACH;AAEA,SAASZ,EAAgC,GAAqC;CAC5E,IAAMe,oBAAM,IAAI,IAAe;CAC/B,KAAK,IAAMH,KAAQI,GAAO;EACxB,IAAIJ,EAAK,OAAO,KAAA,GAAW,MAAU,MAAM,wCAAwC;EACnF,IAAIG,EAAI,IAAIH,EAAK,EAAE,GAAG,MAAU,MAAM,uBAAuBA,EAAK,GAAG,yBAAyB;EAC9F,EAAI,IAAIA,EAAK,IAAIA,CAAI;CACvB;CACA,OAAOG;AACT;AAEA,SAASP,EACP,GACA,GACS;CACT,OAAOS,EAAE,SAASC,EAAE,QACfD,EAAE,aAAaC,EAAE,YACjBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,eAAeC,EAAE,cACnBD,EAAE,iBAAiBC,EAAE,gBACrBD,EAAE,WAAWC,EAAE;AACtB;AAGA,SAASJ,EAAK,GAAY,GAAqB;CAC7C,IAAI,OAAO,GAAGG,GAAGC,CAAC,GAAG,OAAO;CAC5B,IAAI,MAAM,QAAQD,CAAC,KAAK,MAAM,QAAQC,CAAC,GACrC,OAAOD,EAAE,WAAWC,EAAE,UAAUD,EAAE,OAAO,GAAG,MAAMH,EAAKK,GAAGD,EAAEE,EAAE,CAAC;CAEjE,IAAIC,EAAcJ,CAAC,KAAKI,EAAcH,CAAC,GAAG;EACxC,IAAMI,IAAK,OAAO,KAAKL,CAAC;EACxB,OAAOK,EAAG,WAAW,OAAO,KAAKJ,CAAC,CAAC,CAAC,UAAUI,EAAG,OAAO,MAAMC,KAAKL,KAAKJ,EAAKG,EAAEM,IAAIL,EAAEK,EAAE,CAAC;CAC1F;CACA,OAAO;AACT"}
+{"version":3,"file":"reconcileSpecs.js","names":["reconcileSpecs","prevById","byId","prev","nextById","next","gone","id","before","after","needsReplace","removing","scene","removed","selected","spec","parent","same","out","specs","a","b","v","i","isPlainObject","ka","k"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it, and stays selected if it was.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  // A replaced node is the same node to whoever selected it.\n  const selected = scene.getSelection();\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (spec.kind === 'container' && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n    }\n    if (selected.some((id) => removed.has(id))) {\n      scene.setSelection(selected.filter((id) => scene.get(id) !== undefined));\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.copiesFromPose !== b.copiesFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":"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"}

package/dist/core/scene/recorder.js

@@ -0,0 +1,86 @@
+import { bindOpToAdapter as e } from "./boundOps.js";
+//#region src/core/scene/recorder.ts
+function t(e) {
+	for (let t = e.length - 1; t >= 0; t--) try {
+		e[t].invert().apply(void 0);
+	} catch {}
+}
+function n(n) {
+	let { notifier: r, mode: i, engine: a, log: o, arrivals: s } = n, c = null, l = null;
+	function u(e, t) {
+		let r = e();
+		if (t) for (let e of s.settle()) n.writePose(e.id, e.to);
+		return r;
+	}
+	function d(e, l) {
+		let d = !i.open();
+		d && (c = {
+			label: e,
+			ops: [],
+			outer: [],
+			selectionBefore: n.selection()
+		});
+		let f = d && s.open(!0);
+		return r.deferred(() => i.during("batch", () => {
+			if (!d) return l();
+			try {
+				let e = o.atomically(() => u(l, f), () => (c?.ops.length ?? 0) > 0);
+				return f && s.emitReflow(), e;
+			} catch (e) {
+				throw t(c?.outer ?? []), c = null, e;
+			}
+		}), () => {
+			if (f && s.abandon(), !d || !c) return;
+			let e = c;
+			c = null, e.ops.length > 0 && a.recordEntry(e.ops, e.label, { selectionBefore: e.selectionBefore });
+		});
+	}
+	return {
+		record(e, t, s) {
+			i.records() && !c ? i.during("own", () => a.applyOps([n.makeOp(e, t)], s)) : (n.runOp(e, t), o.logApplied(e, t), i.records() ? c.ops.push(n.makeOp(e, t)) : i.untracked() || l?.push(n.makeOp(e, t))), r.notify();
+		},
+		edit: (e, t, n) => t && s.bareLayoutEdit() ? d(e, n) : n(),
+		batch: d,
+		untracked(e) {
+			let t = r.version(), n = s.open(!0);
+			return r.deferred(() => i.during("untracked", () => {
+				let t = o.atomically(() => u(e, n), () => !1);
+				return n && s.emitReflow(), t;
+			}), () => {
+				n && s.abandon(), r.version() !== t && a.seal();
+			});
+		},
+		joins: () => i.records() && c !== null,
+		join(n, r) {
+			let i = c, a = i.ops.length, s = [];
+			try {
+				o.atomically(() => {
+					for (let t of n) {
+						let n = i.ops.length, a = t.apply(r);
+						i.ops.length > n || a === !1 || a === "noop" || (s.push(e(t, r)), i.ops.push(s[s.length - 1]));
+					}
+				}, () => !1);
+			} catch (e) {
+				throw t(s), i.ops.length = a, e;
+			}
+			i.outer.push(...s);
+		},
+		capturing(e) {
+			let t = l, n = [];
+			l = n;
+			try {
+				return {
+					result: e(),
+					ops: n
+				};
+			} finally {
+				l = t;
+			}
+		},
+		engineDriven: (e) => i.during("engine", () => r.muted(e))
+	};
+}
+//#endregion
+export { n as createRecorder };
+
+//# sourceMappingURL=recorder.js.map