@pascal-app/core 1.0.6 → 1.1.0

package/dist/store/use-scene.js

@@ -35,10 +35,11 @@ import { migrateVerticalSceneNodes } from '../utils/vertical-scene-migration.js'
 import { migrateLegacyWallAssemblies } from '../utils/wall-assembly-migration.js';
 import { migrateWallFaceBands, migrateWallFaceKeys } from '../utils/wall-face-migration.js';
 import * as nodeActions from './actions/node-actions.js';
-import { areSceneSnapshotsEqual, beginSceneHistoryPauseSession, getSceneHistoryPauseDepth, isRestoringSceneHistory, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsRemoteSceneChange, runAsSceneHistoryRestore, runSceneWriteGuards, runWithSceneCommitNodeIds, } from './history-control.js';
+import { areSceneSnapshotsEqual, beginSceneHistoryPauseSession, getSceneHistoryPauseDepth, isRestoringSceneHistory, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsRemoteSceneChange, runAsSceneHistoryRestore, runAsSingleSceneHistoryStep, runSceneWriteGuards, runWithSceneCommitNodeIds, settlePendingSceneCommit, } from './history-control.js';
 import { beginSceneHistoryDraft as beginSceneHistoryDraftIn, clearSceneHistoryDrafts, createdSceneHistoryDraftIds, hasSceneHistoryDrafts, noteSceneHistoryDraftWrite, sceneHistoryDraftRevertUpdates as sceneHistoryDraftRevertUpdatesIn, settleSceneHistoryDrafts, withAdoptedDraftsAsOriginal, withDraftsRestored, } from './history-drafts.js';
 import { getHistoryDirtyNodeIds } from './history-invalidation.js';
 import { retainSceneAnnotations, withoutSceneAnnotations, withoutSceneNodeAnnotations, writeSceneNodeField, } from './scene-annotations.js';
+import { bindSceneEnvironment, liveSceneEnvironment, sceneEnvironmentOf, } from './scene-environment.js';
 import { invalidatePendingHydration, isHydrationNormalization, queueSceneNormalization, runSceneHydration, } from './scene-hydration.js';
 import useLiveNodeOverrides from './use-live-node-overrides.js';
 import useLiveTransforms from './use-live-transforms.js';
