@weasel-js/core 1.14.2 → 1.15.1

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

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

package/dist/core/scene/kitRegistry.js

@@ -1,8 +1,8 @@
 import { unionAABB } from "../geometry/unionBounds.js";
-import { BOOLEAN_OF_CHILDREN, booleanOfChildren } from "./booleanOfChildren.js";
 import { CLIP_NOTHING, clipNothing } from "./clipNothing.js";
+import { BOOLEAN_OF_CHILDREN, booleanOfChildren } from "./booleanOfChildren.js";
 
-//#region src/core/scene/kitRegistry.ts
+// src/core/scene/kitRegistry.ts
 /**
 * The `SceneRegistry` entries the kit owns.
 *
@@ -65,6 +65,5 @@ function withKitRegistry(registry) {
 	};
 }
 
-//#endregion
 export { UNION_OF_CHILDREN, asRectPose, unionOfChildren, withKitRegistry };
 //# sourceMappingURL=kitRegistry.js.map

package/dist/core/scene/layerOps.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/layerOps.ts
+// src/core/scene/layerOps.ts
 function setParallax(record, to) {
 	if (to === void 0) delete record.parallax;
 	else record.parallax = to;
@@ -77,6 +77,5 @@ function registerLayerOps(env) {
 	});
 }
 
-//#endregion
 export { registerLayerOps };
 //# sourceMappingURL=layerOps.js.map

package/dist/core/scene/layerStack.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/layerStack.ts
+// src/core/scene/layerStack.ts
 /** A declared system layer as the stack holds it. */
 function systemLayerRecord(spec) {
 	return {
@@ -157,6 +157,5 @@ function createLayerEdits(env) {
 	};
 }
 
-//#endregion
 export { createLayerEdits, createLayerStack, systemLayerRecord };
 //# sourceMappingURL=layerStack.js.map

package/dist/core/scene/layoutPass.js

@@ -1,11 +1,11 @@
 import { composeWorldPose, rebaseLocalPose } from "./composeFrame.js";
-import { samePoseValue } from "./poseSnapshot.js";
-import { definesFrame, documentPose } from "./effectivePose.js";
 import { carriedDescendants } from "./carryDescendants.js";
-import { strategyView } from "./strategyView.js";
+import { definesFrame, documentPose } from "./effectivePose.js";
 import { asRectPose } from "./kitRegistry.js";
+import { samePoseValue } from "./poseSnapshot.js";
+import { strategyView } from "./strategyView.js";
 
-//#region src/core/scene/layoutPass.ts
+// src/core/scene/layoutPass.ts
 /**
 * The one computation behind a scene's container layouts: given the
 * containers one edit changed, the pose writes their layouts ask for.
@@ -162,6 +162,5 @@ function runLayoutPass(source, layoutOf, arrivals, changed, frame, departures =
 	return out;
 }
 
-//#endregion
 export { resized, resolveLayoutFrame, runLayoutPass };
 //# sourceMappingURL=layoutPass.js.map

package/dist/core/scene/lockGuard.js

@@ -1,6 +1,6 @@
 import { isNodeHidden, isNodeLocked, nodeGates } from "./nodeGates.js";
 
-//#region src/core/scene/lockGuard.ts
+// src/core/scene/lockGuard.ts
 /**
 * The scene's lock guard: what a lock refuses, what the selection may hold,
 * and how a caller that is restoring an already-legal state gets past it.
@@ -47,6 +47,5 @@ function createLockGuard(state) {
 	};
 }
 
-//#endregion
 export { createLockGuard };
 //# sourceMappingURL=lockGuard.js.map

package/dist/core/scene/minSize.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/minSize.ts
+// src/core/scene/minSize.ts
 /** A node's minimum, from `data.minSize`, or `null` when it has none. A
 *  side that is not a positive number holds nothing. */
 function minSizeOf(data) {
@@ -12,6 +12,5 @@ function minSizeOf(data) {
 	} : null;
 }
 
-//#endregion
 export { minSizeOf };
 //# sourceMappingURL=minSize.js.map

package/dist/core/scene/nestedHit.js

@@ -2,7 +2,7 @@ import { worldPoseLookup } from "./composePose.js";
 import { poseDescriptorForNode } from "../geometry/poseDescriptor.js";
 import { AUTO_POSE_DESCRIPTOR } from "../geometry/autoPoseDescriptor.js";
 
-//#region src/core/scene/nestedHit.ts
+// src/core/scene/nestedHit.ts
 /** Build hit-testers that respect containers: a plain click selects the
 *  top-level ancestor, and alt-clicking descends one level at a time toward
 *  the leaf actually under the pointer. */
@@ -49,6 +49,5 @@ function nestedHitTester(adapter, opts) {
 	};
 }
 
-//#endregion
 export { nestedHitTester };
 //# sourceMappingURL=nestedHit.js.map

package/dist/core/scene/nodeAsShown.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/nodeAsShown.ts
+// src/core/scene/nodeAsShown.ts
 /** Marks a node whose data is already shown. An own enumerable key, so a spread
 *  of the node (`{ ...node, pose }`) carries it, and applying an override to a
 *  copy of a shown node is a no-op however the copy was made. */
@@ -67,6 +67,5 @@ function nodesAsShown(overrides, nodes) {
 	return held.any ? nodes.map((node) => nodeAsShown(overrides, node)) : nodes;
 }
 
