@weasel-js/core 1.9.4 → 1.10.1

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

@@ -1 +1 @@
-{"version":3,"file":"scene.js","names":["rebuildGlobalOp","defaultIdCounter","defaultGenerateId","asNodeId","createScene","options","state","order","createRenderOrder","isLockedInternal","refuseLocked","refuseLockedLayer","withLocksLifted","createLockGuard","invalidateOrder","registry","withKitRegistry","fnFields","createNodeFnFields","fnField","f","name","layoutFrame","resolveLayoutFrame","hasLayouts","field","write","node","fn","layoutOfInternal","id","store","createNodeStore","createLayerStack","generateId","listeners","registered","historyAdapterAccessor","bindOpToHistoryAdapter","op","get","dwarn","err","selection","overrides","createPoseOverrides","invalidateDependents","history","createHistory","reachable","ids","notify","makeOp","args","createArrangeOp","writePose","rebuilt","rebuildOp","version","incarnations","nextIncarnation","batchDepth","currentBatch","suppressRecording","untrackedDepth","batchDirty","activeJournalAccessor","arrivalWindow","createArrivalWindow","declaredLayouts","openArrivals","settleArrivals","runArrivalEdit","runLayoutPass","scene","arrived","touched","departed","pose","refuseUntracked","verb","createAppliedLog","listener","registerKitOps","kind","handler","runOp","payload","coalesceKeyFor","dir","logApplied","bindOpToAdapter","adapter","token","p","withRecordingSuppressed","prevSuppress","prevDirty","replay","step","executeAndLog","label","k","h","sceneHistory","createSceneHistory","atomically","n","snapshot","applyBatchNow","journal","bound","ops","out","cur","spec","requireLayerIndex","parent","requireNode","assertSubtreeLayer","bareLayoutEdit","sibs","siblingsOf","index","fnKeysOf","patchNodeFunctions","removalClosure","rootIds","nid","detached","removing","l","r","fnKeys","keys","d","patch","resized","layer","parentNode","subtree","stack","curId","i","sid","dependsOn","to","layout","from","fromKey","toKey","layoutRefs","desc","descendants","fromSibs","fromIndex","toSibs","toIndex","noteArrival","noteDeparture","noteChange","visible","locked","parallax","clamped","rec","tagged","finalIndex","proposed","tempIndex","all","e","undo","redo","total","target","targetIndex","outermost","ownsArrivals","result","emitReflow","finished","versionBefore","serializeScene","specs","specsFromSerialized","json","dependents","childDerived","layerFromSerialized","applyConstructionSpecs","sceneSelectionStore","sceneFromJSON"],"sources":["../../../src/core/scene/scene.ts"],"sourcesContent":["import { createHistory, type HistorySelection, type Journal, type SerializedHistory } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { rebuildOp as rebuildGlobalOp } from 'core/ops/registry';\nimport { createArrangeOp, type ArrangeArgs } from 'core/ops/arrange';\nimport { dwarn } from 'debug/flag';\nimport { sameDependsOn } from './dependents';\nimport { withKitRegistry } from './kitRegistry';\nimport {\n  createNodeFnFields,\n  fnKeysOf,\n  type FnBearingNode,\n  type NodeFnField,\n} from './nodeFnFields';\nimport { createPoseOverrides } from './poseOverrides';\nimport { createRenderOrder } from './renderOrder';\nimport { createLockGuard } from './lockGuard';\nimport { createArrivalWindow } from './arrivalWindow';\nimport { createSceneHistory } from './historyFacade';\nimport { createNodeStore } from './nodeStore';\nimport { createAppliedLog } from './appliedLog';\nimport { createLayerStack } from './layerStack';\nimport { registerKitOps, type RemoveSnapshot, type SetLayoutPayload } from './kitOps';\nimport { layerFromSerialized, serializeScene, specsFromSerialized } from './serialization';\nimport { resized, resolveLayoutFrame, runLayoutPass } from './layoutPass';\nimport type { LayoutStrategy } from '../../layout/types';\nimport {\n  asNodeId,\n  type AddNodeSpec,\n  type LayerRecord,\n  type Node,\n  type NodeId,\n  type RegisteredOp,\n  type Scene,\n  type SceneArrivalHandler,\n  type SceneRegistry,\n  type SerializedScene,\n  type UseSceneOptions,\n  type UserLayerRecord,\n} from './types';\n\ninterface SceneState<TData, TLayer extends string, TPose> {\n  nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n  roots: NodeId[];\n  layers: LayerRecord<TLayer>[];\n  layerIndex: Map<TLayer, number>;\n}\n\nlet defaultIdCounter = 0;\nconst defaultGenerateId = (): NodeId =>\n  asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n\n/** Build a scene outside React. `useScene` is the usual entry point; reach for\n *  this in tests, in headless rendering, or wherever a scene must outlive a\n *  component. Throws if no system layers are declared. */\nexport function createScene<TData, TLayer extends string, TPose = import('../../features/groups/composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose> {\n  if (!options.systemLayers || options.systemLayers.length === 0) {\n    throw new Error('useScene: systemLayers must declare at least one layer');\n  }\n\n  // ── State ──────────────────────────────────────────────────────────────\n  const state: SceneState<TData, TLayer, TPose> = {\n    nodes: new Map(),\n    roots: [],\n    layers: [],\n    layerIndex: new Map(),\n  };\n  const order = createRenderOrder(state);\n  const {\n    isLocked: isLockedInternal, refuse: refuseLocked, refuseLayer: refuseLockedLayer, reachable,\n    lifted: withLocksLifted,\n  } = createLockGuard(state);\n  const invalidateOrder = order.invalidate;\n\n  // The kit's own registry entries sit under the consumer's, so a snapshot\n  // carrying a kit-attached function (a grouped container's derived pose)\n  // reloads in any scene, not only one whose consumer registered the key.\n  const registry = withKitRegistry(options.registry ?? {});\n\n  /**\n   * The registry-keyed function fields — `clipFromPose`, `derivePath`,\n   * `derivePose` — each with its key maps and the side-channel cache the\n   * `kit:add` redo path re-attaches from. A function cannot travel through a\n   * serializable op payload, so `scene.add` and the `initial` loader stash it\n   * here and the replayed op reads it back.\n   *\n   * Those caches are pruned at two hook points, both delivered via the history\n   * engine's `onEvict`, to prevent unbounded growth:\n   *   1. When the redo stack is cleared by a new op (branch-on-edit): any\n   *      kit:add in the discarded entries that references a node absent from\n   *      `state.nodes` is permanently unreachable — its cache entry is dropped.\n   *   2. When the undo stack overflows `historyLimit` and evicts the oldest\n   *      entry: same reasoning applies to the evicted entries.\n   * Invariant: after pruning, no entry remains for a node that is both absent\n   * from `state.nodes` AND unreachable via any remaining undo/redo log entry.\n   */\n  const fnFields = createNodeFnFields<TPose>(registry);\n  const fnField = (name: 'clipFromPose' | 'derivePath' | 'derivePose' | 'layout'): NodeFnField =>\n    fnFields.find((f) => f.spec.field === name)!;\n\n  /** How declared layouts are measured; see `LayoutFrame`. */\n  const layoutFrame = resolveLayoutFrame(options.layoutFrame);\n  /** Latched on the first layout a container is given, so a scene that never\n   *  declares one records exactly the entries it did before layouts existed. */\n  let hasLayouts = false;\n  {\n    const field = fnField('layout');\n    const write = field.write;\n    (field as { write: NodeFnField['write'] }).write = (node, fn) => {\n      if (node.kind === 'container') hasLayouts = true;\n      write(node, fn);\n    };\n  }\n\n  function layoutOfInternal(id: NodeId) {\n    const node = state.nodes.get(id);\n    return node?.kind === 'container' ? (node.layout ?? null) : null;\n  }\n\n  const store = createNodeStore(state, invalidateOrder, fnFields);\n  const {\n    dependents, childDerived, invalidateDependents, requireNode, siblingsOf, descendants, removalClosure,\n    patchNodeFunctions,\n  } = store;\n\n  const { requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer } =\n    createLayerStack(state, invalidateOrder, options.systemLayers);\n\n  const generateId = options.generateId ?? defaultGenerateId;\n\n  const listeners = new Set<() => void>();\n  const registered = new Map<string, RegisteredOp<unknown>>();\n\n  // Accessor for the adapter restored external ops apply against.\n  let historyAdapterAccessor: (() => unknown) | null = null;\n\n  /** Wrap a globally-rebuilt external op so apply resolves the history\n   *  adapter lazily — wiring order vs restoreHistory doesn't matter. An\n   *  unset accessor makes the op a debug-warned no-op, and an apply that\n   *  throws (e.g. the wired adapter lacks a method the op calls) degrades\n   *  the same way — never throws mid-undo, matching the placeholder\n   *  degradation policy. (The engine pops entries before applying, so an\n   *  uncaught throw would corrupt the stacks.) See `bindOpToAdapter` for\n   *  the live `applyBatch` path (fixed call-site adapter). */\n  function bindOpToHistoryAdapter(op: Op): Op {\n    return {\n      name: op.name,\n      args: op.args,\n      label: op.label,\n      get coalesceKey() { return op.coalesceKey; },\n      elideNoop: op.elideNoop,\n      apply: () => {\n        const get = historyAdapterAccessor;\n        if (!get) {\n          dwarn('scene', `restored op \"${op.name ?? '?'}\" has no history adapter — skipping (setHistoryAdapter was not wired)`);\n          return 'noop';\n        }\n        try {\n          return op.apply(get());\n        } catch (err) {\n          dwarn('scene', `restored op \"${op.name ?? '?'}\" failed against the history adapter — skipping: ${String(err)}`);\n          return 'noop';\n        }\n      },\n      invert: () => bindOpToHistoryAdapter(op.invert()),\n    };\n  }\n\n  // The scene's undo/redo engine. Recorded ops are `makeOp` wrappers over\n  // `registered` handlers, so the engine's adapter argument is unused (the\n  /** The transient set of active ids. Deliberately not part of `state`:\n   *  selection is not document content and never reaches `toJSON`. It is\n   *  handed to the history engine so entries can restore it. */\n  let selection: readonly NodeId[] = [];\n\n  /** Ephemeral per-node overrides. Deliberately not part of `state`, for the\n   *  same reason `selection` isn't: not document content, never reaches\n   *  `toJSON`, and never touches history. */\n  const overrides = createPoseOverrides<TPose>(\n    (id) => state.nodes.get(id),\n    invalidateDependents,\n  );\n\n  // wrappers close over their payloads). Eviction (branch-edit redo-clears\n  // + historyLimit overflow) drives function-field cache pruning via onEvict.\n  const history = createHistory(undefined, {\n    selection: {\n      get: () => selection,\n      set: (ids) => { selection = reachable(ids as readonly NodeId[]); notify(); },\n    },\n    ...(options.coalesceWindowMs !== undefined ? { coalesceWindowMs: options.coalesceWindowMs } : {}),\n    ...(options.historyLimit !== undefined ? { historyLimit: options.historyLimit } : {}),\n    // Restore-time rebuild: scene-registered kinds (kit:* + consumer\n    // registerOp) rebuild via makeOp; external ops rebuild via the global\n    // op-factory registry, wrapped in the lazy history-adapter binding.\n    // Return null only when the global registry also misses — the engine\n    // then places its no-op placeholder. (The engine's own global-registry\n    // fallback never fires for scene histories: this hook already\n    // consulted it.)\n    rebuildOp: (name, args) => {\n      if (registered.has(name)) return makeOp(name, args);\n      // Its writes are the scene's own, so it replays without an adapter.\n      if (name === 'arrange') return createArrangeOp(args as ArrangeArgs, undefined, writePose);\n      const rebuilt = rebuildGlobalOp(name, args);\n      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt);\n    },\n  });\n\n  let version = 0;\n  // Keyed by node object: every entry into `state.nodes` is a fresh object and\n  // every edit mutates it in place, which is exactly an incarnation's lifetime.\n  const incarnations = new WeakMap<object, number>();\n  let nextIncarnation = 1;\n  let batchDepth = 0;\n  let currentBatch: { label: string; ops: Op[]; selectionBefore: readonly NodeId[] } | null = null;\n  /** True while the history engine drives mutations (undo/redo/goto, journal\n   *  routing) — suppresses scene-side history recording so engine-applied\n   *  ops that re-enter scene mutation methods don't record twice. */\n  let suppressRecording = false;\n  /** Above zero inside `scene.untracked`, where the APIs that exist to\n   *  record refuse rather than record. */\n  let untrackedDepth = 0;\n\n  // ── Helpers ────────────────────────────────────────────────────────────\n  // When `batchDepth > 0` the per-op `notify()` is coalesced: we still bump\n  // the version so getVersion() reflects in-progress mutations, but we defer\n  // listener dispatch until the outermost batch closes. This avoids one\n  // React re-render per op during high-frequency gestures (e.g. snap moves\n  // that emit ~10 transform ops per pointer-move).\n  let batchDirty = false;\n  // Mutable accessor for the active journal — seeded from options and\n  // swappable via `scene.setActiveJournalAccessor(fn)` so mode machines that\n  // depend on `scene.history` can wire it after construction.\n  let activeJournalAccessor: (() => Journal | null) | null =\n    options.getActiveJournal ?? null;\n\n  const arrivalWindow = createArrivalWindow<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    declared: () => (hasLayouts ? declaredLayouts : null),\n    recordsBareEdits: () => batchDepth === 0 && !suppressRecording,\n    writePose,\n  });\n  const {\n    noteArrival, noteDeparture, noteChange, bareLayoutEdit, open: openArrivals, emitReflow,\n    settle: settleArrivals, runEdit: runArrivalEdit,\n  } = arrivalWindow;\n\n  /** The pass a scene runs over its declared layouts when nothing else is\n   *  installed. */\n  const declaredLayouts: SceneArrivalHandler<TPose> = (arrived, touched, departed) =>\n    runLayoutPass(scene, layoutOfInternal, arrived, touched, layoutFrame, departed);\n\n  function writePose(id: string, pose: unknown): void {\n    scene.setPose(asNodeId(id), pose as TPose);\n  }\n\n  function refuseUntracked(verb: string): void {\n    if (untrackedDepth > 0) throw new Error(`Scene: cannot ${verb} inside untracked() — it records`);\n  }\n\n  const { atomically, logApplied } = createAppliedLog({\n    registered,\n    lifted: withLocksLifted,\n    getSelection: () => selection,\n    setSelection: (ids) => { selection = ids; },\n    notify,\n  });\n\n  function notify(): void {\n    version++;\n    if (batchDepth > 0) {\n      batchDirty = true;\n      return;\n    }\n    for (const listener of listeners) listener();\n  }\n\n  const { layoutRefs } = registerKitOps<TData, TLayer, TPose>({\n    state,\n    register: (kind, handler) => { registered.set(kind, handler); },\n    store,\n    requireLayerIndex,\n    rebuildLayerIndex,\n    invalidateOrder,\n    fnFields,\n    narrowSelection: () => { selection = reachable(selection); },\n  });\n\n  // ── Op execution (used by both kit mutations and consumer recordOp) ────\n  function runOp(kind: string, payload: unknown): void {\n    const handler = registered.get(kind);\n    if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    handler.apply(payload);\n  }\n\n  /** Bridge a registered scene op into an engine `Op`: a direction-flipping\n   *  wrapper over the `RegisteredOp`'s `apply`/`revert` pair. `invert()`\n   *  flips the direction with the same payload, so undo replays `revert`\n   *  and redo replays `apply` — no per-op inverse code. `name`/`args` carry\n   *  the (kind, payload) pair for eviction pruning (and, later,\n   *  serialization). Handler lookup happens at apply time so re-registered\n   *  kinds take effect on replay, but existence is checked eagerly to fail\n   *  fast at the call site. */\n  function makeOp(kind: string, payload: unknown, dir: 'fwd' | 'rev' = 'fwd'): Op {\n    if (!registered.has(kind)) {\n      throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    }\n    return {\n      name: kind,\n      args: payload,\n      coalesceKey: coalesceKeyFor(kind, payload),\n      apply: () => {\n        const handler = registered.get(kind);\n        if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n        (dir === 'fwd' ? handler.apply : handler.revert)(payload);\n        // Only a replay logs here: a first apply is recorded by the entry it\n        // creates, and reverting it would leave that entry describing nothing.\n        if (suppressRecording) logApplied(kind, payload, dir === 'rev');\n      },\n      invert: () => makeOp(kind, payload, dir === 'fwd' ? 'rev' : 'fwd'),\n    };\n  }\n\n  /** Rebind an external op to the adapter supplied at the `applyBatch` call\n   *  site — the scene's engine was constructed without an adapter, so ops\n   *  it stores and later replays must close over the right one. Forwards\n   *  the apply return value (no-op detection) and preserves\n   *  `coalesceKey`/`name`/`args`/`label` for coalescing and eviction. See\n   *  `bindOpToHistoryAdapter` for RESTORED entries (lazy accessor). */\n  function bindOpToAdapter(op: Op, adapter: unknown): Op {\n    return {\n      name: op.name,\n      args: 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: () => op.apply(adapter),\n      invert: () => bindOpToAdapter(op.invert(), adapter),\n    };\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 = registered.get(kind)?.coalesceKey?.(payload);\n    }\n    return token === undefined ? undefined : `${kind}:${token}`;\n  }\n\n  /** Run `fn` with scene-side recording suppressed and per-op notifies\n   *  batched. Used whenever the engine drives mutations (undo/redo/goto):\n   *  engine-applied ops may re-enter scene mutation methods, which must\n   *  apply but not record. The caller fires exactly one `notify()` after. */\n  function withRecordingSuppressed<T>(fn: () => T): T {\n    const prevSuppress = suppressRecording;\n    suppressRecording = true;\n    batchDepth++;\n    const prevDirty = batchDirty;\n    try {\n      return fn();\n    } finally {\n      batchDepth--;\n      suppressRecording = prevSuppress;\n      batchDirty = prevDirty;\n    }\n  }\n\n  /** Run an engine step that replays recorded ops — undo, redo, goto, a\n   *  journal stepping. The engine inverts whole ops when one throws; this\n   *  also reverts the scene writes of the op that threw partway. */\n  function replay(step: () => void): void {\n    atomically(() => withLocksLifted(() => withRecordingSuppressed(step)), () => true);\n  }\n\n  function executeAndLog(kind: string, payload: unknown, label: string): void {\n    if (suppressRecording) {\n      runOp(kind, payload);\n      logApplied(kind, payload);\n      notify();\n      return;\n    }\n    if (currentBatch) {\n      runOp(kind, payload);\n      logApplied(kind, payload);\n      currentBatch.ops.push(makeOp(kind, payload));\n      notify();\n      return;\n    }\n    // The engine applies the op itself (inside applyOps) — no separate\n    // runOp call, or the mutation would run twice.\n    history.applyOps([makeOp(kind, payload)], label);\n    notify();\n  }\n\n  // ── Public Scene object ────────────────────────────────────────────────\n\n  // Register consumer-supplied ops up front.\n  if (options.ops) {\n    for (const [k, h] of Object.entries(options.ops)) {\n      registered.set(k, h);\n    }\n  }\n\n  const sceneHistory = createSceneHistory({\n    engine: history,\n    applying: (step) => atomically(() => withRecordingSuppressed(step), () => true),\n    replay,\n    notify,\n    refuseUntracked,\n    runArrivalEdit,\n    undo: () => { scene.undo(); },\n    redo: () => { scene.redo(); },\n    goto: (n) => { scene.jumpToHistoryIndex(n); },\n    restore: (snapshot) => { scene.restoreHistory(snapshot); },\n  });\n\n  function applyBatchNow(ops: Op[], label: string, adapter: unknown): void {\n    const journal: Journal | null = (activeJournalAccessor ?? (() => null))();\n    // Either route drives mutations from a history engine (the journal's\n    // inner history, or the scene's own), so scene-side recording is\n    // suppressed for the duration: op applies that re-enter scene\n    // mutation methods via the adapter must mutate without re-recording.\n    // batchDepth coalesces the per-op notify() calls (same as\n    // scene.batch); exactly one listener dispatch fires at the end —\n    // mirroring the single-notification semantics callers expect.\n    const prevSuppress = suppressRecording;\n    const prevDirty = batchDirty;\n    suppressRecording = true;\n    batchDepth++;\n    batchDirty = false;\n    try {\n      atomically(() => {\n        // Either engine stores the ops and replays them later, so they are\n        // rebound to this call's adapter: the scene's own engine, and any\n        // journal opened on it, was built without one.\n        const bound = ops.map((op) => bindOpToAdapter(op, adapter));\n        if (journal) journal.applyBatch(bound, label);\n        // Native path: one engine entry, coalescible across applyBatch\n        // calls via the ops' own coalesceKeys.\n        else history.applyOps(bound, label);\n      }, () => true);\n    } finally {\n      batchDepth--;\n      suppressRecording = prevSuppress;\n      // Re-merge any outer batch's pending dirt so a nested call can't\n      // swallow it; at true top level prevDirty is always false.\n      batchDirty = batchDirty || prevDirty;\n      // Flush inside finally so a throwing op can't strand subscribers\n      // after earlier ops in the batch already mutated state (mirrors\n      // scene.batch). Depth-guarded: a nested context defers to the\n      // outermost flush.\n      if (batchDepth === 0 && batchDirty) {\n        batchDirty = false;\n        for (const listener of listeners) listener();\n      }\n    }\n  }\n\n  const scene: Scene<TData, TLayer, TPose> = {\n    get nodes() { return state.nodes; },\n    get roots() { return state.roots; },\n    get layers() { return state.layers; },\n    registry,\n\n    get(id) { return state.nodes.get(id); },\n    incarnation(id) {\n      const node = state.nodes.get(id);\n      if (!node) return undefined;\n      let token = incarnations.get(node);\n      if (token === undefined) {\n        token = nextIncarnation++;\n        incarnations.set(node, token);\n      }\n      return token;\n    },\n\n    childrenOf(id) {\n      const n = state.nodes.get(id);\n      return n && n.kind === 'container' ? n.children : [];\n    },\n\n    ancestorsOf(id) {\n      const out: NodeId[] = [];\n      let cur = state.nodes.get(id)?.parent ?? null;\n      while (cur !== null) {\n        out.push(cur);\n        cur = state.nodes.get(cur)?.parent ?? null;\n      }\n      return out;\n    },\n\n    renderOrder: order.ids,\n    renderOrderNodes: order.nodes,\n    nodesOnLayer: order.nodesOnLayer,\n\n    mintId: generateId,\n\n    add(spec) {\n      const id = spec.id ?? generateId();\n      if (state.nodes.has(id)) {\n        throw new Error(`Scene: id collision on \"${id}\"`);\n      }\n      requireLayerIndex(spec.layer);\n      refuseLockedLayer(spec.layer, 'add to');\n      const parent = spec.parent ?? null;\n      if (parent !== null) {\n        const p = requireNode(parent);\n        if (p.kind !== 'container') {\n          throw new Error(`Scene: parent \"${parent}\" is not a container`);\n        }\n        assertSubtreeLayer(spec.id, spec.layer, parent, p.layer);\n        refuseLocked(parent, 'add under');\n      }\n      if (parent !== null && bareLayoutEdit()) {\n        // A bare add under a container is an edit of its own, so it settles\n        // its arrival like one — as a batch, which is what makes the\n        // arrangement part of the same undo step.\n        return scene.batch(`add ${spec.kind}`, () => scene.add(spec));\n      }\n      const sibs = siblingsOf(parent);\n      const index = spec.index ?? sibs.length;\n      noteArrival(id, parent, null);\n      const payload = {\n        id, kind: spec.kind, layer: spec.layer, pose: spec.pose, data: spec.data,\n        parent, index,\n        ...(spec.dependsOn !== undefined ? { dependsOn: spec.dependsOn } : {}),\n        ...(spec.pickable !== undefined ? { pickable: spec.pickable } : {}),\n        ...fnKeysOf(fnFields, { ...spec, id, kind: spec.kind } as unknown as FnBearingNode, 'opKey'),\n      };\n      executeAndLog('kit:add', payload, `add ${spec.kind}`);\n      patchNodeFunctions(spec, id, payload);\n      return id;\n    },\n\n    remove(id) {\n      scene.removeMany([id]);\n    },\n\n    removalClosure(rootIds) {\n      return removalClosure(rootIds).ids;\n    },\n\n    removeMany(rootIds) {\n      if (rootIds.length === 0) return;\n      // Every id resolves against the pre-removal tree, so an id another one\n      // cascades away is absorbed rather than being a second, failing removal.\n      const { ids, removing } = removalClosure(rootIds);\n      for (const nid of ids) refuseLocked(nid, 'remove');\n      // requireNode is what rejects an id that is not in the scene, and it runs\n      // before anything mutates.\n      const snapshot: Node<TData, TLayer, TPose>[] = ids.map((nid) => {\n        const n = requireNode(nid);\n        return n.kind === 'container' ? { ...n, children: [...n.children] } : { ...n };\n      });\n      // The rest is reachable through a snapshotted parent's cloned `children`.\n      const detached = snapshot\n        .filter((n) => n.parent === null || !removing.has(n.parent))\n        .map((n) => ({ id: n.id, parent: n.parent, index: siblingsOf(n.parent).indexOf(n.id) }))\n        .sort((l, r) => l.index - r.index);\n      // Ephemeral, and ids are reusable: an override left behind would\n      // reattach itself to whatever is added under this id next.\n      for (const nid of ids) overrides.clear(nid);\n      const fnKeys = snapshot.flatMap((n) => {\n        const keys = fnKeysOf(fnFields, n as unknown as FnBearingNode, 'opKey');\n        return Object.keys(keys).length === 0 ? [] : [{ id: n.id, ...keys }];\n      });\n      const payload: RemoveSnapshot<TData, TLayer, TPose> = {\n        nodes: snapshot, detached,\n        ...(fnKeys.length > 0 ? { fnKeys } : {}),\n      };\n      if (detached.some((d) => d.parent !== null) && bareLayoutEdit()) {\n        scene.batch('remove', () => scene.removeMany(rootIds));\n        return;\n      }\n      for (const d of detached) noteDeparture(d.id, d.parent, null);\n      executeAndLog('kit:remove', payload, 'remove');\n    },\n\n    update(id, patch) {\n      const node = requireNode(id);\n      refuseLocked(id, 'update');\n      executeAndLog('kit:setData', { id, from: node.data, to: patch.data }, 'update');\n    },\n\n    setPose(id, pose) {\n      const node = requireNode(id);\n      refuseLocked(id, 'set the pose of');\n      if (node.kind === 'container' && resized(layoutFrame, id, node.pose, pose)) {\n        if (bareLayoutEdit()) {\n          scene.batch('setPose', () => scene.setPose(id, pose));\n          return;\n        }\n        noteChange(id);\n      }\n      executeAndLog('kit:setPose', { id, from: node.pose, to: pose }, 'setPose');\n    },\n\n    setLayer(id, layer) {\n      requireLayerIndex(layer);\n      const node = requireNode(id);\n      refuseLocked(id, 'relayer');\n      if (node.layer !== layer) refuseLockedLayer(layer, 'move nodes onto');\n      if (node.parent !== null) {\n        const parentNode = requireNode(node.parent);\n        assertSubtreeLayer(id, layer, node.parent, parentNode.layer, 'relayer');\n      }\n      if (node.layer === layer) return;\n      // DFS preorder: collect id + all descendants.\n      const subtree: NodeId[] = [];\n      const stack: NodeId[] = [id];\n      while (stack.length > 0) {\n        const curId = stack.pop()!;\n        const cur = state.nodes.get(curId);\n        if (!cur) continue;\n        subtree.push(curId);\n        refuseLocked(curId, 'relayer');\n        if (cur.kind === 'container') {\n          for (let i = cur.children.length - 1; i >= 0; i--) {\n            stack.push(cur.children[i]);\n          }\n        }\n      }\n      if (subtree.length === 1) {\n        // Fast path: single node, no batch needed.\n        executeAndLog('kit:setLayer', { id, from: node.layer, to: layer }, 'setLayer');\n      } else {\n        scene.batch('setLayer', () => {\n          for (const sid of subtree) {\n            const cur = requireNode(sid);\n            if (cur.layer === layer) continue;\n            executeAndLog('kit:setLayer', { id: sid, from: cur.layer, to: layer }, 'setLayer');\n          }\n        });\n      }\n    },\n\n    setDependsOn(id, dependsOn) {\n      const node = requireNode(id);\n      refuseLocked(id, 'retarget');\n      if (sameDependsOn(node.dependsOn, dependsOn)) return;\n      executeAndLog(\n        'kit:setDependsOn',\n        { id, from: node.dependsOn, to: dependsOn },\n        'setDependsOn',\n      );\n    },\n\n    setLayout(id, layout) {\n      const node = requireNode(id);\n      if (node.kind !== 'container') throw new Error(`Scene: \"${id}\" is not a container`);\n      refuseLocked(id, 'set the layout of');\n      const field = fnField('layout');\n      let to: LayoutStrategy<TPose> | null;\n      if (typeof layout === 'string') {\n        to = (field.fnOf(layout) as LayoutStrategy<TPose> | undefined) ?? null;\n        if (to === null) throw new Error(`Scene: no layout \"${layout}\" in this scene's registry`);\n      } else {\n        to = layout;\n      }\n      const from = node.layout ?? null;\n      if (from === to) return;\n      if (to !== null) hasLayouts = true;\n      if (bareLayoutEdit()) {\n        scene.batch('setLayout', () => scene.setLayout(id, to));\n        return;\n      }\n      noteChange(id);\n      const fromKey = from === null ? undefined : field.keyOf(from);\n      const toKey = to === null ? undefined : field.keyOf(to);\n      const payload: SetLayoutPayload = {\n        id,\n        ...(fromKey !== undefined ? { fromKey } : {}),\n        ...(toKey !== undefined ? { toKey } : {}),\n      };\n      layoutRefs.set(payload, { from, to });\n      executeAndLog('kit:setLayout', payload, 'setLayout');\n    },\n\n    move(id, parent, index) {\n      const node = requireNode(id);\n      refuseLocked(id, 'move');\n      if (parent !== null) {\n        refuseLocked(parent, 'move nodes into');\n        const p = requireNode(parent);\n        if (p.kind !== 'container') {\n          throw new Error(`Scene: parent \"${parent}\" is not a container`);\n        }\n        assertSubtreeLayer(id, node.layer, parent, p.layer);\n        // Cycle check: parent must not be id or a descendant of id.\n        if (parent === id) throw new Error('Scene: cannot parent a node to itself');\n        const desc: NodeId[] = [];\n        descendants(id, desc);\n        if (desc.includes(parent)) {\n          throw new Error('Scene: cannot parent a node to its own descendant');\n        }\n      }\n      if ((parent !== null || node.parent !== null) && bareLayoutEdit()) {\n        scene.batch('move', () => scene.move(id, parent, index));\n        return;\n      }\n      const fromSibs = siblingsOf(node.parent);\n      const fromIndex = fromSibs.indexOf(id);\n      const toSibs = parent === node.parent ? fromSibs : siblingsOf(parent);\n      const toIndex = index ?? toSibs.length;\n      noteArrival(id, parent, node.parent);\n      noteDeparture(id, node.parent, parent);\n      noteChange(node.parent);\n      executeAndLog('kit:move', {\n        id, fromParent: node.parent, fromIndex, toParent: parent, toIndex,\n      }, 'move');\n    },\n\n    reorder(id, index) {\n      const node = requireNode(id);\n      refuseLocked(id, 'reorder');\n      if (node.parent !== null && bareLayoutEdit()) {\n        scene.batch('reorder', () => scene.reorder(id, index));\n        return;\n      }\n      noteChange(node.parent);\n      const sibs = siblingsOf(node.parent);\n      const fromIndex = sibs.indexOf(id);\n      executeAndLog('kit:move', {\n        id, fromParent: node.parent, fromIndex, toParent: node.parent, toIndex: index,\n      }, 'reorder');\n    },\n\n    setLayerVisible(layer, visible) {\n      const i = requireLayerIndex(layer);\n      executeAndLog('kit:setLayerVisible', { layer, from: state.layers[i].visible, to: visible }, 'setLayerVisible');\n    },\n\n    setLayerLocked(layer, locked) {\n      const i = requireLayerIndex(layer);\n      executeAndLog('kit:setLayerLocked', { layer, from: state.layers[i].locked, to: locked }, 'setLayerLocked');\n    },\n\n    setLayerParallax(layer, parallax) {\n      const i = requireLayerIndex(layer);\n      executeAndLog(\n        'kit:setLayerParallax',\n        { layer, from: state.layers[i].parallax, to: parallax },\n        'setLayerParallax',\n      );\n    },\n\n    isLocked: (id) => isLockedInternal(id),\n\n    unlocked: (fn) => withLocksLifted(fn),\n\n    addLayer(spec) {\n      if (state.layerIndex.has(spec.id)) {\n        throw new Error(`Scene: duplicate layer id \"${spec.id}\"`);\n      }\n      const index = spec.index ?? state.layers.length;\n      const clamped = Math.max(0, Math.min(index, state.layers.length));\n      const record: UserLayerRecord<TLayer> = {\n        kind: 'user',\n        id: spec.id,\n        name: spec.name,\n        visible: spec.visible ?? true,\n        locked: spec.locked ?? false,\n        ...(spec.parallax ? { parallax: spec.parallax } : {}),\n      };\n      executeAndLog('kit:addLayer', { record, index: clamped }, 'addLayer');\n    },\n\n    removeLayer(layer) {\n      const index = requireLayerIndex(layer);\n      const rec = state.layers[index];\n      if (rec.kind !== 'user') {\n        throw new Error(`Scene: cannot remove system layer \"${layer}\"`);\n      }\n      // A layer operation, like the lock toggle: taking a locked layer away\n      // takes its nodes with it.\n      withLocksLifted(() => scene.batch('removeLayer', () => {\n        const tagged: NodeId[] = [];\n        for (const [id, node] of state.nodes) {\n          if (node.layer === layer) tagged.push(id);\n        }\n        scene.removeMany(tagged);\n        const finalIndex = requireLayerIndex(layer);\n        executeAndLog('kit:removeLayer', { record: rec, index: finalIndex }, 'removeLayer');\n      }));\n    },\n\n    renameLayer(layer, name) {\n      const rec = state.layers[requireLayerIndex(layer)];\n      if (rec.kind !== 'user') {\n        throw new Error(`Scene: cannot rename system layer \"${layer}\"`);\n      }\n      executeAndLog('kit:renameLayer', { layer, from: rec.name, to: name }, 'renameLayer');\n    },\n\n    moveLayer(layer, index) {\n      const from = requireLayerIndex(layer);\n      const to = Math.max(0, Math.min(index, state.layers.length - 1));\n      if (from === to) return;\n      // Build the proposed order and a temp index map, then verify the\n      // child-below-parent invariant holds for every node before mutating.\n      const proposed = [...state.layers];\n      const [rec] = proposed.splice(from, 1);\n      proposed.splice(to, 0, rec);\n      const tempIndex = new Map<TLayer, number>();\n      for (let i = 0; i < proposed.length; i++) tempIndex.set(proposed[i].id, i);\n      for (const node of state.nodes.values()) {\n        if (node.parent === null) continue;\n        const parent = state.nodes.get(node.parent);\n        if (!parent) continue;\n        if (tempIndex.get(node.layer)! < tempIndex.get(parent.layer)!) {\n          throw new Error(\n            `Scene: moveLayer(\"${layer}\", ${index}) — a child may not render below its parent's layer`,\n          );\n        }\n      }\n      executeAndLog('kit:moveLayer', { layer, from, to }, 'moveLayer');\n    },\n\n    registerOp(kind, handler) {\n      if (kind.startsWith('kit:')) {\n        throw new Error(`Scene: op kind \"${kind}\" is reserved (kit:* prefix)`);\n      }\n      registered.set(kind, handler as RegisteredOp<unknown>);\n    },\n\n    recordOp(op) {\n      executeAndLog(op.kind, op.payload, op.kind);\n    },\n\n    setActiveJournalAccessor(fn) {\n      activeJournalAccessor = fn;\n    },\n\n    applyBatch(ops, label, adapter) {\n      refuseUntracked('applyBatch');\n      runArrivalEdit(ops, (all) => applyBatchNow(all, label, adapter));\n    },\n\n    setArrivalHandler: arrivalWindow.setHandler,\n\n    layoutOf(id) {\n      return layoutOfInternal(id);\n    },\n\n    onReflow: arrivalWindow.onReflow,\n\n    overrides,\n\n    getSelection: () => selection,\n\n    setSelection(ids) {\n      selection = reachable([...ids]);\n      notify();\n    },\n\n    history: sceneHistory,\n\n    undo() {\n      if (!history.canUndo()) return false;\n      replay(() => history.undo());\n      notify();\n      return true;\n    },\n\n    redo() {\n      if (!history.canRedo()) return false;\n      replay(() => history.redo());\n      notify();\n      return true;\n    },\n\n    canUndo: () => history.canUndo(),\n    canRedo: () => history.canRedo(),\n\n    /** Read-only snapshot of every history entry currently reachable from\n     *  the present state. Order: oldest applied first, then redoable\n     *  entries in the order they'd be re-applied (top of redo stack last).\n     *  Each entry's `id` is stable for the entry's lifetime. */\n    historyEntries() {\n      const { undo, redo } = history.entries();\n      const out: { id: string; label: string }[] = [];\n      for (const e of undo) out.push({ id: String(e.id), label: e.label });\n      // entries().redo is already chronological: the next redo comes first.\n      for (const e of redo) out.push({ id: String(e.id), label: e.label });\n      return out;\n    },\n\n    /** Index of the \"current state\". `0` = nothing applied (initial);\n     *  equals the number of applied (undoable) entries —\n     *  `historyEntries().length` when fully redone. */\n    historyIndex: () => history.undoDepth(),\n\n    /** Walk to a target history index by calling undo/redo repeatedly.\n     *  Caps at the valid range; returns true if the index changed. */\n    jumpToHistoryIndex(targetIndex: number) {\n      const total = history.undoDepth() + history.redoDepth();\n      const target = Math.max(0, Math.min(total, targetIndex));\n      if (target === history.undoDepth()) return false;\n      replay(() => history.goto(target));\n      notify();\n      return true;\n    },\n\n    serializeHistory: () => history.serialize(),\n\n    restoreHistory(snapshot: SerializedHistory) {\n      // restore() only rebuilds the stacks — no op applies, no node-state\n      // mutation. The caller guarantees state already matches the head.\n      history.restore(snapshot);\n      notify();\n    },\n\n    setHistoryAdapter(fn) {\n      historyAdapterAccessor = fn;\n    },\n\n    batch(label, fn) {\n      // Captured at open, not at recordEntry: by the time the batch closes\n      // the selection has already moved to wherever the batch put it.\n      const outermost = batchDepth === 0;\n      if (outermost) currentBatch = { label, ops: [], selectionBefore: selection };\n      const ownsArrivals = outermost && openArrivals(true);\n      batchDepth++;\n      try {\n        if (!outermost) return fn();\n        try {\n          const result = atomically(() => {\n            const r = fn();\n            if (ownsArrivals) for (const p of settleArrivals()) scene.setPose(asNodeId(p.id), p.to as TPose);\n            return r;\n          }, () => (currentBatch?.ops.length ?? 0) > 0);\n          if (ownsArrivals) emitReflow();\n          return result;\n        } catch (err) {\n          // Reverted already; the half-built entry must not reach history.\n          currentBatch = null;\n          throw err;\n        }\n      } finally {\n        batchDepth--;\n        if (ownsArrivals) arrivalWindow.abandon();\n        if (batchDepth === 0) {\n          if (currentBatch) {\n            const finished = currentBatch;\n            currentBatch = null;\n            // Ops were applied live as they were issued (state stays\n            // readable mid-batch); recordEntry pushes without re-applying.\n            if (finished.ops.length > 0) {\n              history.recordEntry(finished.ops, finished.label, { selectionBefore: finished.selectionBefore });\n            }\n          }\n          // Fire one coalesced notify if any op inside the batch dirtied\n          // state. Nested batches contribute to the same flush — only the\n          // outermost emits.\n          if (batchDirty) {\n            batchDirty = false;\n            for (const listener of listeners) listener();\n          }\n        }\n      }\n    },\n\n    untracked(fn) {\n      const prevSuppress = suppressRecording;\n      const versionBefore = version;\n      suppressRecording = true;\n      untrackedDepth++;\n      const ownsArrivals = openArrivals(true);\n      batchDepth++;\n      try {\n        const result = atomically(() => {\n          const r = fn();\n          if (ownsArrivals) for (const p of settleArrivals()) scene.setPose(asNodeId(p.id), p.to as TPose);\n          return r;\n        }, () => false);\n        if (ownsArrivals) emitReflow();\n        return result;\n      } finally {\n        batchDepth--;\n        if (ownsArrivals) arrivalWindow.abandon();\n        untrackedDepth--;\n        suppressRecording = prevSuppress;\n        if (version !== versionBefore) history.seal();\n        if (batchDepth === 0 && batchDirty) {\n          batchDirty = false;\n          for (const listener of listeners) listener();\n        }\n      }\n    },\n\n    toJSON: () => serializeScene(state, fnFields),\n\n    loadState(json) {\n      // Validate + map up front (throws before we touch live state on a bad\n      // version or unknown registry key).\n      const specs = specsFromSerialized(json, registry);\n      if (batchDepth > 0) {\n        throw new Error('Scene: cannot loadState inside batch() or untracked() — it replaces the state they would revert to');\n      }\n      // Ephemeral, and every id is a new node after this.\n      overrides.clearAll();\n      // Reset node + layer state.\n      dependents.clear();\n      childDerived.clear();\n      state.nodes.clear();\n      state.roots.length = 0;\n      state.layers.length = 0;\n      state.layerIndex.clear();\n      invalidateOrder();\n      for (let i = 0; i < json.systemLayers.length; i++) {\n        const spec = json.systemLayers[i];\n        if (state.layerIndex.has(spec.id)) {\n          throw new Error(`Scene.loadState: duplicate system layer id \"${spec.id}\"`);\n        }\n        state.layers.push(layerFromSerialized(spec));\n        state.layerIndex.set(spec.id, i);\n      }\n      history.clear();\n      // Rebuild nodes (bypass the log, exactly like construction).\n      applyConstructionSpecs(specs);\n      selection = selection.filter((id) => state.nodes.has(id));\n      notify();\n    },\n\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n\n    getVersion: () => version,\n  };\n\n  /** Insert nodes without writing to the undo log — used by construction\n   *  (`options.initial`) and by `loadState`. Specs must list parents before\n   *  children (the order `toJSON()` emits). Throws on id collision, unknown\n   *  layer, non-container parent, or cross-layer subtree. */\n  function applyConstructionSpecs(specs: readonly AddNodeSpec<TData, TLayer, TPose>[]): void {\n    for (const spec of specs) {\n      // Bypass the log: we want construction to start with empty history.\n      const id = spec.id ?? generateId();\n      if (state.nodes.has(id)) {\n        throw new Error(`Scene: id collision on \"${id}\"`);\n      }\n      requireLayerIndex(spec.layer);\n      const parent = spec.parent ?? null;\n      if (parent !== null) {\n        const p = requireNode(parent);\n        if (p.kind !== 'container') {\n          throw new Error(`Scene: parent \"${parent}\" is not a container`);\n        }\n        assertSubtreeLayer(spec.id, spec.layer, parent, p.layer);\n      }\n      const sibs = siblingsOf(parent);\n      const index = spec.index ?? sibs.length;\n      runOp('kit:add', {\n        id, kind: spec.kind, layer: spec.layer, pose: spec.pose, data: spec.data,\n        parent, index,\n        ...(spec.dependsOn !== undefined ? { dependsOn: spec.dependsOn } : {}),\n        ...(spec.pickable !== undefined ? { pickable: spec.pickable } : {}),\n      });\n      // No `kit:add` reaches history here, so nothing replays one. A restore\n      // after `remove` comes from `kit:remove`'s revert, which clones the\n      // whole node and carries every field along.\n      patchNodeFunctions(spec, id, null);\n    }\n  }\n\n  // Apply initial nodes (not undoable — they're part of the construction).\n  if (options.initial) {\n    applyConstructionSpecs(options.initial);\n    notify();\n  }\n\n  return scene;\n}\n\n/** The scene's selection in the shape `createHistory` wants, for a consumer\n *  building a second History over the same scene (a modality machine, a\n *  journal owner) that should restore selection the way the scene's own\n *  history does. */\nexport function sceneSelectionStore(scene: {\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n}): HistorySelection {\n  return {\n    get: () => scene.getSelection(),\n    set: (ids) => scene.setSelection(ids as readonly NodeId[]),\n  };\n}\n\n/** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.\n *  Function fields (e.g., `clipFromPose`) are resolved by string key via the\n *  registry passed in `options`. Throws on unknown version, unknown registry\n *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).\n *  Loaded scenes start with empty history — undo/redo is NOT serialized. */\nexport function sceneFromJSON<TData, TLayer extends string, TPose>(\n  json: SerializedScene<TData, TLayer, TPose>,\n  options: {\n    registry?: SceneRegistry<TPose, TData, TLayer>;\n    historyLimit?: number;\n    coalesceWindowMs?: number;\n    generateId?: () => NodeId;\n    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;\n    layoutFrame?: UseSceneOptions<TData, TLayer, TPose>['layoutFrame'];\n  } = {},\n): Scene<TData, TLayer, TPose> {\n  const registry = options.registry ?? {};\n  // Built empty and then loaded, so the snapshot's layer stack is rebuilt by\n  // the one reader that knows how — `createScene` mints system layers only.\n  const scene = createScene<TData, TLayer, TPose>({\n    systemLayers: json.systemLayers.map((l) => ({ id: l.id })),\n    registry,\n    ...(options.historyLimit !== undefined ? { historyLimit: options.historyLimit } : {}),\n    ...(options.coalesceWindowMs !== undefined ? { coalesceWindowMs: options.coalesceWindowMs } : {}),\n    ...(options.generateId !== undefined ? { generateId: options.generateId } : {}),\n    ...(options.ops !== undefined ? { ops: options.ops } : {}),\n    ...(options.layoutFrame !== undefined ? { layoutFrame: options.layoutFrame } : {}),\n  });\n  scene.loadState(json);\n  return scene;\n}\n"],"mappings":"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"}
+{"version":3,"file":"scene.js","names":["defaultIdCounter","defaultGenerateId","asNodeId","createScene","buildScene","options","systemLayerRecord","layers","registry","withKitRegistry","doc","createSceneState","arrivals","notifier","createNotifier","mode","createEditMode","writePose","id","pose","layoutFrame","resolveLayoutFrame","createArrivalWindow","state","runLayoutPass","scene","reads","arrived","touched","departed","generateId","selection","createSceneSelection","locks","overrides","createPoseOverrides","recording","createSceneRecording","edits","createSceneEdits","kind","handler","IDENTITY_POSE_COMPOSITION","fn","ids","specs","specsFromSerialized","json","layerFromSerialized","initial","initialNodes","sceneFromJSON"],"sources":["../../../src/core/scene/scene.ts"],"sourcesContent":["import { withKitRegistry } from './kitRegistry';\nimport { createPoseOverrides } from './poseOverrides';\nimport { createArrivalWindow } from './arrivalWindow';\nimport { createNotifier } from './notifier';\nimport { createEditMode } from './editMode';\nimport { createSceneEdits } from './sceneEdits';\nimport { createSceneRecording } from './sceneRecording';\nimport { createSceneSelection } from './sceneSelection';\nimport { createSceneState } from './sceneState';\nimport { systemLayerRecord } from './layerStack';\nimport { layerFromSerialized, specsFromSerialized } from './serialization';\nimport { resolveLayoutFrame, runLayoutPass } from './layoutPass';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from './composeFrame';\nimport {\n  asNodeId,\n  type AddNodeSpec,\n  type LayerRecord,\n  type NodeId,\n  type RegisteredOp,\n  type Scene,\n  type SceneRegistry,\n  type SerializedScene,\n  type UseSceneOptions,\n} from './types';\n\nlet defaultIdCounter = 0;\nconst defaultGenerateId = (): NodeId =>\n  asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n\n/** Build a scene outside React. `useScene` is the usual entry point; reach for\n *  this in tests, in headless rendering, or wherever a scene must outlive a\n *  component. Throws if no system layers are declared. */\nexport function createScene<TData, TLayer extends string, TPose = import('./composePose').RectPose>(\n  options: UseSceneOptions<TData, TLayer, TPose>,\n): Scene<TData, TLayer, TPose> {\n  return buildScene(options, (options.systemLayers ?? []).map(systemLayerRecord), () => options.initial);\n}\n\ntype SceneConfig<TData, TLayer extends string, TPose> =\n  Omit<UseSceneOptions<TData, TLayer, TPose>, 'systemLayers' | 'initial'>;\n\n/** A scene holding `layers`, and the nodes `initialNodes` answers with once\n *  it is handed the registry their functions resolve against. */\nfunction buildScene<TData, TLayer extends string, TPose>(\n  options: SceneConfig<TData, TLayer, TPose>,\n  layers: readonly LayerRecord<TLayer>[],\n  initialNodes: (registry: SceneRegistry<TPose, TData, TLayer>) => readonly AddNodeSpec<TData, TLayer, TPose>[] | undefined,\n): Scene<TData, TLayer, TPose> {\n  if (layers.length === 0) throw new Error('Scene: systemLayers must declare at least one layer');\n\n  // The kit's own registry entries sit under the consumer's, so a snapshot\n  // carrying a kit-attached function (a grouped container's derived pose)\n  // reloads in any scene, not only one whose consumer registered the key.\n  const registry = withKitRegistry(options.registry ?? {});\n\n  const doc = createSceneState<TData, TLayer, TPose>(registry, layers, () => arrivals.layoutDeclared());\n  const { state, locks, reads } = doc;\n  const notifier = createNotifier();\n  const mode = createEditMode();\n  const writePose = (id: string, pose: unknown): void => { scene.setPose(asNodeId(id), pose as TPose); };\n\n  const layoutFrame = resolveLayoutFrame(options.layoutFrame);\n  const arrivals = createArrivalWindow<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    layoutPass: (arrived, touched, departed) =>\n      runLayoutPass(scene, reads.layoutOf, arrived, touched, layoutFrame, departed),\n    recordsBareEdits: () => !mode.open(),\n    writePose,\n  });\n\n  const generateId = options.generateId ?? defaultGenerateId;\n  const selection = createSceneSelection(locks.reachable);\n  // A selection change is a scene change to every subscriber.\n  selection.subscribe(notifier.notify);\n\n  /** Ephemeral per-node overrides. Deliberately not part of `state`: not\n   *  document content, never reaches `toJSON`, and never touches history. */\n  const overrides = createPoseOverrides<TPose>((id) => state.nodes.get(id), doc.store.invalidateDependents);\n\n  const recording = createSceneRecording({\n    notifier,\n    mode,\n    stale: doc.stale,\n    lifted: locks.lifted,\n    selection,\n    arrivals,\n    writePose,\n    config: options,\n  });\n\n  const edits = createSceneEdits<TData, TLayer, TPose>({\n    state,\n    store: doc.store,\n    locks,\n    layers: doc.layers,\n    invalidateOrder: doc.order.invalidate,\n    fnFields: doc.fnFields,\n    ops: recording.ops,\n    recorder: recording.recorder,\n    arrivals,\n    layoutFrame,\n    generateId,\n    narrowSelection: selection.narrow,\n    clearOverride: overrides.clear,\n  });\n  for (const [kind, handler] of Object.entries(options.ops ?? {})) recording.ops.register(kind, handler);\n\n  const scene: Scene<TData, TLayer, TPose> = {\n    get nodes() { return state.nodes; },\n    get roots() { return state.roots; },\n    get layers() { return state.layers; },\n    registry,\n\n    ...reads,\n\n    mintId: generateId,\n    composition: options.composition ?? (IDENTITY_POSE_COMPOSITION as PoseComposition<TPose>),\n\n    ...edits.methods,\n    ...recording.methods,\n\n    unlocked: (fn) => locks.lifted(fn),\n\n    setArrivalHandler: arrivals.setHandler,\n    onReflow: arrivals.onReflow,\n\n    overrides,\n\n    getSelection: selection.get,\n    setSelection: (ids) => selection.set([...ids]),\n\n    loadState(json) {\n      // Validate + map up front (throws before we touch live state on a bad\n      // version or unknown registry key).\n      const specs = specsFromSerialized(json, registry);\n      if (mode.open()) {\n        throw new Error('Scene: cannot loadState inside another edit — it replaces the state that edit would revert to');\n      }\n      // Ephemeral, and every id is a new node after this.\n      overrides.clearAll();\n      doc.reset(json.systemLayers.map(layerFromSerialized));\n      recording.clearHistory();\n      edits.construct(specs);\n      selection.replace(locks.reachable(selection.get().filter((id) => state.nodes.has(id))));\n      notifier.notify();\n    },\n\n    subscribe: notifier.subscribe,\n    getVersion: notifier.version,\n  };\n\n  const initial = initialNodes(registry);\n  if (initial) {\n    edits.construct(initial);\n    notifier.notify();\n  }\n\n  return scene;\n}\n\n/** Reconstruct a Scene from a JSON snapshot produced by `scene.toJSON()`.\n *  Function fields (e.g., `clipFromPose`) are resolved by string key via the\n *  registry passed in `options`. Throws on unknown version, unknown registry\n *  keys, or invalid scene shape (cross-layer subtrees, unknown layer ids).\n *  The scene starts with empty history. */\nexport function sceneFromJSON<TData, TLayer extends string, TPose>(\n  json: SerializedScene<TData, TLayer, TPose>,\n  options: {\n    registry?: SceneRegistry<TPose, TData, TLayer>;\n    historyLimit?: number;\n    coalesceWindowMs?: number;\n    generateId?: () => NodeId;\n    ops?: Readonly<Record<string, RegisteredOp<unknown>>>;\n    composition?: UseSceneOptions<TData, TLayer, TPose>['composition'];\n    layoutFrame?: UseSceneOptions<TData, TLayer, TPose>['layoutFrame'];\n  } = {},\n): Scene<TData, TLayer, TPose> {\n  return buildScene(\n    options,\n    json.systemLayers.map(layerFromSerialized),\n    (registry) => specsFromSerialized(json, registry),\n  );\n}\n"],"mappings":"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"}