@@ -1008,16 +1009,22 @@ function sceneHistorySnapshotFromState(state) {
  * still carry `metadata.isNew`, so only explicitly owned drafts are left out.
  */
 export function getSceneDocument(drafts = []) {
-    const state = useScene.getState();
-    const kept = withoutDraftSubtrees(state, [...createdSceneHistoryDraftIds(), ...drafts]);
-    return {
-        nodes: withAdoptedDraftsAsOriginal(state.nodes, kept.nodes),
-        rootNodeIds: kept.rootNodeIds,
-        collections: kept.collections,
-        materials: state.materials,
-        installedPlugins: state.installedPlugins,
-        hasExplicitPluginInstallState: state.hasExplicitPluginInstallState,
-    };
+    return sceneDocumentOf(useScene, drafts);
+}
+/** `getSceneDocument` for any scene store: its document as a save writes it. */
+export function sceneDocumentOf(store, drafts = []) {
+    const state = store.getState();
+    return sceneEnvironmentOf(store).run(() => {
+        const kept = withoutDraftSubtrees(state, [...createdSceneHistoryDraftIds(), ...drafts]);
+        return {
+            nodes: withAdoptedDraftsAsOriginal(state.nodes, kept.nodes),
+            rootNodeIds: kept.rootNodeIds,
+            collections: kept.collections,
+            materials: state.materials,
+            installedPlugins: state.installedPlugins,
+            hasExplicitPluginInstallState: state.hasExplicitPluginInstallState,
+        };
+    });
 }
 /**
  * A dirty mark is a promise that some system will rebuild the node and clear
@@ -1055,52 +1062,31 @@ class GuardedDirtySet extends Set {
         return super.add(id);
     }
 }
-function createSceneStore(config) {
-    const hydratedConfig = (set, get, store) => {
-        const setWithHydration = (partial, replace) => {
-            const state = get();
-            let next = typeof partial === 'function' ? partial(state) : partial;
-            const documentChanged = ['nodes', 'rootNodeIds', 'materials', 'collections', 'installedPlugins'].some((key) => (replace || key in next) && next[key] !== state[key]);
-            if (documentChanged && !isHydrationNormalization()) {
-                invalidatePendingHydration();
-                if (state.hydrationToken)
-                    next = { ...next, hydrationToken: null };
-            }
-            if (replace)
-                set(next, true);
-            else
-                set(next);
-        };
-        store.setState = setWithHydration;
-        return config(setWithHydration, get, store);
-    };
-    return create()(hydratedConfig);
-}
-function runTemporalJump(target, restore) {
-    const draftsBefore = useScene.getState().nodes;
+function runTemporalJump(store, target, restore) {
+    const draftsBefore = store.getState().nodes;
     const restoreDrafts = () => {
-        const current = useScene.getState().nodes;
+        const current = store.getState().nodes;
         const nodes = retainSceneAnnotations(draftsBefore, withDraftsRestored(draftsBefore, current) ?? current);
         if (nodes === current)
             return;
         // The carry's own state, not a new step: a tracked write here would clear redo.
-        const pause = beginSceneHistoryPauseSession(useScene);
+        const pause = beginSceneHistoryPauseSession(store);
         try {
-            useScene.setState({ nodes });
+            store.setState({ nodes });
         }
         finally {
             pause.end();
         }
     };
-    runTemporalJumpOnly(target, () => runAsSceneHistoryRestore(restore));
+    runTemporalJumpOnly(store, target, () => runAsSceneHistoryRestore(restore));
     restoreDrafts();
 }
-function runTemporalJumpOnly(target, jump) {
+function runTemporalJumpOnly(store, target, jump) {
     if (!target?.nodes) {
         jump();
         return;
     }
-    const before = useScene.getState().nodes;
+    const before = store.getState().nodes;
     const changed = new Set();
     for (const id of new Set([...Object.keys(before), ...Object.keys(target.nodes)])) {
         const nodeId = id;
@@ -1116,313 +1102,364 @@ function runTemporalJumpOnly(target, jump) {
     }
     runWithSceneCommitNodeIds(changed, jump);
 }
-const useScene = createSceneStore(temporal((set, get) => ({
-    // 1. Flat dictionary of all nodes
-    nodes: {},
-    // 2. Root node IDs
-    rootNodeIds: [],
-    // 3. Dirty set
-    dirtyNodes: new GuardedDirtySet(get),
-    hydrationToken: null,
-    hydrationId: null,
-    invalidateHydration: () => {
-        invalidatePendingHydration();
-        if (get().hydrationToken)
-            set({ hydrationToken: null });
-    },
-    // 4. Collections
-    collections: {},
-    materials: {},
-    installedPlugins: [],
-    hasExplicitPluginInstallState: false,
-    // 5. Read-only lock
-    readOnly: false,
-    setReadOnly: (readOnly) => set({ readOnly }),
-    unloadScene: () => {
-        runSceneWriteGuards();
-        invalidatePendingHydration();
-        set({
-            hydrationToken: null,
-            hydrationId: null,
-            nodes: {},
-            rootNodeIds: [],
-            dirtyNodes: new GuardedDirtySet(get),
-            collections: {},
-            materials: {},
-            installedPlugins: [],
-            hasExplicitPluginInstallState: false,
-        });
-    },
-    clearScene: () => {
-        const installedPlugins = get().installedPlugins;
-        const hasExplicitPluginInstallState = get().hasExplicitPluginInstallState;
-        get().unloadScene();
-        get().loadScene(); // Default scene
-        set({ installedPlugins, hasExplicitPluginInstallState });
-    },
-    setScene: (nodes, rootNodeIds, extra) => {
-        runSceneWriteGuards();
-        // Apply backward compatibility migrations
-        const { nodes: patchedNodes, mintedMaterials } = migrateNodes(nodes);
-        // Scene materials minted by the legacy→slots migrations join the
-        // loaded palette. Their ids are content-derived, so an existing entry
-        // with the same id (the hosted authority minted it) is the same material.
-        const materials = { ...mintedMaterials, ...(extra?.materials ?? {}) };
-        // Remove orphans: nodes whose parentId points to a non-existent node
-        const cleanedNodes = { ...patchedNodes };
-        for (const node of Object.values(cleanedNodes)) {
-            if (node.parentId && !cleanedNodes[node.parentId]) {
-                console.warn('[Scene] Removing orphan node', node.id, '(parentId', node.parentId, 'not found)');
-                delete cleanedNodes[node.id];
-            }
-        }
-        const normalizedRootNodeIds = normalizeRootNodeIds(cleanedNodes, rootNodeIds);
-        const reachableNodeIds = collectReachableNodeIds(cleanedNodes, normalizedRootNodeIds);
-        if (normalizedRootNodeIds.length > 0) {
-            for (const node of Object.values(cleanedNodes)) {
-                if (reachableNodeIds.has(node.id))
-                    continue;
-                console.warn('[Scene] Removing unreachable node', node.id);
-                delete cleanedNodes[node.id];
+/** Every function field of `state` runs inside `environment` (scene-environment.ts). */
+function inEnvironment(environment, state) {
+    const wrapped = { ...state };
+    for (const [key, value] of Object.entries(state)) {
+        if (typeof value !== 'function')
+            continue;
+        const action = value;
+        wrapped[key] = (...args) => environment.run(() => action(...args));
+    }
+    return wrapped;
+}
+/**
+ * A scene store bound to `environment`: its writes, actions, history and commits run in that
+ * environment, so a second store (a detached scene, `@pascal-app/core/runtime`) never pauses,
+ * commits to or drafts in the editor's. Once the environment is disposed, every read and write
+ * of the store throws.
+ */
+export function createSceneStore(environment) {
+    const store = create()((set, get, api) => {
+        const setWithHydration = (partial, replace) => {
+            const state = get();
+            let next = typeof partial === 'function' ? partial(state) : partial;
+            const documentChanged = ['nodes', 'rootNodeIds', 'materials', 'collections', 'installedPlugins'].some((key) => (replace || key in next) && next[key] !== state[key]);
+            if (documentChanged && !isHydrationNormalization()) {
+                invalidatePendingHydration();
+                if (state.hydrationToken)
+                    next = { ...next, hydrationToken: null };
             }
-        }
-        // Single tracked `set`: with zundo, every tracked write pushes the
-        // pre-write state onto `pastStates`. Writing the scene in two steps
-        // (as this used to) exposed a half-normalized intermediate state —
-        // and the pre-load (possibly empty) state — as undo targets.
-        const hydrationId = {};
-        runSceneHydration(() => {
+            if (replace)
+                set(next, true);
+            else
+                set(next);
+        };
+        api.setState = setWithHydration;
+        const temporalApi = api;
+        return inEnvironment(environment, sceneStoreConfig(() => temporalApi)(setWithHydration, get, temporalApi));
+    });
+    bindSceneEnvironment(store, environment);
+    const { getState, setState } = store;
+    store.getState = () => {
+        environment.assertActive();
+        return getState();
+    };
+    store.setState = ((partial, replace) => environment.run(() => setState(partial, replace)));
+    const temporalState = store.temporal.getState();
+    store.temporal.setState(inEnvironment(environment, temporalState));
+    return store;
+}
+function sceneStoreConfig(storeOf) {
+    return temporal((set, get) => ({
+        // 1. Flat dictionary of all nodes
+        nodes: {},
+        // 2. Root node IDs
+        rootNodeIds: [],
+        // 3. Dirty set
+        dirtyNodes: new GuardedDirtySet(get),
+        hydrationToken: null,
+        hydrationId: null,
+        invalidateHydration: () => {
+            invalidatePendingHydration();
+            if (get().hydrationToken)
+                set({ hydrationToken: null });
+        },
+        // 4. Collections
+        collections: {},
+        materials: {},
+        installedPlugins: [],
+        hasExplicitPluginInstallState: false,
+        // 5. Read-only lock
+        readOnly: false,
+        setReadOnly: (readOnly) => set({ readOnly }),
+        unloadScene: () => {
+            runSceneWriteGuards();
+            invalidatePendingHydration();
             set({
                 hydrationToken: null,
-                hydrationId,
-                nodes: cleanedNodes,
-                rootNodeIds: normalizedRootNodeIds,
+                hydrationId: null,
+                nodes: {},
+                rootNodeIds: [],
                 dirtyNodes: new GuardedDirtySet(get),
-                collections: extra?.collections ?? {},
-                materials,
-                installedPlugins: Array.from(new Set(extra?.installedPlugins ?? [])),
-                hasExplicitPluginInstallState: extra?.hasExplicitPluginInstallState ?? false,
+                collections: {},
+                materials: {},
+                installedPlugins: [],
+                hasExplicitPluginInstallState: false,
             });
-            if (!get().readOnly &&
-                Object.values(get().nodes).some((node) => node.type === 'stair')) {
-                queueSceneNormalization(() => {
-                    if (get().hydrationId !== hydrationId)
-                        return;
-                    const { updates } = ensureSceneOpenings(get().nodes);
-                    if (!updates.length)
-                        return;
-                    pauseSceneHistory(useScene);
-                    try {
-                        get().updateNodes(updates);
-                    }
-                    finally {
-                        resumeSceneHistory(useScene);
-                    }
+        },
+        clearScene: () => {
+            const installedPlugins = get().installedPlugins;
+            const hasExplicitPluginInstallState = get().hasExplicitPluginInstallState;
+            get().unloadScene();
+            get().loadScene(); // Default scene
+            set({ installedPlugins, hasExplicitPluginInstallState });
+        },
+        setScene: (nodes, rootNodeIds, extra) => {
+            runSceneWriteGuards();
+            // Apply backward compatibility migrations
+            const { nodes: patchedNodes, mintedMaterials } = migrateNodes(nodes);
+            // Scene materials minted by the legacy→slots migrations join the
+            // loaded palette. Their ids are content-derived, so an existing entry
+            // with the same id (the hosted authority minted it) is the same material.
+            const materials = { ...mintedMaterials, ...(extra?.materials ?? {}) };
+            // Remove orphans: nodes whose parentId points to a non-existent node
+            const cleanedNodes = { ...patchedNodes };
+            for (const node of Object.values(cleanedNodes)) {
+                if (node.parentId && !cleanedNodes[node.parentId]) {
+                    console.warn('[Scene] Removing orphan node', node.id, '(parentId', node.parentId, 'not found)');
+                    delete cleanedNodes[node.id];
+                }
+            }
+            const normalizedRootNodeIds = normalizeRootNodeIds(cleanedNodes, rootNodeIds);
+            const reachableNodeIds = collectReachableNodeIds(cleanedNodes, normalizedRootNodeIds);
+            if (normalizedRootNodeIds.length > 0) {
+                for (const node of Object.values(cleanedNodes)) {
+                    if (reachableNodeIds.has(node.id))
+                        continue;
+                    console.warn('[Scene] Removing unreachable node', node.id);
+                    delete cleanedNodes[node.id];
+                }
+            }
+            // Single tracked `set`: with zundo, every tracked write pushes the
+            // pre-write state onto `pastStates`. Writing the scene in two steps
+            // (as this used to) exposed a half-normalized intermediate state —
+            // and the pre-load (possibly empty) state — as undo targets.
+            const hydrationId = {};
+            runSceneHydration(() => {
+                set({
+                    hydrationToken: null,
+                    hydrationId,
+                    nodes: cleanedNodes,
+                    rootNodeIds: normalizedRootNodeIds,
+                    dirtyNodes: new GuardedDirtySet(get),
+                    collections: extra?.collections ?? {},
+                    materials,
+                    installedPlugins: Array.from(new Set(extra?.installedPlugins ?? [])),
+                    hasExplicitPluginInstallState: extra?.hasExplicitPluginInstallState ?? false,
                 });
+                if (!get().readOnly &&
+                    Object.values(get().nodes).some((node) => node.type === 'stair')) {
+                    queueSceneNormalization(() => {
+                        if (get().hydrationId !== hydrationId)
+                            return;
+                        const { updates } = ensureSceneOpenings(get().nodes);
+                        if (!updates.length)
+                            return;
+                        pauseSceneHistory(storeOf());
+                        try {
+                            get().updateNodes(updates);
+                        }
+                        finally {
+                            resumeSceneHistory(storeOf());
+                        }
+                    });
+                }
+                // Mark all nodes as dirty to trigger re-validation
+                Object.values(get().nodes).forEach((node) => {
+                    get().markDirty(node.id);
+                });
+            }, () => set({ hydrationToken: hydrationId }));
+        },
+        setInstalledPlugins: (pluginIds, options) => {
+            if (get().readOnly)
+                return;
+            const nextInstalledPlugins = Array.from(new Set(pluginIds));
+            const previousInstalledPlugins = get().installedPlugins;
+            // Guard against the *next* plugin list: the store still holds the old
+            // one, and re-marks for newly enabled kinds must pass the guard.
+            const dirtyNodes = new GuardedDirtySet(() => ({ nodes: get().nodes, installedPlugins: nextInstalledPlugins }), get().dirtyNodes);
+            for (const node of Object.values(get().nodes)) {
+                if (!getNodePluginId(node.type))
+                    continue;
+                if (!isNodeKindEnabled(node.type, nextInstalledPlugins)) {
+                    dirtyNodes.delete(node.id);
+                }
+                else if (!isNodeKindEnabled(node.type, previousInstalledPlugins)) {
+                    if (nodeRegistry.get(node.type)?.dirtyTracking !== false)
+                        dirtyNodes.add(node.id);
+                }
             }
-            // Mark all nodes as dirty to trigger re-validation
-            Object.values(get().nodes).forEach((node) => {
-                get().markDirty(node.id);
+            set({
+                installedPlugins: nextInstalledPlugins,
+                hasExplicitPluginInstallState: options?.explicit ?? get().hasExplicitPluginInstallState,
+                dirtyNodes,
             });
-        }, () => set({ hydrationToken: hydrationId }));
-    },
-    setInstalledPlugins: (pluginIds, options) => {
-        if (get().readOnly)
-            return;
-        const nextInstalledPlugins = Array.from(new Set(pluginIds));
-        const previousInstalledPlugins = get().installedPlugins;
-        // Guard against the *next* plugin list: the store still holds the old
-        // one, and re-marks for newly enabled kinds must pass the guard.
-        const dirtyNodes = new GuardedDirtySet(() => ({ nodes: get().nodes, installedPlugins: nextInstalledPlugins }), get().dirtyNodes);
-        for (const node of Object.values(get().nodes)) {
-            if (!getNodePluginId(node.type))
-                continue;
-            if (!isNodeKindEnabled(node.type, nextInstalledPlugins)) {
-                dirtyNodes.delete(node.id);
-            }
-            else if (!isNodeKindEnabled(node.type, previousInstalledPlugins)) {
-                if (nodeRegistry.get(node.type)?.dirtyTracking !== false)
-                    dirtyNodes.add(node.id);
+        },
+        loadScene: () => {
+            if (get().rootNodeIds.length > 0) {
+                // Assign all nodes as dirty to force re-validation
+                Object.values(get().nodes).forEach((node) => {
+                    get().markDirty(node.id);
+                });
+                return; // Scene already loaded
             }
-        }
-        set({
-            installedPlugins: nextInstalledPlugins,
-            hasExplicitPluginInstallState: options?.explicit ?? get().hasExplicitPluginInstallState,
-            dirtyNodes,
-        });
-    },
-    loadScene: () => {
-        if (get().rootNodeIds.length > 0) {
-            // Assign all nodes as dirty to force re-validation
-            Object.values(get().nodes).forEach((node) => {
-                get().markDirty(node.id);
+            // Create hierarchy: Site → Building → Level. Parent links must be
+            // written explicitly — the schema defaults `parentId` to null, and the
+            // scene authority rejects parent/child asymmetry that the renderer
+            // happily traverses through `children`.
+            const site = SiteNode.parse({});
+            const building = BuildingNode.parse({
+                parentId: site.id,
             });
-            return; // Scene already loaded
-        }
-        // Create hierarchy: Site → Building → Level. Parent links must be
-        // written explicitly — the schema defaults `parentId` to null, and the
-        // scene authority rejects parent/child asymmetry that the renderer
-        // happily traverses through `children`.
-        const site = SiteNode.parse({});
-        const building = BuildingNode.parse({
-            parentId: site.id,
-        });
-        const level0 = LevelNode.parse({
-            parentId: building.id,
-            level: 0,
-            children: [],
-            height: DEFAULT_LEVEL_HEIGHT,
-        });
-        // Define all nodes flat
-        const nodes = {
-            [site.id]: { ...site, children: [building.id] },
-            [building.id]: { ...building, children: [level0.id] },
-            [level0.id]: level0,
-        };
-        // Site is the root
-        const rootNodeIds = [site.id];
-        set({ nodes, rootNodeIds });
-    },
-    markDirty: (id) => {
-        // Guarded here too, not just in GuardedDirtySet.add — tests (and any
-        // setState caller) can swap in a plain Set.
-        if (!isDirtyTrackable(id, get()))
-            return;
-        get().dirtyNodes.add(id);
-    },
-    clearDirty: (id) => {
-        get().dirtyNodes.delete(id);
-    },
-    createNodes: (ops, options) => nodeActions.createNodesAction(set, get, ops, options),
-    createNode: (node, parentId, options) => nodeActions.createNodesAction(set, get, [{ node, parentId }], options),
-    applyNodeChanges: (changes, options) => nodeActions.applyNodeChangesAction(set, get, changes, options),
-    updateNodes: (updates, options) => nodeActions.updateNodesAction(set, get, updates, options),
-    updateNode: (id, data, options) => nodeActions.updateNodesAction(set, get, [{ id, data }], options),
-    detachDerivedNode: (id, data) => nodeActions.detachDerivedNodeAction(set, get, id, data),
-    // --- DELETE ---
-    deleteNodes: (ids, options) => nodeActions.deleteNodesAction(set, get, ids, options),
-    deleteNode: (id, options) => nodeActions.deleteNodesAction(set, get, [id], options),
-    // --- COLLECTIONS ---
-    createCollection: (name, nodeIds = []) => {
-        if (get().readOnly)
-            return '';
-        const id = generateCollectionId();
-        set((state) => ({
-            collections: { ...state.collections, [id]: { id, name, nodeIds: [...nodeIds] } },
-            nodes: mirrorItemMembership(state.nodes, id, nodeIds, true),
-        }));
-        return id;
-    },
-    deleteCollection: (id) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const col = state.collections[id];
-            const nextCollections = { ...state.collections };
-            delete nextCollections[id];
-            return {
-                collections: nextCollections,
-                nodes: mirrorItemMembership(state.nodes, id, col?.nodeIds ?? [], false),
+            const level0 = LevelNode.parse({
+                parentId: building.id,
+                level: 0,
+                children: [],
+                height: DEFAULT_LEVEL_HEIGHT,
+            });
+            // Define all nodes flat
+            const nodes = {
+                [site.id]: { ...site, children: [building.id] },
+                [building.id]: { ...building, children: [level0.id] },
+                [level0.id]: level0,
             };
-        });
-    },
-    updateCollection: (id, data) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const col = state.collections[id];
-            if (!col)
-                return state;
-            return { collections: { ...state.collections, [id]: { ...col, ...data } } };
-        });
-    },
-    addToCollection: (id, nodeIds) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const col = state.collections[id];
-            const added = nodeIds.filter((nodeId) => !col?.nodeIds.includes(nodeId));
-            if (!col || added.length === 0)
-                return state;
+            // Site is the root
+            const rootNodeIds = [site.id];
+            set({ nodes, rootNodeIds });
+        },
+        markDirty: (id) => {
+            // Guarded here too, not just in GuardedDirtySet.add — tests (and any
+            // setState caller) can swap in a plain Set.
+            if (!isDirtyTrackable(id, get()))
+                return;
+            get().dirtyNodes.add(id);
+        },
+        clearDirty: (id) => {
+            get().dirtyNodes.delete(id);
+        },
+        createNodes: (ops, options) => nodeActions.createNodesAction(set, get, ops, options),
+        createNode: (node, parentId, options) => nodeActions.createNodesAction(set, get, [{ node, parentId }], options),
+        applyNodeChanges: (changes, options) => nodeActions.applyNodeChangesAction(set, get, changes, options),
+        updateNodes: (updates, options) => nodeActions.updateNodesAction(set, get, updates, options),
+        updateNode: (id, data, options) => nodeActions.updateNodesAction(set, get, [{ id, data }], options),
+        detachDerivedNode: (id, data) => nodeActions.detachDerivedNodeAction(set, get, id, data),
+        // --- DELETE ---
+        deleteNodes: (ids, options) => nodeActions.deleteNodesAction(set, get, ids, options),
+        deleteNode: (id, options) => nodeActions.deleteNodesAction(set, get, [id], options),
+        // --- COLLECTIONS ---
+        createCollection: (name, nodeIds = []) => {
+            if (get().readOnly)
+                return '';
+            const id = generateCollectionId();
+            set((state) => ({
+                collections: { ...state.collections, [id]: { id, name, nodeIds: [...nodeIds] } },
+                nodes: mirrorItemMembership(state.nodes, id, nodeIds, true),
+            }));
+            return id;
+        },
+        deleteCollection: (id) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const col = state.collections[id];
+                const nextCollections = { ...state.collections };
+                delete nextCollections[id];
+                return {
+                    collections: nextCollections,
+                    nodes: mirrorItemMembership(state.nodes, id, col?.nodeIds ?? [], false),
+                };
+            });
+        },
+        updateCollection: (id, data) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const col = state.collections[id];
+                if (!col)
+                    return state;
+                return { collections: { ...state.collections, [id]: { ...col, ...data } } };
+            });
+        },
+        addToCollection: (id, nodeIds) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const col = state.collections[id];
+                const added = nodeIds.filter((nodeId) => !col?.nodeIds.includes(nodeId));
+                if (!col || added.length === 0)
+                    return state;
+                return {
+                    collections: {
+                        ...state.collections,
+                        [id]: { ...col, nodeIds: [...col.nodeIds, ...added] },
+                    },
+                    nodes: mirrorItemMembership(state.nodes, id, added, true),
+                };
+            });
+        },
+        removeFromCollection: (id, nodeIds) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const col = state.collections[id];
+                const removed = nodeIds.filter((nodeId) => col?.nodeIds.includes(nodeId));
+                if (!col || removed.length === 0)
+                    return state;
+                return {
+                    collections: {
+                        ...state.collections,
+                        [id]: { ...col, nodeIds: col.nodeIds.filter((nodeId) => !removed.includes(nodeId)) },
+                    },
+                    nodes: mirrorItemMembership(state.nodes, id, removed, false),
+                };
+            });
+        },
+        // --- SCENE MATERIALS ---
+        addSceneMaterial: (material) => {
+            if (get().readOnly)
+                return;
+            set((state) => ({
+                materials: { ...state.materials, [material.id]: material },
+            }));
+        },
+        updateSceneMaterial: (id, data) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const material = state.materials[id];
+                if (!material)
+                    return state;
+                return { materials: { ...state.materials, [id]: { ...material, ...data } } };
+            });
+        },
+        removeSceneMaterial: (id) => {
+            if (get().readOnly)
+                return;
+            set((state) => {
+                const materials = { ...state.materials };
+                delete materials[id];
+                return { materials };
+            });
+        },
+    }), {
+        partialize: (state) => sceneHistorySnapshotFromState(state),
+        equality: (pastState, currentState) => areSceneSnapshotsEqual({ ...pastState, nodes: withoutSceneAnnotations(pastState.nodes) }, { ...currentState, nodes: withoutSceneAnnotations(currentState.nodes) }),
+        onSave: (pastState, currentState) => {
+            notifySceneCommit({
+                origin: 'local',
+                before: sceneHistorySnapshotFromState(pastState),
+                current: sceneHistorySnapshotFromState(currentState),
+            });
+        },
+        wrapTemporal: (config) => (set, get, store) => {
+            const state = config(set, get, store);
             return {
-                collections: {
-                    ...state.collections,
-                    [id]: { ...col, nodeIds: [...col.nodeIds, ...added] },
+                ...state,
+                undo: (steps = 1) => {
+                    runSceneWriteGuards(storeOf());
+                    return runTemporalJump(storeOf(), get().pastStates.slice().splice(-steps, steps)[0], () => state.undo(steps));
                 },
-                nodes: mirrorItemMembership(state.nodes, id, added, true),
-            };
-        });
-    },
-    removeFromCollection: (id, nodeIds) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const col = state.collections[id];
-            const removed = nodeIds.filter((nodeId) => col?.nodeIds.includes(nodeId));
-            if (!col || removed.length === 0)
-                return state;
-            return {
-                collections: {
-                    ...state.collections,
-                    [id]: { ...col, nodeIds: col.nodeIds.filter((nodeId) => !removed.includes(nodeId)) },
+                redo: (steps = 1) => {
+                    runSceneWriteGuards(storeOf());
+                    return runTemporalJump(storeOf(), get().futureStates.slice().splice(-steps, steps)[0], () => state.redo(steps));
                 },
-                nodes: mirrorItemMembership(state.nodes, id, removed, false),
             };
-        });
-    },
-    // --- SCENE MATERIALS ---
-    addSceneMaterial: (material) => {
-        if (get().readOnly)
-            return;
-        set((state) => ({
-            materials: { ...state.materials, [material.id]: material },
-        }));
-    },
-    updateSceneMaterial: (id, data) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const material = state.materials[id];
-            if (!material)
-                return state;
-            return { materials: { ...state.materials, [id]: { ...material, ...data } } };
-        });
-    },
-    removeSceneMaterial: (id) => {
-        if (get().readOnly)
-            return;
-        set((state) => {
-            const materials = { ...state.materials };
-            delete materials[id];
-            return { materials };
-        });
-    },
-}), {
-    partialize: (state) => sceneHistorySnapshotFromState(state),
-    equality: (pastState, currentState) => areSceneSnapshotsEqual({ ...pastState, nodes: withoutSceneAnnotations(pastState.nodes) }, { ...currentState, nodes: withoutSceneAnnotations(currentState.nodes) }),
-    onSave: (pastState, currentState) => {
-        notifySceneCommit({
-            origin: 'local',
-            before: sceneHistorySnapshotFromState(pastState),
-            current: sceneHistorySnapshotFromState(currentState),
-        });
-    },
-    wrapTemporal: (config) => (set, get, store) => {
-        const state = config(set, get, store);
-        return {
-            ...state,
-            undo: (steps = 1) => {
-                runSceneWriteGuards();
-                return runTemporalJump(get().pastStates.slice().splice(-steps, steps)[0], () => state.undo(steps));
-            },
-            redo: (steps = 1) => {
-                runSceneWriteGuards();
-                return runTemporalJump(get().futureStates.slice().splice(-steps, steps)[0], () => state.redo(steps));
-            },
-        };
-    },
-    limit: 50, // Limit to last 50 actions
-}));
+        },
+        limit: 50, // Limit to last 50 actions
+    });
+}
+const useScene = createSceneStore(liveSceneEnvironment);
 // Live state belongs to the hydration owner so even a lazy consumer cannot
 // miss an override that was set and cleared before its first frame.
 const invalidateForLiveState = () => {
@@ -1574,7 +1611,12 @@ function insertSceneStructuralPlacements(base, placements) {
     }
     return result;
 }