-//#endregion
 export { nodeAsShown, nodesAsShown, shownCopyOf, shownLookup, withShownData };
 //# sourceMappingURL=nodeAsShown.js.map

package/dist/core/scene/nodeFlags.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/nodeFlags.ts
+// src/core/scene/nodeFlags.ts
 /** Stored only while set, so a snapshot of an unflagged node carries neither. */
 function write(node, flag, to) {
 	if (to) node[flag] = true;
@@ -44,6 +44,5 @@ function createNodeFlags(env) {
 	};
 }
 
-//#endregion
 export { createNodeFlags };
 //# sourceMappingURL=nodeFlags.js.map

package/dist/core/scene/nodeFnFields.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/nodeFnFields.ts
+// src/core/scene/nodeFnFields.ts
 var NODE_FN_FIELDS = [
 	{
 		field: "clipFromPose",
@@ -93,6 +93,5 @@ function fnFieldsOfNode(node) {
 	return out;
 }
 
-//#endregion
 export { NODE_FN_FIELDS, createNodeFnFields, fnFieldsOfNode, fnKeysOf, restoreFn };
 //# sourceMappingURL=nodeFnFields.js.map

package/dist/core/scene/nodeGates.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/nodeGates.ts
+// src/core/scene/nodeGates.ts
 /** Whether `node`'s own flag hides it and its subtree. A walk from the roots
 *  down prunes where this holds instead of asking {@link NodeGates.hidden}
 *  per node; the two agree because this is the flag that answer climbs for. */
@@ -53,12 +53,12 @@ function nodeGates(scene) {
 	const lockedAbove = above(ownLock);
 	return {
 		hidden(id) {
-			const node = scene.get(id);
+			const node = typeof id === "string" ? scene.get(id) : id;
 			if (node === void 0) return false;
 			return hiddenLayers?.has(node.layer) === true || hidesSubtree(node) || hiddenAbove(node.parent ?? null);
 		},
 		locked(id) {
-			const node = scene.get(id);
+			const node = typeof id === "string" ? scene.get(id) : id;
 			if (node === void 0) return false;
 			return ownLock(node) || lockedAbove(node.parent ?? null);
 		}
@@ -102,6 +102,5 @@ function isNodeLocked(scene, id) {
 	return climbs(scene, id, layers === null ? (node) => node.locked === true : (node) => node.locked === true || layers.has(node.layer));
 }
 
-//#endregion
 export { hidesSubtree, isNodeHidden, isNodeLocked, nodeGates };
 //# sourceMappingURL=nodeGates.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeGates.js","names":[],"sources":["../../../src/core/scene/nodeGates.ts"],"sourcesContent":["/**\n * Whether a node is shown, and whether it is in reach — the one place either\n * question is answered. Painting, picking, area selection, select-all,\n * snapping, export, and the scene's own lock guard all ask here.\n *\n * - **Hidden**: its own layer is not visible, or it or any ancestor carries\n *   `hidden`. A layer hides only the nodes tagged to it; a hidden node hides\n *   its whole subtree, as SVG's `display=\"none\"` does.\n * - **Locked**: it or any ancestor carries `locked`, or sits on a locked\n *   layer. A lock covers the whole subtree, whatever layers it spans.\n */\nimport type { NodeId } from './types';\n\n/** The node fields the gates read. A partial scene stand-in may leave `parent` out. */\nexport interface GatedNode {\n  readonly layer: string;\n  readonly parent?: string | null;\n  readonly hidden?: boolean;\n  readonly locked?: boolean;\n}\n\n/** The layer fields the gates read. Only an explicit `visible: false` hides. */\nexport interface GatedLayer {\n  readonly id: string;\n  readonly visible?: boolean;\n  readonly locked?: boolean;\n}\n\n/** What the gates read of a scene. A `Scene` is one. */\nexport interface GateSource {\n  readonly layers?: readonly GatedLayer[];\n  get(id: NodeId): GatedNode | undefined;\n}\n\n/** Whether `node`'s own flag hides it and its subtree. A walk from the roots\n *  down prunes where this holds instead of asking {@link NodeGates.hidden}\n *  per node; the two agree because this is the flag that answer climbs for. */\nexport function hidesSubtree(node: { readonly hidden?: boolean }): boolean {\n  return node.hidden === true;\n}\n\n/** Both answers, for one read of a scene. */\nexport interface NodeGates {\n  /** Whether `id` is not drawn. An id not in the scene is not hidden. */\n  hidden(id: string): boolean;\n  /** Whether `id` is out of reach. An id not in the scene is not locked. */\n  locked(id: string): boolean;\n}\n\n/**\n * The gates over `scene` as it stands now. Ancestor answers are remembered,\n * so a walk over every node climbs each chain once: build one per walk, and\n * a fresh one after an edit.\n */\nexport function nodeGates(scene: GateSource): NodeGates {\n  const hiddenLayers = flaggedLayers(scene, 'hidden');\n  const lockedLayers = flaggedLayers(scene, 'locked');\n  const ownLock = lockedLayers === null\n    ? (node: GatedNode) => node.locked === true\n    : (node: GatedNode) => node.locked === true || lockedLayers.has(node.layer);\n\n  /** Whether `test` holds on the node at `parent` or any of its ancestors.\n   *  Only ancestors are remembered, so a walk over a flat scene allocates\n   *  nothing; that walk is every pick made after an edit. */\n  const above = (test: (node: GatedNode) => boolean) => {\n    const memo = new Map<string, boolean>();\n    const path: string[] = [];\n    return (parent: string | null): boolean => {\n      if (parent === null) return false;\n      let out = false;\n      let seen: Set<string> | null = null;\n      path.length = 0;\n      for (let at: string | null = parent; at !== null; ) {\n        const known = memo.get(at);\n        if (known !== undefined) { out = known; break; }\n        const node = scene.get(at as NodeId);\n        if (node === undefined) break;\n        if (path.length > 64) {\n          seen ??= new Set(path);\n          if (seen.has(at)) break;\n          seen.add(at);\n        }\n        path.push(at);\n        if (test(node)) { out = true; break; }\n        at = node.parent ?? null;\n      }\n      for (const id of path) memo.set(id, out);\n      return out;\n    };\n  };\n\n  const hiddenAbove = above(hidesSubtree);\n  const lockedAbove = above(ownLock);\n  return {\n    hidden(id) {\n      const node = scene.get(id as NodeId);\n      if (node === undefined) return false;\n      return hiddenLayers?.has(node.layer) === true || hidesSubtree(node) || hiddenAbove(node.parent ?? null);\n    },\n    locked(id) {\n      const node = scene.get(id as NodeId);\n      if (node === undefined) return false;\n      return ownLock(node) || lockedAbove(node.parent ?? null);\n    },\n  };\n}\n\n/** Whether `test` holds on the node at `id` or any ancestor, without the\n *  allocation {@link nodeGates} spends on a walk: the scene's lock guard asks\n *  this on every mutation. A parent cycle answers false, as the walk's does. */\nfunction climbs(scene: GateSource, id: string, test: (node: GatedNode) => boolean): boolean {\n  let seen: Set<string> | null = null;\n  let hops = 0;\n  for (let at: string | null = id; at !== null; ) {\n    const node = scene.get(at as NodeId);\n    if (node === undefined) return false;\n    if (++hops > 64) {\n      seen ??= new Set();\n      if (seen.has(at)) return false;\n      seen.add(at);\n    }\n    if (test(node)) return true;\n    at = node.parent ?? null;\n  }\n  return false;\n}\n\n/** The layers flagged `flag`, or null when none is: the usual answer, which\n *  lets a climb skip the layer test at every hop. */\nfunction flaggedLayers(scene: GateSource, flag: 'locked' | 'hidden'): Set<string> | null {\n  let out: Set<string> | null = null;\n  for (const l of scene.layers ?? []) {\n    if (flag === 'locked' ? l.locked === true : l.visible === false) (out ??= new Set()).add(l.id);\n  }\n  return out;\n}\n\n/** {@link NodeGates.hidden} for one id. */\nexport function isNodeHidden(scene: GateSource, id: NodeId): boolean {\n  const node = scene.get(id);\n  if (node === undefined) return false;\n  return flaggedLayers(scene, 'hidden')?.has(node.layer) === true || climbs(scene, id, hidesSubtree);\n}\n\n/** {@link NodeGates.locked} for one id. */\nexport function isNodeLocked(scene: GateSource, id: NodeId): boolean {\n  const layers = flaggedLayers(scene, 'locked');\n  return climbs(scene, id, layers === null\n    ? (node) => node.locked === true\n    : (node) => node.locked === true || layers.has(node.layer));\n}\n"],"mappings":"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"}
+{"version":3,"file":"nodeGates.js","names":[],"sources":["../../../src/core/scene/nodeGates.ts"],"sourcesContent":["/**\n * Whether a node is shown, and whether it is in reach — the one place either\n * question is answered. Painting, picking, area selection, select-all,\n * snapping, export, and the scene's own lock guard all ask here.\n *\n * - **Hidden**: its own layer is not visible, or it or any ancestor carries\n *   `hidden`. A layer hides only the nodes tagged to it; a hidden node hides\n *   its whole subtree, as SVG's `display=\"none\"` does.\n * - **Locked**: it or any ancestor carries `locked`, or sits on a locked\n *   layer. A lock covers the whole subtree, whatever layers it spans.\n */\nimport type { NodeId } from './types';\n\n/** The node fields the gates read. A partial scene stand-in may leave `parent` out. */\nexport interface GatedNode {\n  readonly layer: string;\n  readonly parent?: string | null;\n  readonly hidden?: boolean;\n  readonly locked?: boolean;\n}\n\n/** The layer fields the gates read. Only an explicit `visible: false` hides. */\nexport interface GatedLayer {\n  readonly id: string;\n  readonly visible?: boolean;\n  readonly locked?: boolean;\n}\n\n/** What the gates read of a scene. A `Scene` is one. */\nexport interface GateSource {\n  readonly layers?: readonly GatedLayer[];\n  get(id: NodeId): GatedNode | undefined;\n}\n\n/** Whether `node`'s own flag hides it and its subtree. A walk from the roots\n *  down prunes where this holds instead of asking {@link NodeGates.hidden}\n *  per node; the two agree because this is the flag that answer climbs for. */\nexport function hidesSubtree(node: { readonly hidden?: boolean }): boolean {\n  return node.hidden === true;\n}\n\n/** Both answers, for one read of a scene. Each takes an id, or the node a\n *  walk already holds, which saves looking it up. */\nexport interface NodeGates {\n  /** Whether `id` is not drawn. An id not in the scene is not hidden. */\n  hidden(id: string | GatedNode): boolean;\n  /** Whether `id` is out of reach. An id not in the scene is not locked. */\n  locked(id: string | GatedNode): boolean;\n}\n\n/**\n * The gates over `scene` as it stands now. Ancestor answers are remembered,\n * so a walk over every node climbs each chain once: build one per walk, and\n * a fresh one after an edit.\n */\nexport function nodeGates(scene: GateSource): NodeGates {\n  const hiddenLayers = flaggedLayers(scene, 'hidden');\n  const lockedLayers = flaggedLayers(scene, 'locked');\n  const ownLock = lockedLayers === null\n    ? (node: GatedNode) => node.locked === true\n    : (node: GatedNode) => node.locked === true || lockedLayers.has(node.layer);\n\n  /** Whether `test` holds on the node at `parent` or any of its ancestors.\n   *  Only ancestors are remembered, so a walk over a flat scene allocates\n   *  nothing; that walk is every pick made after an edit. */\n  const above = (test: (node: GatedNode) => boolean) => {\n    const memo = new Map<string, boolean>();\n    const path: string[] = [];\n    return (parent: string | null): boolean => {\n      if (parent === null) return false;\n      let out = false;\n      let seen: Set<string> | null = null;\n      path.length = 0;\n      for (let at: string | null = parent; at !== null; ) {\n        const known = memo.get(at);\n        if (known !== undefined) { out = known; break; }\n        const node = scene.get(at as NodeId);\n        if (node === undefined) break;\n        if (path.length > 64) {\n          seen ??= new Set(path);\n          if (seen.has(at)) break;\n          seen.add(at);\n        }\n        path.push(at);\n        if (test(node)) { out = true; break; }\n        at = node.parent ?? null;\n      }\n      for (const id of path) memo.set(id, out);\n      return out;\n    };\n  };\n\n  const hiddenAbove = above(hidesSubtree);\n  const lockedAbove = above(ownLock);\n  return {\n    hidden(id) {\n      const node = typeof id === 'string' ? scene.get(id as NodeId) : id;\n      if (node === undefined) return false;\n      return hiddenLayers?.has(node.layer) === true || hidesSubtree(node) || hiddenAbove(node.parent ?? null);\n    },\n    locked(id) {\n      const node = typeof id === 'string' ? scene.get(id as NodeId) : id;\n      if (node === undefined) return false;\n      return ownLock(node) || lockedAbove(node.parent ?? null);\n    },\n  };\n}\n\n/** Whether `test` holds on the node at `id` or any ancestor, without the\n *  allocation {@link nodeGates} spends on a walk: the scene's lock guard asks\n *  this on every mutation. A parent cycle answers false, as the walk's does. */\nfunction climbs(scene: GateSource, id: string, test: (node: GatedNode) => boolean): boolean {\n  let seen: Set<string> | null = null;\n  let hops = 0;\n  for (let at: string | null = id; at !== null; ) {\n    const node = scene.get(at as NodeId);\n    if (node === undefined) return false;\n    if (++hops > 64) {\n      seen ??= new Set();\n      if (seen.has(at)) return false;\n      seen.add(at);\n    }\n    if (test(node)) return true;\n    at = node.parent ?? null;\n  }\n  return false;\n}\n\n/** The layers flagged `flag`, or null when none is: the usual answer, which\n *  lets a climb skip the layer test at every hop. */\nfunction flaggedLayers(scene: GateSource, flag: 'locked' | 'hidden'): Set<string> | null {\n  let out: Set<string> | null = null;\n  for (const l of scene.layers ?? []) {\n    if (flag === 'locked' ? l.locked === true : l.visible === false) (out ??= new Set()).add(l.id);\n  }\n  return out;\n}\n\n/** {@link NodeGates.hidden} for one id. */\nexport function isNodeHidden(scene: GateSource, id: NodeId): boolean {\n  const node = scene.get(id);\n  if (node === undefined) return false;\n  return flaggedLayers(scene, 'hidden')?.has(node.layer) === true || climbs(scene, id, hidesSubtree);\n}\n\n/** {@link NodeGates.locked} for one id. */\nexport function isNodeLocked(scene: GateSource, id: NodeId): boolean {\n  const layers = flaggedLayers(scene, 'locked');\n  return climbs(scene, id, layers === null\n    ? (node) => node.locked === true\n    : (node) => node.locked === true || layers.has(node.layer));\n}\n"],"mappings":"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"}

package/dist/core/scene/nodeMemo.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/nodeMemo.ts
+// src/core/scene/nodeMemo.ts
 function createNodeMemoScope() {
 	return /* @__PURE__ */ new WeakMap();
 }
@@ -114,6 +114,5 @@ function dropPoseKeyedMemoSlots(node) {
 	for (const [slot, entry] of record.slots) if (entry.pose !== void 0) record.slots.delete(slot);
 }
 
-//#endregion
 export { bumpNodeMemoGeneration, createNodeMemoScope, dropPoseKeyedMemoSlots, nodeMemo, nodeMemoGeneration };
 //# sourceMappingURL=nodeMemo.js.map

package/dist/core/scene/nodeStore.js

@@ -1,10 +1,10 @@
+import { dwarn } from "../../debug/flag.js";
 import { createDependentsIndex } from "./dependents.js";
 import { dropPoseKeyedMemoSlots } from "./nodeMemo.js";
-import { dwarn } from "../../debug/flag.js";
 import { restoreFn } from "./nodeFnFields.js";
 import { SceneMembershipError } from "./staleReplay.js";
 
-//#region src/core/scene/nodeStore.ts
+// src/core/scene/nodeStore.ts
 /**
 * The scene's node store: the tree links, the reverse index of who derives
 * from whom, and the function fields a node carries beside its data.
@@ -200,6 +200,5 @@ function createNodeStore(state, invalidateOrder, fnFields) {
 	};
 }
 
-//#endregion
 export { createNodeStore };
 //# sourceMappingURL=nodeStore.js.map

package/dist/core/scene/notifier.js

@@ -1,6 +1,6 @@
 import { createEmitter } from "@weasel-js/registry";
 
-//#region src/core/scene/notifier.ts
+// src/core/scene/notifier.ts
 function createNotifier() {
 	const changed = createEmitter();
 	let version = 0;
@@ -43,6 +43,5 @@ function createNotifier() {
 	};
 }
 
-//#endregion
 export { createNotifier };
 //# sourceMappingURL=notifier.js.map

package/dist/core/scene/opTable.js

@@ -1,4 +1,4 @@
-//#region src/core/scene/opTable.ts
+// src/core/scene/opTable.ts
 function createOpTable(env) {
 	const handlers = /* @__PURE__ */ new Map();
 	function handlerFor(kind) {
@@ -18,6 +18,12 @@ function createOpTable(env) {
 		} else token = handlers.get(kind)?.coalesceKey?.(payload);
 		return token === void 0 ? void 0 : `${kind}:${token}`;
 	}
+	function run(kind, payload, forward) {
+		const handler = handlerFor(kind);
+		if (env.skips(kind, payload, forward)) return "noop";
+		(forward ? handler.apply : handler.revert)(payload);
+		env.applied(kind, payload, !forward);
+	}
 	function op(kind, payload, forward = true) {
 		handlerFor(kind);
 		return {
@@ -25,16 +31,10 @@ function createOpTable(env) {
 			args: payload,
 			coalesceKey: coalesceKeyFor(kind, payload),
 			apply: () => {
-				const run = () => {
-					const handler = handlerFor(kind);
-					if (env.skips(kind, payload, forward)) return "noop";
-					(forward ? handler.apply : handler.revert)(payload);
-					env.applied(kind, payload, !forward);
-				};
-				if (env.driven()) return run();
+				if (env.driven()) return run(kind, payload, forward);
 				let result;
 				env.replayAlone(() => {
-					result = run();
+					result = run(kind, payload, forward);
 				});
 				return result;
 			},
@@ -51,6 +51,5 @@ function createOpTable(env) {
 	};
 }
 
-//#endregion
 export { createOpTable };
 //# sourceMappingURL=opTable.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"opTable.js","names":[],"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,SAAgB,cAAc,KAA0B;CACtD,MAAM,2BAAW,IAAI,IAAmC;CAExD,SAAS,WAAW,MAAqC;EACvD,MAAM,UAAU,SAAS,IAAI,IAAI;EACjC,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qCAAqC,KAAK,EAAE;EAC1E,OAAO;CACT;;;;CAKA,SAAS,eAAe,MAAc,SAAsC;EAC1E,IAAI;EACJ,IAAI,KAAK,WAAW,MAAM,GAAG;GAC3B,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO;GAC5D,MAAM,IAAI;GACV,QACE,OAAO,EAAE,OAAO,WAAW,EAAE,KAC3B,OAAO,EAAE,UAAU,WAAW,EAAE,QAChC;EACN,OACE,QAAQ,SAAS,IAAI,IAAI,CAAC,EAAE,cAAc,OAAO;EAEnD,OAAO,UAAU,SAAY,SAAY,GAAG,KAAK,GAAG;CACtD;CAEA,SAAS,GAAG,MAAc,SAAkB,UAAU,MAAU;EAC9D,WAAW,IAAI;EACf,OAAO;GACL,MAAM;GACN,MAAM;GACN,aAAa,eAAe,MAAM,OAAO;GACzC,aAAa;IACX,MAAM,YAAgC;KACpC,MAAM,UAAU,WAAW,IAAI;KAC/B,IAAI,IAAI,MAAM,MAAM,SAAS,OAAO,GAAG,OAAO;KAC9C,CAAC,UAAU,QAAQ,QAAQ,QAAQ,OAAA,CAAQ,OAAO;KAClD,IAAI,QAAQ,MAAM,SAAS,CAAC,OAAO;IAErC;IACA,IAAI,IAAI,OAAO,GAAG,OAAO,IAAI;IAC7B,IAAI;IACJ,IAAI,kBAAkB;KAAE,SAAS,IAAI;IAAG,CAAC;IACzC,OAAO;GACT;GACA,cAAc,GAAG,MAAM,SAAS,CAAC,OAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,MAAM,YAAY;GAAE,SAAS,IAAI,MAAM,OAAO;EAAG;EAC5D,MAAM,MAAM,YAAY,WAAW,IAAI,CAAC,CAAC,MAAM,OAAO;EACtD,KAAK,MAAM,YAAY,GAAG,MAAM,OAAO;CACzC;AACF"}
+{"version":3,"file":"opTable.js","names":[],"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 run(kind: string, payload: unknown, forward: boolean): '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\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        if (env.driven()) return run(kind, payload, forward);\n        let result: 'noop' | undefined;\n        env.replayAlone(() => { result = run(kind, payload, forward); });\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,SAAgB,cAAc,KAA0B;CACtD,MAAM,2BAAW,IAAI,IAAmC;CAExD,SAAS,WAAW,MAAqC;EACvD,MAAM,UAAU,SAAS,IAAI,IAAI;EACjC,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qCAAqC,KAAK,EAAE;EAC1E,OAAO;CACT;;;;CAKA,SAAS,eAAe,MAAc,SAAsC;EAC1E,IAAI;EACJ,IAAI,KAAK,WAAW,MAAM,GAAG;GAC3B,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO;GAC5D,MAAM,IAAI;GACV,QACE,OAAO,EAAE,OAAO,WAAW,EAAE,KAC3B,OAAO,EAAE,UAAU,WAAW,EAAE,QAChC;EACN,OACE,QAAQ,SAAS,IAAI,IAAI,CAAC,EAAE,cAAc,OAAO;EAEnD,OAAO,UAAU,SAAY,SAAY,GAAG,KAAK,GAAG;CACtD;CAEA,SAAS,IAAI,MAAc,SAAkB,SAAsC;EACjF,MAAM,UAAU,WAAW,IAAI;EAC/B,IAAI,IAAI,MAAM,MAAM,SAAS,OAAO,GAAG,OAAO;EAC9C,CAAC,UAAU,QAAQ,QAAQ,QAAQ,OAAA,CAAQ,OAAO;EAClD,IAAI,QAAQ,MAAM,SAAS,CAAC,OAAO;CAErC;CAEA,SAAS,GAAG,MAAc,SAAkB,UAAU,MAAU;EAC9D,WAAW,IAAI;EACf,OAAO;GACL,MAAM;GACN,MAAM;GACN,aAAa,eAAe,MAAM,OAAO;GACzC,aAAa;IACX,IAAI,IAAI,OAAO,GAAG,OAAO,IAAI,MAAM,SAAS,OAAO;IACnD,IAAI;IACJ,IAAI,kBAAkB;KAAE,SAAS,IAAI,MAAM,SAAS,OAAO;IAAG,CAAC;IAC/D,OAAO;GACT;GACA,cAAc,GAAG,MAAM,SAAS,CAAC,OAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,MAAM,YAAY;GAAE,SAAS,IAAI,MAAM,OAAO;EAAG;EAC5D,MAAM,MAAM,YAAY,WAAW,IAAI,CAAC,CAAC,MAAM,OAAO;EACtD,KAAK,MAAM,YAAY,GAAG,MAAM,OAAO;CACzC;AACF"}

package/dist/core/scene/outerOps.js

@@ -1,7 +1,7 @@
 import { rebuildOp } from "../ops/registry.js";
 import { bindOpToAdapter, bindOpToHistoryAdapter } from "./boundOps.js";
 
-//#region src/core/scene/outerOps.ts
+// src/core/scene/outerOps.ts
 /** A kit op under the key of the outer op that caused it, so two edits merge
 *  when their outer ops would have. */
 function keyed(kit, outerKey) {
@@ -51,7 +51,7 @@ function createOuterOps(env) {
 		causing: (op) => causing(op),
 		apply(engine, ops, label, adapter) {
 			if (env.recorder().joins()) return env.recorder().join(ops, adapter);
-			const journal = activeJournal?.() ?? null;
+			const journal = env.openJournal() ?? activeJournal?.() ?? null;
 			env.driving(() => {
 				const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));
 				if (journal) journal.applyBatch(bound, label);
@@ -64,10 +64,9 @@ function createOuterOps(env) {
 		setActiveJournalAccessor(fn) {
 			activeJournal = fn;
 		},
-		activeJournal: () => activeJournal?.() ?? null
+		activeJournal: () => env.openJournal() ?? activeJournal?.() ?? null
 	};
 }
 
-//#endregion
 export { createOuterOps };
 //# sourceMappingURL=outerOps.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp"],"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,SAAS,MAAM,KAAS,UAAkC;CACxD,MAAM,MAAM,aAAa,UAAa,IAAI,gBAAgB,SAAY,SAAY,GAAG,SAAS,GAAG,IAAI;CACrG,OAAO;EAAE,MAAM,IAAI;EAAM,MAAM,IAAI;EAAM,aAAa;EAAK,OAAO,IAAI;EAAO,QAAQ,IAAI;CAAO;AAClG;AAEA,SAAgB,eAAe,KAA4B;CACzD,IAAI,iBAAyC;CAC7C,IAAI,gBAAgB,IAAI;CAExB,SAAS,QAAQ,IAAQ,QAAY,IAAQ;EAC3C,IAAI,GAAG,QAAQ,OAAO;EACtB,IAAI,SAAe,CAAC,KAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,OAAO,GAAG;GAEV,IAAI,cAAc;IAAE,OAAO,GAAG;GAAa;GAC3C,WAAW,GAAG;GACd,MAAM,SAAS;IACb,MAAM,EAAE,QAAQ,QAAQ,IAAI,SAAS,CAAC,CAAC,gBAAgB,MAAM,MAAM,OAAO,CAAC;IAC3E,IAAI,IAAI,SAAS,GAAG,SAAS,IAAI,KAAK,QAAQ,MAAM,KAAK,GAAG,WAAW,CAAC;IACxE,OAAO;GACT;GACA,cAAc;GACd,cAAc,MAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,MAAM,MAAM;GAClB,MAAM,MAAM,IAAI,IAAI,MAAM,IAAI;GAC9B,IAAI,QAAQ,MAAM,OAAO;GACzB,MAAM,UAAUA,UAAgB,MAAM,IAAI;GAC1C,OAAO,YAAY,OAAO,OAAO,uBAAuB,eAAe,cAAc;EACvF;EACA,UAAU,OAAO,QAAQ,EAAE;EAC3B,MAAM,QAAQ,KAAK,OAAO,SAAS;GACjC,IAAI,IAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAO,IAAI,SAAS,CAAC,CAAC,KAAK,KAAK,OAAO;GACnE,MAAM,UAAU,gBAAgB,KAAK;GACrC,IAAI,cAAc;IAGhB,MAAM,QAAQ,IAAI,KAAK,OAAO,QAAQ,IAAI,gBAAgB,IAAI,OAAO,CAAC,CAAC;IACvE,IAAI,SAAS,QAAQ,WAAW,OAAO,KAAK;SACvC,OAAO,SAAS,OAAO,KAAK;GACnC,CAAC;EACH;EACA,kBAAkB,IAAI;GACpB,iBAAiB;EACnB;EACA,yBAAyB,IAAI;GAC3B,gBAAgB;EAClB;EACA,qBAAqB,gBAAgB,KAAK;CAC5C;AACF"}
+{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp"],"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  /** The innermost journal opened through `scene.history`, which edits go to\n   *  ahead of the accessor's: it is opened inside that one, if anything. */\n  openJournal(): Journal | 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 = env.openJournal() ?? 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: () => env.openJournal() ?? activeJournal?.() ?? null,\n  };\n}\n"],"mappings":";;;;;;AAiDA,SAAS,MAAM,KAAS,UAAkC;CACxD,MAAM,MAAM,aAAa,UAAa,IAAI,gBAAgB,SAAY,SAAY,GAAG,SAAS,GAAG,IAAI;CACrG,OAAO;EAAE,MAAM,IAAI;EAAM,MAAM,IAAI;EAAM,aAAa;EAAK,OAAO,IAAI;EAAO,QAAQ,IAAI;CAAO;AAClG;AAEA,SAAgB,eAAe,KAA4B;CACzD,IAAI,iBAAyC;CAC7C,IAAI,gBAAgB,IAAI;CAExB,SAAS,QAAQ,IAAQ,QAAY,IAAQ;EAC3C,IAAI,GAAG,QAAQ,OAAO;EACtB,IAAI,SAAe,CAAC,KAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,OAAO,GAAG;GAEV,IAAI,cAAc;IAAE,OAAO,GAAG;GAAa;GAC3C,WAAW,GAAG;GACd,MAAM,SAAS;IACb,MAAM,EAAE,QAAQ,QAAQ,IAAI,SAAS,CAAC,CAAC,gBAAgB,MAAM,MAAM,OAAO,CAAC;IAC3E,IAAI,IAAI,SAAS,GAAG,SAAS,IAAI,KAAK,QAAQ,MAAM,KAAK,GAAG,WAAW,CAAC;IACxE,OAAO;GACT;GACA,cAAc;GACd,cAAc,MAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,MAAM,MAAM;GAClB,MAAM,MAAM,IAAI,IAAI,MAAM,IAAI;GAC9B,IAAI,QAAQ,MAAM,OAAO;GACzB,MAAM,UAAUA,UAAgB,MAAM,IAAI;GAC1C,OAAO,YAAY,OAAO,OAAO,uBAAuB,eAAe,cAAc;EACvF;EACA,UAAU,OAAO,QAAQ,EAAE;EAC3B,MAAM,QAAQ,KAAK,OAAO,SAAS;GACjC,IAAI,IAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAO,IAAI,SAAS,CAAC,CAAC,KAAK,KAAK,OAAO;GACnE,MAAM,UAAU,IAAI,YAAY,KAAK,gBAAgB,KAAK;GAC1D,IAAI,cAAc;IAGhB,MAAM,QAAQ,IAAI,KAAK,OAAO,QAAQ,IAAI,gBAAgB,IAAI,OAAO,CAAC,CAAC;IACvE,IAAI,SAAS,QAAQ,WAAW,OAAO,KAAK;SACvC,OAAO,SAAS,OAAO,KAAK;GACnC,CAAC;EACH;EACA,kBAAkB,IAAI;GACpB,iBAAiB;EACnB;EACA,yBAAyB,IAAI;GAC3B,gBAAgB;EAClB;EACA,qBAAqB,IAAI,YAAY,KAAK,gBAAgB,KAAK;CACjE;AACF"}

package/dist/core/scene/pathEffects/blend.js

@@ -1,7 +1,7 @@
 import { boundsOfPath, measurePath, multiply, prepareBlend, rotate, rotatePathAround, transformPath, translate } from "@weasel-js/geom";
 import { lerpFill, lerpStroke } from "@weasel-js/paint";
 
-//#region src/core/scene/pathEffects/blend.ts
+// src/core/scene/pathEffects/blend.ts
 /**
 * A blend's steps: where each sits between its two sources — evenly by
 * count, or a fixed distance apart — and, with a spine, laid along it.
@@ -75,6 +75,5 @@ function blendParts(effect, a, b, spine) {
 	});
 }
 
-//#endregion
 export { blendParts, blendStations };
 //# sourceMappingURL=blend.js.map

package/dist/core/scene/pathEffects/derive.js

@@ -1,10 +1,10 @@
+import { derivedPartsOf, pathFromParts } from "../derivedParts.js";
 import { fontGeneration, noteFontRead, withFontReads } from "../fontReads.js";
 import { samePoseValue, snapshotPose } from "../poseSnapshot.js";
-import { derivedPartsOf, pathFromParts } from "../derivedParts.js";
 import { effectParts } from "./effects.js";
 import { boundsOfPath } from "@weasel-js/geom";
 
-//#region src/core/scene/pathEffects/derive.ts
+// src/core/scene/pathEffects/derive.ts
 /**
 * A path effect as a scene node: a leaf whose `dependsOn` names its sources,
 * whose `data.pathEffect` says what to make of them, and whose path and pose
@@ -113,6 +113,5 @@ function registeredPathEffects(registry) {
 	} : null;
 }
 
-//#endregion
 export { PATH_EFFECT, createPathEffectDerivations, pathEffectNode, pathEffectOf, pathEffectParts, registeredPathEffects };
 //# sourceMappingURL=derive.js.map

package/dist/core/scene/pathEffects/effects.js

@@ -2,7 +2,7 @@ import { blendParts } from "./blend.js";
 import { textAlongParts, wholeItem } from "./textAlong.js";
 import { bendAlongPath, puckerBloatPath, repeatAlongPath, roughenPath, zigzagPath } from "@weasel-js/geom";
 
-//#region src/core/scene/pathEffects/effects.ts
+// src/core/scene/pathEffects/effects.ts
 /**
 * The path effects, each as the parts it paints from its sources: a blend's
 * steps between two shapes, a shape bent along a spine, copies of a shape
@@ -56,6 +56,5 @@ function effectParts(effect, sources) {
 	}
 }
 
-//#endregion
 export { effectParts };
 //# sourceMappingURL=effects.js.map

package/dist/core/scene/pathEffects/foundHidden.js

@@ -1,6 +1,6 @@
 import { pathEffectOf } from "./derive.js";
 
-//#region src/core/scene/pathEffects/foundHidden.ts
+// src/core/scene/pathEffects/foundHidden.ts
 /**
 * A path effect's `foundHidden` names its sources by position, so a retarget
 * of its `dependsOn` carries the record along: every writer of `dependsOn`
@@ -30,6 +30,5 @@ function foundHiddenRetargeted(data, from, to) {
 	};
 }
 
-//#endregion
 export { foundHiddenRetargeted };
 //# sourceMappingURL=foundHidden.js.map

package/dist/core/scene/pathEffects/textAlong.js

@@ -1,7 +1,7 @@
 import { bandParts } from "./textAlongBands.js";
 import { boundsOfPath, multiply, pathShape, placeAlongRun, rotate, runLength, trackRun, transformPath, translate } from "@weasel-js/geom";
 
-//#region src/core/scene/pathEffects/textAlong.ts
+// src/core/scene/pathEffects/textAlong.ts
 /**
 * Text along a path: a source's items — a text node's grapheme clusters, or a
 * whole shape as one item — laid end to end along a path, each turned to it.
@@ -103,6 +103,5 @@ function itemFrame(place, length, lift) {
 var clamp01 = (v) => v > 1 ? 1 : v > 0 ? v : 0;
 var finiteOr = (v, d) => v !== void 0 && Number.isFinite(v) ? v : d;
 
-//#endregion
 export { textAlongParts, wholeItem };
 //# sourceMappingURL=textAlong.js.map

package/dist/core/scene/pathEffects/textAlongBands.js

@@ -1,6 +1,6 @@
 import { polygonFromPoints, runStationAt } from "@weasel-js/geom";
 
-//#region src/core/scene/pathEffects/textAlongBands.ts
+// src/core/scene/pathEffects/textAlongBands.ts
 /**
 * The bands text along a path carries — decoration rules cut into clusters — joined across neighboring items and drawn
 * as ribbons that bend with the path.
@@ -60,6 +60,5 @@ function ribbonPart(r, run, shift) {
 	};
 }
 
-//#endregion
 export { bandParts };
 //# sourceMappingURL=textAlongBands.js.map

package/dist/core/scene/plyStacks.js

@@ -1,6 +1,6 @@
 import { carryBoxPath } from "./depFrame.js";
 
-//#region src/core/scene/plyStacks.ts
+// src/core/scene/plyStacks.ts
 /** Empty stacks. */
 function createPlyStacks() {
 	const plies = /* @__PURE__ */ new Map();
@@ -84,6 +84,5 @@ function plyPath(stack, pose, held) {
 	}
 }
 
-//#endregion
 export { createPlyStacks, plyPath };
 //# sourceMappingURL=plyStacks.js.map

package/dist/core/scene/poseFeed.js

@@ -1,7 +1,7 @@
 import { effectivePose } from "./effectivePose.js";
 import { createEmitter } from "@weasel-js/registry";
 
-//#region src/core/scene/poseFeed.ts
+// src/core/scene/poseFeed.ts
 var EMPTY = Object.freeze([]);
 /** A {@link PoseFeed} over `scene`, reporting effective poses (committed pose
 *  under any override). The first `read()` is a reset listing every node. */
@@ -117,6 +117,5 @@ function createPoseFeed(scene) {
 	};
 }
 
-//#endregion
 export { createPoseFeed };
 //# sourceMappingURL=poseFeed.js.map