package/dist/core/scene/sceneEdits.js

@@ -0,0 +1,58 @@
+import { createFieldEdits as e } from "./fieldEdits.js";
+import { registerKitOps as t } from "./kitOps.js";
+import { createLayerEdits as n } from "./layerStack.js";
+import { createTreeEdits as r } from "./treeEdits.js";
+//#region src/core/scene/sceneEdits.ts
+function i(i) {
+	let { state: a, store: o, locks: s, layers: c, fnFields: l, recorder: u, arrivals: d } = i, { layoutRefs: f } = t({
+		state: a,
+		register: i.ops.register,
+		store: o,
+		requireLayerIndex: c.requireLayerIndex,
+		rebuildLayerIndex: c.rebuildLayerIndex,
+		invalidateOrder: i.invalidateOrder,
+		fnFields: l,
+		narrowSelection: i.narrowSelection,
+		clearOverride: i.clearOverride
+	}), { construct: p, ...m } = r({
+		nodes: a.nodes,
+		generateId: i.generateId,
+		store: o,
+		locks: s,
+		layers: c,
+		fnFields: l,
+		runOp: i.ops.run,
+		recorder: u,
+		arrivals: d
+	}), h = e({
+		store: o,
+		locks: s,
+		layers: c,
+		recorder: u,
+		arrivals: d,
+		layoutFrame: i.layoutFrame,
+		layoutField: l.find((e) => e.spec.field === "layout"),
+		layoutRefs: f
+	}), g = n({
+		layers: a.layers,
+		layerIndex: a.layerIndex,
+		nodes: a.nodes,
+		requireLayerIndex: c.requireLayerIndex,
+		record: u.record,
+		lifted: s.lifted,
+		batch: u.batch,
+		removeMany: m.removeMany
+	});
+	return {
+		construct: p,
+		methods: {
+			...m,
+			...h,
+			...g
+		}
+	};
+}
+//#endregion
+export { i as createSceneEdits };
+
+//# sourceMappingURL=sceneEdits.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneEdits.js","names":["createSceneEdits","env","registerKitOps","layers","treeEdits","createTreeEdits","state","fieldEdits","createFieldEdits","fnFields","f","layerEdits","createLayerEdits","recorder","locks"],"sources":["../../../src/core/scene/sceneEdits.ts"],"sourcesContent":["/**\n * The scene's edits to its document — tree, node fields, and layers — with\n * the kit ops they record.\n */\nimport type { ArrivalWindow } from './arrivalWindow';\nimport { createFieldEdits, type FieldEdits } from './fieldEdits';\nimport { registerKitOps } from './kitOps';\nimport { createLayerEdits, type LayerEdits, type createLayerStack } from './layerStack';\nimport type { ResolvedLayoutFrame } from './layoutPass';\nimport type { LockGuard } from './lockGuard';\nimport type { NodeFnField } from './nodeFnFields';\nimport type { createNodeStore } from './nodeStore';\nimport type { OpTable } from './opTable';\nimport type { Recorder } from './recorder';\nimport { createTreeEdits, type TreeEdits } from './treeEdits';\nimport type { LayerRecord, Node, NodeId } from './types';\n\nexport interface SceneEditsEnv<TData, TLayer extends string, TPose> {\n  state: {\n    nodes: Map<NodeId, Node<TData, TLayer, TPose>>;\n    layers: LayerRecord<TLayer>[];\n    layerIndex: Map<TLayer, number>;\n  };\n  store: ReturnType<typeof createNodeStore<TData, TLayer, TPose>>;\n  locks: Pick<LockGuard<TLayer>, 'refuse' | 'refuseLayer' | 'lifted'>;\n  layers: Pick<\n    ReturnType<typeof createLayerStack<TLayer>>,\n    'requireLayerIndex' | 'rebuildLayerIndex' | 'assertSubtreeLayer'\n  >;\n  invalidateOrder(): void;\n  fnFields: readonly NodeFnField[];\n  ops: Pick<OpTable, 'register' | 'run'>;\n  recorder: Pick<Recorder, 'record' | 'edit' | 'batch'>;\n  arrivals: Pick<ArrivalWindow<TPose>, 'noteArrival' | 'noteDeparture' | 'noteChange' | 'layoutDeclared'>;\n  layoutFrame: ResolvedLayoutFrame<TPose>;\n  generateId(): NodeId;\n  narrowSelection(gone?: ReadonlySet<NodeId>): void;\n  clearOverride(id: NodeId): void;\n}\n\nexport interface SceneEdits<TData, TLayer extends string, TPose> {\n  construct: TreeEdits<TData, TLayer, TPose>['construct'];\n  methods: Omit<TreeEdits<TData, TLayer, TPose>, 'construct'>\n    & FieldEdits<TData, TLayer, TPose>\n    & LayerEdits<TData, TLayer, TPose>;\n}\n\nexport function createSceneEdits<TData, TLayer extends string, TPose>(\n  env: SceneEditsEnv<TData, TLayer, TPose>,\n): SceneEdits<TData, TLayer, TPose> {\n  const { state, store, locks, layers, fnFields, recorder, arrivals } = env;\n\n  const { layoutRefs } = registerKitOps<TData, TLayer, TPose>({\n    state,\n    register: env.ops.register,\n    store,\n    requireLayerIndex: layers.requireLayerIndex,\n    rebuildLayerIndex: layers.rebuildLayerIndex,\n    invalidateOrder: env.invalidateOrder,\n    fnFields,\n    narrowSelection: env.narrowSelection,\n    clearOverride: env.clearOverride,\n  });\n\n  const { construct, ...treeEdits } = createTreeEdits<TData, TLayer, TPose>({\n    nodes: state.nodes,\n    generateId: env.generateId,\n    store,\n    locks,\n    layers,\n    fnFields,\n    runOp: env.ops.run,\n    recorder,\n    arrivals,\n  });\n\n  const fieldEdits = createFieldEdits<TData, TLayer, TPose>({\n    store,\n    locks,\n    layers,\n    recorder,\n    arrivals,\n    layoutFrame: env.layoutFrame,\n    layoutField: fnFields.find((f) => f.spec.field === 'layout')!,\n    layoutRefs,\n  });\n\n  const layerEdits = createLayerEdits<TData, TLayer, TPose>({\n    layers: state.layers,\n    layerIndex: state.layerIndex,\n    nodes: state.nodes,\n    requireLayerIndex: layers.requireLayerIndex,\n    record: recorder.record,\n    lifted: locks.lifted,\n    batch: recorder.batch,\n    removeMany: treeEdits.removeMany,\n  });\n\n  return { construct, methods: { ...treeEdits, ...fieldEdits, ...layerEdits } };\n}\n"],"mappings":";;;;;AA+CA,SAAgBA,EACd,GACkC;CAClC,IAAM,EAAE,UAAO,UAAO,UAAO,WAAQ,aAAU,aAAU,gBAAaC,GAEhE,EAAE,kBAAeC,EAAqC;EAC1D;EACA,UAAUD,EAAI,IAAI;EAClB;EACA,mBAAmBE,EAAO;EAC1B,mBAAmBA,EAAO;EAC1B,iBAAiBF,EAAI;EACrB;EACA,iBAAiBA,EAAI;EACrB,eAAeA,EAAI;CACrB,CAAC,GAEK,EAAE,cAAW,GAAGG,MAAcC,EAAsC;EACxE,OAAOC,EAAM;EACb,YAAYL,EAAI;EAChB;EACA;EACA;EACA;EACA,OAAOA,EAAI,IAAI;EACf;EACA;CACF,CAAC,GAEKM,IAAaC,EAAuC;EACxD;EACA;EACA;EACA;EACA;EACA,aAAaP,EAAI;EACjB,aAAaQ,EAAS,MAAM,MAAMC,EAAE,KAAK,UAAU,QAAQ;EAC3D;CACF,CAAC,GAEKC,IAAaC,EAAuC;EACxD,QAAQN,EAAM;EACd,YAAYA,EAAM;EAClB,OAAOA,EAAM;EACb,mBAAmBH,EAAO;EAC1B,QAAQU,EAAS;EACjB,QAAQC,EAAM;EACd,OAAOD,EAAS;EAChB,YAAYT,EAAU;CACxB,CAAC;CAED,OAAO;EAAE;EAAW,SAAS;GAAE,GAAGA;GAAW,GAAGG;GAAY,GAAGI;EAAW;CAAE;AAC9E"}