-function sceneOperationPatchNextState(beforeState, changes) {
+/**
+ * The document a patch makes of `beforeState`, without a store, or null when the patch does not
+ * apply to it (a delete of a node that changed, a create at a taken position, a node that fails
+ * its schema). `applySceneOperationPatch` writes exactly this.
+ */
+export function nextSceneOperationState(beforeState, changes) {
     const createIds = new Set();
     const deleteIds = new Set();
     const updateIds = new Set();
@@ -1807,7 +1849,7 @@ function sceneOperationPatchNextState(beforeState, changes) {
     };
 }
 export function applySceneOperationPatch(changes, options = {}) {
-    runSceneWriteGuards();
+    runSceneWriteGuards(useScene);
     const beforeState = useScene.getState();
     if (changes.nodeUpdates.length === 0 &&
         changes.materialChanges.length === 0 &&
@@ -1842,7 +1884,7 @@ export function applySceneOperationPatch(changes, options = {}) {
         return false;
     if (sceneOperationPatchHasLiveConflict(beforeState, changes))
         return false;
-    const next = sceneOperationPatchNextState(beforeState, changes);
+    const next = nextSceneOperationState(beforeState, changes);
     if (!next)
         return false;
     const before = sceneHistorySnapshotFromState(beforeState);
@@ -1935,6 +1977,36 @@ export function applySceneOperationPatch(changes, options = {}) {
     });
     return true;
 }
+/**
+ * Runs `run` on `store` as one undo step and one commit that carries everything it changed: its
+ * own writes and the history-paused derived writes it settles after them (`reconcileDocument`),
+ * which a commit captured when the first write landed would miss. Collaboration then receives the
+ * derived construction, with its ids, in the same commit as the edit that caused it.
+ */
+export function runAsSettledSceneStep(store, run) {
+    const environment = sceneEnvironmentOf(store);
+    const snapshot = () => environment.run(() => sceneHistorySnapshotFromState(store.getState()));
+    const before = snapshot();
+    const pastBefore = store.temporal.getState().pastStates.length;
+    return runAsSingleSceneHistoryStep(store, () => {
+        const result = run();
+        const current = snapshot();
+        if (areSceneSnapshotsEqual(before, current))
+            return result;
+        const temporal = store.temporal.getState();
+        // Only paused (derived) writes landed: they still make one step of their own.
+        if (temporal.pastStates.length === pastBefore &&
+            temporal.isTracking &&
+            getSceneHistoryPauseDepth(store) === 0)
+            store.temporal.setState({ pastStates: [...temporal.pastStates, before], futureStates: [] });
+        const changedNodeIds = new Set();
+        for (const id of new Set([...Object.keys(before.nodes), ...Object.keys(current.nodes)]))
+            if (before.nodes[id] !== current.nodes[id])
+                changedNodeIds.add(id);
+        settlePendingSceneCommit(store, { origin: 'local', before, current, changedNodeIds });
+        return result;
+    });
+}
 export function applyScenePatch(changes) {
     return applySceneOperationPatch({
         ...changes,
@@ -1943,7 +2015,7 @@ export function applyScenePatch(changes) {
     });
 }
 export function applySceneSnapshot(snapshot, options) {
-    runSceneWriteGuards();
+    runSceneWriteGuards(useScene);
     const before = sceneHistorySnapshotFromState(useScene.getState());
     const temporalState = useScene.temporal.getState();
     if (!temporalState.isTracking || getSceneHistoryPauseDepth() > 0 || hasSceneHistoryDrafts()) {