package/dist/core/scene/sceneMutators.js

@@ -0,0 +1,49 @@
+import { documentPose as e } from "./effectivePose.js";
+import { asNodeId as t } from "./types.js";
+import { fnFieldsOfNode as n } from "./nodeFnFields.js";
+import { statedFields as r } from "./statedFields.js";
+//#region src/core/scene/sceneMutators.ts
+function i(e) {
+	let i = (n) => n === null ? [...e.roots] : [...e.childrenOf(t(n))];
+	return {
+		getNode: (n) => e.get(t(n)),
+		getParent: (n) => e.get(t(n))?.parent ?? null,
+		getChildren: i,
+		getRemovalClosure: (n) => [...e.removalClosure(n.map(t))],
+		setPose: (n, r) => e.setPose(t(n), r),
+		setParent: (n, r) => e.move(t(n), r == null ? null : t(r)),
+		setChildOrder: (n, r) => {
+			e.batch("Reorder", () => {
+				for (let a = 0; a < r.length; a++) i(n)[a] !== r[a] && e.reorder(t(r[a]), a);
+			});
+		},
+		setData: (n, r) => e.update(t(n), { data: r }),
+		setLayer: (n, r) => e.setLayer(t(n), r),
+		setLayout: (n, r) => e.setLayout(t(n), r),
+		removeNode: (n) => e.remove(t(n)),
+		insertNode: (t, i) => {
+			e.add({
+				kind: t.kind,
+				layer: t.layer,
+				pose: t.pose,
+				data: t.data,
+				id: t.id,
+				...i === void 0 ? {} : { index: i },
+				...t.parent == null ? {} : { parent: t.parent },
+				...t.dependsOn === void 0 ? {} : { dependsOn: t.dependsOn },
+				...r(t),
+				...n(t)
+			});
+		}
+	};
+}
+function a(n) {
+	return {
+		getPose: (r) => e(n, n.get(t(r))),
+		getNodes: () => [...n.renderOrderNodes()]
+	};
+}
+//#endregion
+export { a as documentReads, i as sceneMutators };
+
+//# sourceMappingURL=sceneMutators.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneMutators.js","names":["sceneMutators","getChildren","parentId","scene","asNodeId","id","ids","pose","i","layer","layout","node","index","statedFields","fnFieldsOfNode","documentReads","documentPose"],"sources":["../../../src/core/scene/sceneMutators.ts"],"sourcesContent":["/**\n * What every scene-backed adapter shares: the writes an op applies through,\n * and the structural reads those ops need. `sceneToAdapter`,\n * `defaultCommitAdapter`, and `moveGestureAdapter` all build on it.\n *\n * It leaves out the pose and node-list reads, where the adapters differ on\n * purpose. The canvas adapter answers with what is shown: the effective pose,\n * visible layers only. An adapter ops commit through answers with what the\n * document holds, which is {@link documentReads}.\n */\nimport type { LayoutStrategy } from '../../layout/types';\nimport { documentPose } from './effectivePose';\nimport { fnFieldsOfNode } from './nodeFnFields';\nimport { statedFields } from './statedFields';\nimport { asNodeId, type Node, type Scene } from './types';\n\nexport interface SceneMutators<TData, TLayer extends string, TPose> {\n  getNode(id: string): Node<TData, TLayer, TPose> | undefined;\n  getParent(id: string): string | null;\n  /** Ordered children of `parentId`; `null` names the root siblings. */\n  getChildren(parentId: string | null): string[];\n  /** Every id removing `ids` takes: their subtrees and their dependents. */\n  getRemovalClosure(ids: readonly string[]): string[];\n  setPose(id: string, pose: TPose): void;\n  setParent(id: string, parentId: string | null): void;\n  /** One undo step when called bare; inside a batch it joins that batch. */\n  setChildOrder(parentId: string | null, ids: string[]): void;\n  setData(id: string, data: TData): void;\n  setLayer(id: string, layer: TLayer): void;\n  setLayout(id: string, layout: LayoutStrategy<TPose> | string | null): void;\n  removeNode(id: string): void;\n  /** Re-add `node` as it was, at sibling `index` when one is given. */\n  insertNode(node: Node<TData, TLayer, TPose>, index?: number): void;\n}\n\nexport function sceneMutators<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n): SceneMutators<TData, TLayer, TPose> {\n  const getChildren = (parentId: string | null): string[] =>\n    (parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))]);\n  return {\n    getNode: (id) => scene.get(asNodeId(id)),\n    getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,\n    getChildren,\n    getRemovalClosure: (ids) => [...scene.removalClosure(ids.map(asNodeId))],\n    setPose: (id, pose) => scene.setPose(asNodeId(id), pose),\n    setParent: (id, parentId) => scene.move(asNodeId(id), parentId == null ? null : asNodeId(parentId)),\n    setChildOrder: (parentId, ids) => {\n      scene.batch('Reorder', () => {\n        for (let i = 0; i < ids.length; i++) {\n          // Re-read each time: a reorder shifts later ids, sometimes into place.\n          if (getChildren(parentId)[i] === ids[i]) continue;\n          scene.reorder(asNodeId(ids[i]), i);\n        }\n      });\n    },\n    setData: (id, data) => scene.update(asNodeId(id), { data }),\n    setLayer: (id, layer) => scene.setLayer(asNodeId(id), layer),\n    setLayout: (id, layout) => scene.setLayout(asNodeId(id), layout),\n    removeNode: (id) => scene.remove(asNodeId(id)),\n    insertNode: (node, index) => {\n      scene.add({\n        kind: node.kind,\n        layer: node.layer,\n        pose: node.pose,\n        data: node.data,\n        id: node.id,\n        ...(index !== undefined ? { index } : {}),\n        ...(node.parent != null ? { parent: node.parent } : {}),\n        // Derivation travels with the node, or undo of a delete brings an\n        // edge back as a static path that never follows its endpoints again.\n        ...(node.dependsOn !== undefined ? { dependsOn: node.dependsOn } : {}),\n        ...statedFields(node),\n        ...fnFieldsOfNode(node),\n      });\n    },\n  };\n}\n\n/** The pose and node-list reads of an adapter ops commit through: the document,\n *  whatever a gesture is showing and whichever layers are hidden. */\nexport function documentReads<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n): { getPose(id: string): TPose; getNodes(): Node<TData, TLayer, TPose>[] } {\n  return {\n    getPose: (id) => documentPose(scene, scene.get(asNodeId(id))!),\n    getNodes: () => [...scene.renderOrderNodes()],\n  };\n}\n"],"mappings":";;;;;AAmCA,SAAgBA,EACd,GACqC;CACrC,IAAMC,KAAe,MAClBC,MAAa,OAAO,CAAC,GAAGC,EAAM,KAAK,IAAI,CAAC,GAAGA,EAAM,WAAWC,EAASF,CAAQ,CAAC,CAAC;CAClF,OAAO;EACL,UAAU,MAAOC,EAAM,IAAIC,EAASC,CAAE,CAAC;EACvC,YAAY,MAAOF,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAC,EAAE,UAAU;EACtD;EACA,oBAAoB,MAAQ,CAAC,GAAGF,EAAM,eAAeG,EAAI,IAAIF,CAAQ,CAAC,CAAC;EACvE,UAAU,GAAI,MAASD,EAAM,QAAQC,EAASC,CAAE,GAAGE,CAAI;EACvD,YAAY,GAAI,MAAaJ,EAAM,KAAKC,EAASC,CAAE,GAAGH,KAAY,OAAO,OAAOE,EAASF,CAAQ,CAAC;EAClG,gBAAgB,GAAU,MAAQ;GAChC,EAAM,MAAM,iBAAiB;IAC3B,KAAK,IAAIM,IAAI,GAAGA,IAAIF,EAAI,QAAQ,KAE9B,AAAIL,EAAYC,CAAQ,CAAC,CAACM,OAAOF,EAAIE,MACrCL,EAAM,QAAQC,EAASE,EAAIE,EAAE,GAAGA,CAAC;GAErC,CAAC;EACH;EACA,UAAU,GAAI,MAASL,EAAM,OAAOC,EAASC,CAAE,GAAG,EAAE,QAAK,CAAC;EAC1D,WAAW,GAAI,MAAUF,EAAM,SAASC,EAASC,CAAE,GAAGI,CAAK;EAC3D,YAAY,GAAI,MAAWN,EAAM,UAAUC,EAASC,CAAE,GAAGK,CAAM;EAC/D,aAAa,MAAOP,EAAM,OAAOC,EAASC,CAAE,CAAC;EAC7C,aAAa,GAAM,MAAU;GAC3B,EAAM,IAAI;IACR,MAAMM,EAAK;IACX,OAAOA,EAAK;IACZ,MAAMA,EAAK;IACX,MAAMA,EAAK;IACX,IAAIA,EAAK;IACT,GAAIC,MAAU,KAAA,IAAwB,CAAC,IAAb,EAAE,SAAM;IAClC,GAAID,EAAK,UAAU,OAAiC,CAAC,IAA3B,EAAE,QAAQA,EAAK,OAAO;IAGhD,GAAIA,EAAK,cAAc,KAAA,IAA4C,CAAC,IAAjC,EAAE,WAAWA,EAAK,UAAU;IAC/D,GAAGE,EAAaF,CAAI;IACpB,GAAGG,EAAeH,CAAI;GACxB,CAAC;EACH;CACF;AACF;AAIA,SAAgBI,EACd,GAC0E;CAC1E,OAAO;EACL,UAAU,MAAOC,EAAab,GAAOA,EAAM,IAAIC,EAASC,CAAE,CAAC,CAAE;EAC7D,gBAAgB,CAAC,GAAGF,EAAM,iBAAiB,CAAC;CAC9C;AACF"}

package/dist/core/scene/scenePoseAdapter.js

@@ -0,0 +1,16 @@
+import { definesFrame as e, documentPose as t } from "./effectivePose.js";
+//#region src/core/scene/scenePoseAdapter.ts
+function n(n) {
+	return {
+		getPose: (e) => t(n, n.get(e)),
+		getParent: (e) => n.get(e)?.parent ?? null,
+		definesFrame: (t) => {
+			let r = n.get(t);
+			return r === void 0 || e(r);
+		}
+	};
+}
+//#endregion
+export { n as scenePoseAdapter };
+
+//# sourceMappingURL=scenePoseAdapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scenePoseAdapter.js","names":["scenePoseAdapter","documentPose","scene","id","node","definesFrame"],"sources":["../../../src/core/scene/scenePoseAdapter.ts"],"sourcesContent":["import { definesFrame, documentPose } from 'core/scene/effectivePose';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { PoseAdapter } from './composePose';\n\n/** Build a `PoseAdapter` over a `Scene` for `composePose` helpers.\n *  `getParent` returns the live parent at call time so mid-batch\n *  parent updates compose correctly. */\nexport function scenePoseAdapter(\n  scene: Scene<unknown, string, unknown>,\n): PoseAdapter<unknown> {\n  return {\n    getPose: (id) => documentPose(scene, scene.get(id as NodeId)!),\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n}\n"],"mappings":";;AAOA,SAAgBA,EACd,GACsB;CACtB,OAAO;EACL,UAAU,MAAOC,EAAaC,GAAOA,EAAM,IAAIC,CAAY,CAAE;EAC7D,YAAY,MAAOD,EAAM,IAAIC,CAAY,CAAC,EAAE,UAAU;EACtD,eAAe,MAAO;GACpB,IAAMC,IAAOF,EAAM,IAAIC,CAAY;GACnC,OAAOC,MAAS,KAAA,KAAaC,EAAaD,CAAI;EAChD;CACF;AACF"}

package/dist/core/scene/sceneRecording.js

@@ -0,0 +1,91 @@
+import { createHistory as e } from "../ops/createHistory.js";
+import { createAppliedLog as t } from "./appliedLog.js";
+import { createSceneHistory as n } from "./historyFacade.js";
+import { createOpTable as r } from "./opTable.js";
+import { createOuterOps as i } from "./outerOps.js";
+import { createRecorder as a } from "./recorder.js";
+//#region src/core/scene/sceneRecording.ts
+function o(o) {
+	let { notifier: s, mode: c, stale: l, lifted: u, selection: d, arrivals: f, config: p } = o, { notify: m } = s, h = r({
+		driven: c.open,
+		replayAlone: (e) => {
+			w(e), m();
+		},
+		skips: l.skips,
+		applied: (e, t, n) => {
+			c.records() || b(e, t, n);
+		}
+	}), g = i({
+		own: (e, t) => h.handlers.has(e) ? h.op(e, t) : null,
+		recorder: () => x,
+		driving: (e) => s.deferred(() => c.during("engine", () => y(e, () => !0))),
+		getActiveJournal: p.getActiveJournal ?? null
+	}), _ = e(void 0, {
+		selection: {
+			get: d.get,
+			set: (e) => d.set(e)
+		},
+		...p.coalesceWindowMs === void 0 ? {} : { coalesceWindowMs: p.coalesceWindowMs },
+		...p.historyLimit === void 0 ? {} : { historyLimit: p.historyLimit },
+		rebuildOp: g.rebuild
+	}), v = t({
+		registered: h.handlers,
+		lifted: u,
+		getSelection: d.get,
+		setSelection: d.replace,
+		notify: m
+	}), { atomically: y, logApplied: b } = v, x = a({
+		notifier: s,
+		mode: c,
+		engine: _,
+		runOp: h.run,
+		makeOp: h.op,
+		log: v,
+		arrivals: f,
+		selection: d.get,
+		writePose: o.writePose
+	}), { record: S, engineDriven: C } = x;
+	function w(e) {
+		y(() => u(() => l.during(() => C(e))), () => !0);
+	}
+	function T(e) {
+		if (c.untracked()) throw Error(`Scene: cannot ${e} inside untracked() — it records`);
+	}
+	let { history: E, methods: D } = n({
+		engine: _,
+		applying: (e) => y(() => C(e), () => !0),
+		causing: g.causing,
+		replay: w,
+		notify: m,
+		refuseUntracked: T,
+		runArrivalEdit: f.runEdit,
+		activeJournal: g.activeJournal
+	});
+	return {
+		ops: h,
+		recorder: x,
+		clearHistory: () => _.clear(),
+		methods: {
+			registerOp(e, t) {
+				if (e.startsWith("kit:")) throw Error(`Scene: op kind "${e}" is reserved (kit:* prefix)`);
+				h.register(e, t);
+			},
+			recordOp(e) {
+				S(e.kind, e.payload, e.kind);
+			},
+			applyBatch(e, t, n) {
+				return T("applyBatch"), f.runEdit(e, (e) => g.apply(_, e, t, n));
+			},
+			history: E,
+			...D,
+			batch: x.batch,
+			untracked: x.untracked,
+			setActiveJournalAccessor: g.setActiveJournalAccessor,
+			setHistoryAdapter: g.setHistoryAdapter
+		}
+	};
+}
+//#endregion
+export { o as createSceneRecording };
+
+//# sourceMappingURL=sceneRecording.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneRecording.js","names":["createSceneRecording","env","notifier","ops","createOpTable","mode","replay","step","notify","stale","logApplied","kind","payload","reverted","outer","createOuterOps","name","args","recorder","atomically","config","engine","createHistory","selection","ids","log","createAppliedLog","createRecorder","lifted","engineDriven","refuseUntracked","verb","createSceneHistory","arrivals","handler","op","batch","all","label","adapter","methods"],"sources":["../../../src/core/scene/sceneRecording.ts"],"sourcesContent":["/**\n * How a scene's edits reach its undo stack: the op table, the log that takes\n * back an edit refused partway, the engine, and the recorder between them.\n */\nimport type { Journal } from '@weasel-js/history';\nimport { createHistory } from 'core/ops/createHistory';\nimport { createAppliedLog } from './appliedLog';\nimport type { ArrivalWindow } from './arrivalWindow';\nimport type { EditMode } from './editMode';\nimport { createSceneHistory, type SceneHistoryMethods } from './historyFacade';\nimport type { Notifier } from './notifier';\nimport { createOpTable, type OpTable } from './opTable';\nimport { createOuterOps } from './outerOps';\nimport { createRecorder, type Recorder, type RecorderEnv } from './recorder';\nimport type { SceneSelection } from './sceneSelection';\nimport type { StaleReplay } from './staleReplay';\nimport type { NodeId, RegisteredOp, Scene } from './types';\n\nexport interface SceneRecordingEnv {\n  notifier: Notifier;\n  mode: EditMode;\n  stale: StaleReplay;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  selection: Pick<SceneSelection, 'get' | 'set' | 'replace'>;\n  arrivals: RecorderEnv['arrivals'] & Pick<ArrivalWindow<unknown>, 'runEdit'>;\n  writePose(id: string, pose: unknown): void;\n  config: {\n    getActiveJournal?: (() => Journal | null) | undefined;\n    coalesceWindowMs?: number | undefined;\n    historyLimit?: number | undefined;\n  };\n}\n\nexport interface SceneRecording {\n  ops: Pick<OpTable, 'register' | 'run'>;\n  recorder: Recorder;\n  clearHistory(): void;\n  methods: SceneHistoryMethods & Pick<\n    Scene<unknown, string, unknown>,\n    | 'registerOp' | 'recordOp' | 'applyBatch' | 'history' | 'batch' | 'untracked'\n    | 'setActiveJournalAccessor' | 'setHistoryAdapter'\n  >;\n}\n\nexport function createSceneRecording(env: SceneRecordingEnv): SceneRecording {\n  const { notifier, mode, stale, lifted, selection, arrivals, config } = env;\n  const { notify } = notifier;\n\n  const ops = createOpTable({\n    driven: mode.open,\n    replayAlone: (step) => { replay(step); notify(); },\n    skips: stale.skips,\n    // Only a replay is logged: a first apply is recorded by the entry it\n    // creates, and reverting it would leave that entry describing nothing.\n    applied: (kind, payload, reverted) => { if (!mode.records()) logApplied(kind, payload, reverted); },\n  });\n\n  const outer = createOuterOps({\n    own: (name, args) => (ops.handlers.has(name) ? ops.op(name, args) : null),\n    recorder: () => recorder,\n    // Deferred rather than muted, so a throwing op cannot strand subscribers\n    // after earlier ops in the batch already mutated state.\n    driving: (step) => notifier.deferred(() => mode.during('engine', () => atomically(step, () => true))),\n    getActiveJournal: config.getActiveJournal ?? null,\n  });\n\n  // The scene's undo/redo engine. Its recorded ops close over their payloads,\n  // so the engine's adapter argument is unused.\n  const engine = createHistory(undefined, {\n    selection: { get: selection.get, set: (ids) => selection.set(ids as readonly NodeId[]) },\n    ...(config.coalesceWindowMs !== undefined ? { coalesceWindowMs: config.coalesceWindowMs } : {}),\n    ...(config.historyLimit !== undefined ? { historyLimit: config.historyLimit } : {}),\n    rebuildOp: outer.rebuild,\n  });\n\n  const log = createAppliedLog({\n    registered: ops.handlers,\n    lifted,\n    getSelection: selection.get,\n    setSelection: selection.replace,\n    notify,\n  });\n  const { atomically, logApplied } = log;\n\n  const recorder = createRecorder({\n    notifier,\n    mode,\n    engine,\n    runOp: ops.run,\n    makeOp: ops.op,\n    log,\n    arrivals,\n    selection: selection.get,\n    writePose: env.writePose,\n  });\n  const { record, engineDriven } = recorder;\n\n  /** Run an engine step that replays recorded ops — undo, redo, goto, a\n   *  journal stepping. The engine inverts whole ops when one throws; this\n   *  also reverts the scene writes of the op that threw partway. */\n  function replay(step: () => void): void {\n    atomically(() => lifted(() => stale.during(() => engineDriven(step))), () => true);\n  }\n\n  function refuseUntracked(verb: string): void {\n    if (mode.untracked()) throw new Error(`Scene: cannot ${verb} inside untracked() — it records`);\n  }\n\n  const { history, methods } = createSceneHistory({\n    engine,\n    applying: (step) => atomically(() => engineDriven(step), () => true),\n    causing: outer.causing,\n    replay,\n    notify,\n    refuseUntracked,\n    runArrivalEdit: arrivals.runEdit,\n    activeJournal: outer.activeJournal,\n  });\n\n  return {\n    ops,\n    recorder,\n    clearHistory: () => engine.clear(),\n    methods: {\n      registerOp(kind, handler) {\n        if (kind.startsWith('kit:')) {\n          throw new Error(`Scene: op kind \"${kind}\" is reserved (kit:* prefix)`);\n        }\n        ops.register(kind, handler as RegisteredOp<unknown>);\n      },\n      recordOp(op) {\n        record(op.kind, op.payload, op.kind);\n      },\n      applyBatch(batch, label, adapter) {\n        refuseUntracked('applyBatch');\n        return arrivals.runEdit(batch, (all) => outer.apply(engine, all, label, adapter));\n      },\n      history,\n      ...methods,\n      batch: recorder.batch,\n      untracked: recorder.untracked,\n      setActiveJournalAccessor: outer.setActiveJournalAccessor,\n      setHistoryAdapter: outer.setHistoryAdapter,\n    },\n  };\n}\n"],"mappings":";;;;;;;AA6CA,SAAgBA,EAAqB,GAAwC;CAC3E,IAAM,EAAE,aAAU,SAAM,UAAO,WAAQ,cAAW,aAAU,cAAWC,GACjE,EAAE,cAAWC,GAEbC,IAAMC,EAAc;EACxB,QAAQC,EAAK;EACb,cAAc,MAAS;GAAgB,AAAdC,EAAOC,CAAI,GAAGC,EAAO;EAAG;EACjD,OAAOC,EAAM;EAGb,UAAU,GAAM,GAAS,MAAa;GAAE,AAAKJ,EAAK,QAAQ,KAAGK,EAAWC,GAAMC,GAASC,CAAQ;EAAG;CACpG,CAAC,GAEKC,IAAQC,EAAe;EAC3B,MAAM,GAAM,MAAUZ,EAAI,SAAS,IAAIa,CAAI,IAAIb,EAAI,GAAGa,GAAMC,CAAI,IAAI;EACpE,gBAAgBC;EAGhB,UAAU,MAAShB,EAAS,eAAeG,EAAK,OAAO,gBAAgBc,EAAWZ,SAAY,EAAI,CAAC,CAAC;EACpG,kBAAkBa,EAAO,oBAAoB;CAC/C,CAAC,GAIKC,IAASC,EAAc,KAAA,GAAW;EACtC,WAAW;GAAE,KAAKC,EAAU;GAAK,MAAM,MAAQA,EAAU,IAAIC,CAAwB;EAAE;EACvF,GAAIJ,EAAO,qBAAqB,KAAA,IAA4D,CAAC,IAAjD,EAAE,kBAAkBA,EAAO,iBAAiB;EACxF,GAAIA,EAAO,iBAAiB,KAAA,IAAoD,CAAC,IAAzC,EAAE,cAAcA,EAAO,aAAa;EAC5E,WAAWN,EAAM;CACnB,CAAC,GAEKW,IAAMC,EAAiB;EAC3B,YAAYvB,EAAI;EAChB;EACA,cAAcoB,EAAU;EACxB,cAAcA,EAAU;EACxB;CACF,CAAC,GACK,EAAE,eAAY,kBAAeE,GAE7BP,IAAWS,EAAe;EAC9B;EACA;EACA;EACA,OAAOxB,EAAI;EACX,QAAQA,EAAI;EACZ;EACA;EACA,WAAWoB,EAAU;EACrB,WAAWtB,EAAI;CACjB,CAAC,GACK,EAAE,WAAQ,oBAAiBiB;CAKjC,SAASZ,EAAO,GAAwB;EACtC,QAAiBsB,QAAanB,EAAM,aAAaoB,EAAatB,CAAI,CAAC,CAAC,SAAS,EAAI;CACnF;CAEA,SAASuB,EAAgB,GAAoB;EAC3C,IAAIzB,EAAK,UAAU,GAAG,MAAU,MAAM,iBAAiB0B,EAAK,iCAAiC;CAC/F;CAEA,IAAM,EAAE,YAAS,eAAYC,EAAmB;EAC9C;EACA,WAAW,MAASb,QAAiBU,EAAatB,CAAI,SAAS,EAAI;EACnE,SAASO,EAAM;EACf;EACA;EACA;EACA,gBAAgBmB,EAAS;EACzB,eAAenB,EAAM;CACvB,CAAC;CAED,OAAO;EACL;EACA;EACA,oBAAoBO,EAAO,MAAM;EACjC,SAAS;GACP,WAAW,GAAM,GAAS;IACxB,IAAIV,EAAK,WAAW,MAAM,GACxB,MAAU,MAAM,mBAAmBA,EAAK,6BAA6B;IAEvE,EAAI,SAASA,GAAMuB,CAAgC;GACrD;GACA,SAAS,GAAI;IACX,EAAOC,EAAG,MAAMA,EAAG,SAASA,EAAG,IAAI;GACrC;GACA,WAAW,GAAO,GAAO,GAAS;IAEhC,OADAL,EAAgB,YAAY,GACrBG,EAAS,QAAQG,IAAQ,MAAQtB,EAAM,MAAMO,GAAQgB,GAAKC,GAAOC,CAAO,CAAC;GAClF;GACA;GACA,GAAGC;GACH,OAAOtB,EAAS;GAChB,WAAWA,EAAS;GACpB,0BAA0BJ,EAAM;GAChC,mBAAmBA,EAAM;EAC3B;CACF;AACF"}

package/dist/core/scene/sceneSelection.js

@@ -0,0 +1,28 @@
+import { createEmitter as e } from "@weasel-js/registry";
+//#region src/core/scene/sceneSelection.ts
+function t(t) {
+	let n = [], r = e();
+	return {
+		get: () => n,
+		set(e) {
+			n = t(e), r.emit();
+		},
+		narrow(e) {
+			n = t(e !== void 0 && n.some((t) => e.has(t)) ? n.filter((t) => !e.has(t)) : n);
+		},
+		replace(e) {
+			n = e;
+		},
+		subscribe: r.subscribe
+	};
+}
+function n(e) {
+	return {
+		get: () => e.getSelection(),
+		set: (t) => e.setSelection(t)
+	};
+}
+//#endregion
+export { t as createSceneSelection, n as sceneSelectionStore };
+
+//# sourceMappingURL=sceneSelection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneSelection.js","names":["createSceneSelection","ids","changed","createEmitter","reachable","next","gone","id","sceneSelectionStore","scene"],"sources":["../../../src/core/scene/sceneSelection.ts"],"sourcesContent":["/**\n * The scene's selection: the transient set of active ids. Not document\n * content, so it never reaches `toJSON`; it does ride on history entries.\n */\nimport type { HistorySelection } from '@weasel-js/history';\nimport { createEmitter } from '@weasel-js/registry';\nimport type { NodeId } from './types';\n\nexport interface SceneSelection {\n  get(): readonly NodeId[];\n  /** Select the ids of `ids` that are in reach, and tell subscribers. */\n  set(ids: readonly NodeId[]): void;\n  /** Drop the ids in `gone`, and any a lock has put out of reach. Tells no\n   *  one: the edit that took them is what subscribers hear about. */\n  narrow(gone?: ReadonlySet<NodeId>): void;\n  /** Put a selection in place exactly as given, telling no one: for a caller\n   *  returning what it read earlier, or one that has already filtered. */\n  replace(ids: readonly NodeId[]): void;\n  subscribe(listener: () => void): () => void;\n}\n\nexport function createSceneSelection(\n  /** `ids` less those out of reach; the same array when none is. */\n  reachable: (ids: readonly NodeId[]) => readonly NodeId[],\n): SceneSelection {\n  let ids: readonly NodeId[] = [];\n  const changed = createEmitter();\n\n  return {\n    get: () => ids,\n    set(next) {\n      ids = reachable(next);\n      changed.emit();\n    },\n    narrow(gone) {\n      // A new array only when one is dropped: readers compare the selection by identity.\n      const kept = gone !== undefined && ids.some((id) => gone.has(id)) ? ids.filter((id) => !gone.has(id)) : ids;\n      ids = reachable(kept);\n    },\n    replace(next) {\n      ids = next;\n    },\n    subscribe: changed.subscribe,\n  };\n}\n\n/** The scene's selection in the shape `createHistory` wants, for a consumer\n *  building a second History over the same scene (a modality machine, a\n *  journal owner) that should restore selection the way the scene's own\n *  history does. */\nexport function sceneSelectionStore(scene: {\n  getSelection(): readonly NodeId[];\n  setSelection(ids: readonly NodeId[]): void;\n}): HistorySelection {\n  return {\n    get: () => scene.getSelection(),\n    set: (ids) => scene.setSelection(ids as readonly NodeId[]),\n  };\n}\n"],"mappings":";;AAqBA,SAAgBA,EAEd,GACgB;CAChB,IAAIC,IAAyB,CAAC,GACxBC,IAAUC,EAAc;CAE9B,OAAO;EACL,WAAWF;EACX,IAAI,GAAM;GAER,AADA,IAAMG,EAAUC,CAAI,GACpBH,EAAQ,KAAK;EACf;EACA,OAAO,GAAM;GAGX,IAAME,EADOE,MAAS,KAAA,KAAaL,EAAI,MAAM,MAAOK,EAAK,IAAIC,CAAE,CAAC,IAAIN,EAAI,QAAQ,MAAO,CAACK,EAAK,IAAIC,CAAE,CAAC,IAAIN,CACpF;EACtB;EACA,QAAQ,GAAM;GACZ,IAAMI;EACR;EACA,WAAWH,EAAQ;CACrB;AACF;AAMA,SAAgBM,EAAoB,GAGf;CACnB,OAAO;EACL,WAAWC,EAAM,aAAa;EAC9B,MAAM,MAAQA,EAAM,aAAaR,CAAwB;CAC3D;AACF"}

package/dist/core/scene/sceneState.js

@@ -0,0 +1,49 @@
+import { createNodeFnFields as e } from "./nodeFnFields.js";
+import { createLayerStack as t } from "./layerStack.js";
+import { createStaleReplay as n } from "./staleReplay.js";
+import { createLockGuard as r } from "./lockGuard.js";
+import { createNodeStore as i } from "./nodeStore.js";
+import { createRenderOrder as a } from "./renderOrder.js";
+import { serializeScene as o } from "./serialization.js";
+import { createTreeReads as s } from "./treeReads.js";
+//#region src/core/scene/sceneState.ts
+function c(c, l, u) {
+	let d = {
+		nodes: /* @__PURE__ */ new Map(),
+		roots: [],
+		layers: [],
+		layerIndex: /* @__PURE__ */ new Map()
+	}, f = a(d), p = e(c, (e) => {
+		e === "layout" && u();
+	}), m = i(d, f.invalidate, p), h = t(d, f.invalidate);
+	h.reset(l);
+	let g = r(d), _ = {
+		...s(d.nodes),
+		renderOrder: f.ids,
+		renderOrderNodes: f.nodes,
+		nodesOnLayer: f.nodesOnLayer,
+		isLocked: (e) => g.isLocked(e),
+		layoutOf(e) {
+			let t = d.nodes.get(e);
+			return t?.kind === "container" ? t.layout ?? null : null;
+		},
+		toJSON: () => o(d, p)
+	};
+	return {
+		state: d,
+		order: f,
+		locks: g,
+		stale: n(d.nodes),
+		fnFields: p,
+		store: m,
+		layers: h,
+		reads: _,
+		reset(e) {
+			m.dependents.clear(), m.childDerived.clear(), d.nodes.clear(), d.roots.length = 0, h.reset(e);
+		}
+	};
+}
+//#endregion
+export { c as createSceneState };
+
+//# sourceMappingURL=sceneState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sceneState.js","names":["createSceneState","state","order","createRenderOrder","fnFields","createNodeFnFields","registry","field","layoutDeclared","store","createNodeStore","layers","createLayerStack","initialLayers","locks","createLockGuard","reads","createTreeReads","id","node","serializeScene","createStaleReplay","records"],"sources":["../../../src/core/scene/sceneState.ts"],"sourcesContent":["/**\n * A scene's document state — its nodes, roots, and layers — with the modules\n * that read and write it directly.\n */\nimport { createLayerStack } from './layerStack';\nimport { createLockGuard } from './lockGuard';\nimport { createNodeFnFields } from './nodeFnFields';\nimport { createNodeStore } from './nodeStore';\nimport { createRenderOrder } from './renderOrder';\nimport { serializeScene } from './serialization';\nimport { createStaleReplay } from './staleReplay';\nimport { createTreeReads } from './treeReads';\nimport type { LayerRecord, Node, NodeId, Scene, SceneRegistry } from './types';\n\nexport function createSceneState<TData, TLayer extends string, TPose>(\n  registry: SceneRegistry<TPose, TData, TLayer>,\n  initialLayers: readonly LayerRecord<TLayer>[],\n  /** Called when a node is given a layout. */\n  layoutDeclared: () => void,\n) {\n  const state = {\n    nodes: new Map<NodeId, Node<TData, TLayer, TPose>>(),\n    roots: [] as NodeId[],\n    layers: [] as LayerRecord<TLayer>[],\n    layerIndex: new Map<TLayer, number>(),\n  };\n  const order = createRenderOrder(state);\n  /** The registry-keyed function fields, each with its key maps. A function\n   *  cannot travel through a serializable op payload, so an op carries its key. */\n  const fnFields = createNodeFnFields<TPose>(registry, (field) => {\n    if (field === 'layout') layoutDeclared();\n  });\n  const store = createNodeStore(state, order.invalidate, fnFields);\n  const layers = createLayerStack(state, order.invalidate);\n  layers.reset(initialLayers);\n  const locks = createLockGuard(state);\n\n  const reads: Pick<\n    Scene<TData, TLayer, TPose>,\n    | 'get' | 'incarnation' | 'childrenOf' | 'ancestorsOf' | 'renderOrder' | 'renderOrderNodes'\n    | 'nodesOnLayer' | 'isLocked' | 'layoutOf' | 'toJSON'\n  > = {\n    ...createTreeReads(state.nodes),\n    renderOrder: order.ids,\n    renderOrderNodes: order.nodes,\n    nodesOnLayer: order.nodesOnLayer,\n    isLocked: (id) => locks.isLocked(id),\n    layoutOf(id) {\n      const node = state.nodes.get(id);\n      return node?.kind === 'container' ? (node.layout ?? null) : null;\n    },\n    toJSON: () => serializeScene(state, fnFields),\n  };\n\n  return {\n    state,\n    order,\n    locks,\n    stale: createStaleReplay(state.nodes),\n    fnFields,\n    store,\n    layers,\n    reads,\n\n    /** Empty the document and give it `records` as its layers. */\n    reset(records: readonly LayerRecord<TLayer>[]): void {\n      store.dependents.clear();\n      store.childDerived.clear();\n      state.nodes.clear();\n      state.roots.length = 0;\n      layers.reset(records);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;AAcA,SAAgBA,EACd,GACA,GAEA,GACA;CACA,IAAMC,IAAQ;EACZ,uBAAO,IAAI,IAAwC;EACnD,OAAO,CAAC;EACR,QAAQ,CAAC;EACT,4BAAY,IAAI,IAAoB;CACtC,GACMC,IAAQC,EAAkBF,CAAK,GAG/BG,IAAWC,EAA0BC,IAAW,MAAU;EAC9D,AAAIC,MAAU,YAAUC,EAAe;CACzC,CAAC,GACKC,IAAQC,EAAgBT,GAAOC,EAAM,YAAYE,CAAQ,GACzDO,IAASC,EAAiBX,GAAOC,EAAM,UAAU;CACvD,EAAO,MAAMW,CAAa;CAC1B,IAAMC,IAAQC,EAAgBd,CAAK,GAE7Be,IAIF;EACF,GAAGC,EAAgBhB,EAAM,KAAK;EAC9B,aAAaC,EAAM;EACnB,kBAAkBA,EAAM;EACxB,cAAcA,EAAM;EACpB,WAAW,MAAOY,EAAM,SAASI,CAAE;EACnC,SAAS,GAAI;GACX,IAAMC,IAAOlB,EAAM,MAAM,IAAIiB,CAAE;GAC/B,OAAOC,GAAM,SAAS,cAAeA,EAAK,UAAU,OAAQ;EAC9D;EACA,cAAcC,EAAenB,GAAOG,CAAQ;CAC9C;CAEA,OAAO;EACL;EACA;EACA;EACA,OAAOiB,EAAkBpB,EAAM,KAAK;EACpC;EACA;EACA;EACA;EAGA,MAAM,GAA+C;GAKnD,AAJAQ,EAAM,WAAW,MAAM,GACvBA,EAAM,aAAa,MAAM,GACzBR,EAAM,MAAM,MAAM,GAClB,EAAM,MAAM,SAAS,GACrBU,EAAO,MAAMW,CAAO;EACtB;CACF;AACF"}

package/dist/core/scene/serialization.js

@@ -2,6 +2,9 @@ import { NODE_FN_FIELDS as e, fnKeysOf as t } from "./nodeFnFields.js";
 import { treePreorder as n } from "./treeOrder.js";
 //#region src/core/scene/serialization.ts
 function r(e) {
+	return typeof e == "object" && !!e && e.version === 1 && Array.isArray(e.nodes);
+}
+function i(e) {
 	let t = {
 		id: e.id,
 		visible: e.visible ?? !0,
@@ -17,7 +20,7 @@ function r(e) {
 		kind: "system"
 	};
 }
-function i(e, r) {
+function a(e, r) {
 	let i = [];
 	for (let a of n(e.roots, e.nodes)) {
 		let e = a.id, n = {
@@ -27,7 +30,7 @@ function i(e, r) {
 			pose: a.pose,
 			data: a.data
 		};
-		a.parent != null && (n.parent = a.parent), a.dependsOn === "children" ? n.dependsOn = "children" : a.dependsOn && a.dependsOn.length > 0 && (n.dependsOn = a.dependsOn), a.pickable === !1 && (n.pickable = !1), Object.assign(n, t(r, a, "jsonKey", (t) => {
+		a.parent != null && (n.parent = a.parent), a.dependsOn === "children" ? n.dependsOn = "children" : a.dependsOn && a.dependsOn.length > 0 && (n.dependsOn = a.dependsOn), a.pickable === !1 && (n.pickable = !1), a.kind === "container" && a.units !== void 0 && (n.units = a.units), Object.assign(n, t(r, a, "jsonKey", (t) => {
 			throw Error(`Scene.toJSON: node '${e}' has ${t.spec.field} but no matching registry key. The function must be registered via createScene's registry option to round-trip.`);
 		})), i.push(n);
 	}
@@ -40,7 +43,7 @@ function i(e, r) {
 		nodes: i
 	};
 }
-function a(t, n) {
+function o(t, n) {
 	if (t.version !== 1) throw Error(`Scene: unsupported version ${t.version}; only v1 supported`);
 	return t.nodes.map((t) => {
 		let r = {
@@ -50,7 +53,7 @@ function a(t, n) {
 			pose: t.pose,
 			data: t.data
 		};
-		t.parent !== void 0 && (r.parent = t.parent), t.pickable !== void 0 && (r.pickable = t.pickable), t.dependsOn !== void 0 && (r.dependsOn = t.dependsOn === "children" ? "children" : t.dependsOn);
+		t.parent !== void 0 && (r.parent = t.parent), t.pickable !== void 0 && (r.pickable = t.pickable), t.units !== void 0 && (r.units = t.units), t.dependsOn !== void 0 && (r.dependsOn = t.dependsOn === "children" ? "children" : t.dependsOn);
 		let i = t;
 		for (let t of e) {
 			let e = i[t.jsonKey];
@@ -63,6 +66,6 @@ function a(t, n) {
 	});
 }
 //#endregion
-export { r as layerFromSerialized, i as serializeScene, a as specsFromSerialized };
+export { r as isSerializedScene, i as layerFromSerialized, a as serializeScene, o as specsFromSerialized };
 
 //# sourceMappingURL=serialization.js.map