@pascal-app/core 1.0.5 → 1.0.7

package/dist/store/history-control.js

@@ -1,92 +1,152 @@
 import { withSceneHistoryDraftSuspended } from './history-drafts.js';
-let sceneHistoryRestoreDepth = 0;
+import { currentSceneEnvironment, sceneEnvironmentOf, } from './scene-environment.js';
+const HISTORY_CONTROL = Symbol('scene-history-control');
+function controlOf(environment) {
+    return environment.slot(HISTORY_CONTROL, () => ({
+        restoreDepth: 0,
+        remoteOperationDepth: 0,
+        pauseDepth: 0,
+        pauseLeases: new Set(),
+        commitListeners: new Set(),
+        commitTransactionDepth: 0,
+        pendingCommit: null,
+        commitNodeIdScopes: [],
+        gesturePauseHolders: new Map(),
+        livePauseHolders: new Set(),
+        writeGuards: new Set(),
+        derivedWrites: new Map(),
+    }));
+}
+/** The state of the environment whose store is acting, or the live one. */
+const current = () => controlOf(currentSceneEnvironment());
+/** The state of `store`'s own environment. */
+const of = (store) => controlOf(sceneEnvironmentOf(store));
 export function isRestoringSceneHistory() {
-    return sceneHistoryRestoreDepth > 0;
+    return current().restoreDepth > 0;
 }
 export function runAsSceneHistoryRestore(run) {
-    sceneHistoryRestoreDepth += 1;
+    const control = current();
+    control.restoreDepth += 1;
     try {
         return run();
     }
     finally {
-        sceneHistoryRestoreDepth -= 1;
+        control.restoreDepth -= 1;
     }
 }
-let remoteSceneOperationDepth = 0;
 /**
  * Whether the scene is being written by a collaborator's change (a shared
  * operation or snapshot applied from the host), not by this client — what a
  * live session that takes back its own writes must leave alone.
  */
 export function isApplyingRemoteSceneChange() {
-    return remoteSceneOperationDepth > 0;
+    return current().remoteOperationDepth > 0;
 }
 export function runAsRemoteSceneChange(run) {
-    remoteSceneOperationDepth += 1;
+    const control = current();
+    control.remoteOperationDepth += 1;
     try {
         return run();
     }
     finally {
-        remoteSceneOperationDepth -= 1;
+        control.remoteOperationDepth -= 1;
     }
 }
-let sceneHistoryPauseDepth = 0;
-const sceneHistoryPauseLeases = new Set();
-const sceneCommitListeners = new Set();
-let sceneCommitTransactionDepth = 0;
-let pendingSceneCommit = null;
-const sceneCommitNodeIdScopes = [];
 function mergedNodeIds(left, right) {
     if (!(left || right))
         return undefined;
     return new Set([...(left ?? []), ...(right ?? [])]);
 }
 export function activeSceneCommitNodeIds() {
-    if (sceneCommitNodeIdScopes.length === 0)
+    const scopes = current().commitNodeIdScopes;
+    if (scopes.length === 0)
         return undefined;
     const ids = new Set();
-    for (const scope of sceneCommitNodeIdScopes) {
+    for (const scope of scopes) {
         for (const id of scope)
             ids.add(id);
     }
     return ids;
 }
 export function addActiveSceneCommitNodeIds(nodeIds) {
-    const scope = sceneCommitNodeIdScopes.at(-1);
+    const scope = current().commitNodeIdScopes.at(-1);
     if (!scope)
         return;
     for (const id of nodeIds)
         scope.add(id);
 }
 export function runWithSceneCommitNodeIds(nodeIds, run) {
+    const scopes = current().commitNodeIdScopes;
     const scope = new Set(nodeIds);
-    sceneCommitNodeIdScopes.push(scope);
+    scopes.push(scope);
     try {
         return run();
     }
     finally {
-        sceneCommitNodeIdScopes.pop();
-        const parentScope = sceneCommitNodeIdScopes.at(-1);
+        scopes.pop();
+        const parentScope = scopes.at(-1);
         if (parentScope) {
             for (const id of scope)
                 parentScope.add(id);
         }
     }
 }
-const sceneWriteGuards = new Set();
+function areSemanticValuesEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (typeof left !== typeof right || left === null || right === null)
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!(Array.isArray(left) && Array.isArray(right)) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => areSemanticValuesEqual(value, right[index]));
+    }
+    if (typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (const key of leftKeys) {
+        if (!(key in rightRecord) || !areSemanticValuesEqual(leftRecord[key], rightRecord[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function areSceneSnapshotsEqual(left, right) {
+    return (areSemanticValuesEqual(left.nodes, right.nodes) &&
+        areSemanticValuesEqual(left.rootNodeIds, right.rootNodeIds) &&
+        areSemanticValuesEqual(left.collections, right.collections) &&
+        areSemanticValuesEqual(left.materials, right.materials) &&
+        areSemanticValuesEqual(left.installedPlugins, right.installedPlugins) &&
+        (left.hasExplicitPluginInstallState ?? false) === (right.hasExplicitPluginInstallState ?? false));
+}
+/** Listens to the commits of the current environment's store: the live editor's, by default. */
+export function subscribeSceneCommits(listener) {
+    const listeners = current().commitListeners;
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
 /**
- * Registers something that must let go of the scene before anything writes it: a preview that
- * shows another state (`scene-preview.ts`) would otherwise swallow the write or have it land on
- * the wrong state. Returns the unregister.
+ * Registers something that must let go of the current environment's scene before anything writes
+ * it: a preview that shows another state (`scene-preview.ts`) would otherwise swallow the write or
+ * have it land on the wrong state. Returns the unregister.
  */
 export function registerSceneWriteGuard(guard) {
-    sceneWriteGuards.add(guard);
+    const guards = current().writeGuards;
+    guards.add(guard);
     return () => {
-        sceneWriteGuards.delete(guard);
+        guards.delete(guard);
     };
 }
-export function runSceneWriteGuards() {
-    for (const guard of [...sceneWriteGuards])
+/** Runs the guards of `sceneStore`'s environment, or of the current one. */
+export function runSceneWriteGuards(sceneStore) {
+    for (const guard of [...(sceneStore ? of(sceneStore) : current()).writeGuards])
         guard();
 }
 const sceneCommitAuthorScopes = [];
@@ -124,51 +184,12 @@ export function acquireSceneCommitAuthor(author) {
         sceneCommitAuthorLeases.delete(lease);
     };
 }
-function areSemanticValuesEqual(left, right) {
-    if (Object.is(left, right))
-        return true;
-    if (typeof left !== typeof right || left === null || right === null)
-        return false;
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!(Array.isArray(left) && Array.isArray(right)) || left.length !== right.length)
-            return false;
-        return left.every((value, index) => areSemanticValuesEqual(value, right[index]));
-    }
-    if (typeof left !== 'object' || typeof right !== 'object')
-        return false;
-    const leftRecord = left;
-    const rightRecord = right;
-    const leftKeys = Object.keys(leftRecord);
-    const rightKeys = Object.keys(rightRecord);
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    for (const key of leftKeys) {
-        if (!(key in rightRecord) || !areSemanticValuesEqual(leftRecord[key], rightRecord[key])) {
-            return false;
-        }
-    }
-    return true;
-}
-export function areSceneSnapshotsEqual(left, right) {
-    return (areSemanticValuesEqual(left.nodes, right.nodes) &&
-        areSemanticValuesEqual(left.rootNodeIds, right.rootNodeIds) &&
-        areSemanticValuesEqual(left.collections, right.collections) &&
-        areSemanticValuesEqual(left.materials, right.materials) &&
-        areSemanticValuesEqual(left.installedPlugins, right.installedPlugins) &&
-        (left.hasExplicitPluginInstallState ?? false) === (right.hasExplicitPluginInstallState ?? false));
-}
-export function subscribeSceneCommits(listener) {
-    sceneCommitListeners.add(listener);
-    return () => {
-        sceneCommitListeners.delete(listener);
-    };
-}
-let derivedWrites = new Map();
 /**
- * Records what the derived-writer capability writes, for the commit that follows: each node, and the
- * fields written (none given: the node as a whole).
+ * Records what the derived-writer capability writes, for the current environment's commit that
+ * follows: each node, and the fields written (none given: the node as a whole).
  */
 export function noteDerivedNodeWrites(writes) {
+    const derivedWrites = current().derivedWrites;
     for (const { id, fields } of writes) {
         const noted = derivedWrites.get(id);
         if (noted === 'all')
@@ -179,11 +200,11 @@ export function noteDerivedNodeWrites(writes) {
             derivedWrites.set(id, new Set([...(noted ?? []), ...fields]));
     }
 }
-function emitSceneCommit(authored) {
-    const derived = derivedWrites;
-    derivedWrites = new Map();
+function emitSceneCommit(control, authored) {
+    const derived = control.derivedWrites;
+    control.derivedWrites = new Map();
     const commit = derived.size > 0 ? { ...authored, derivedWrites: derived } : authored;
-    for (const listener of [...sceneCommitListeners]) {
+    for (const listener of [...control.commitListeners]) {
         try {
             listener(commit);
         }
@@ -193,9 +214,10 @@ function emitSceneCommit(authored) {
     }
 }
 export function notifySceneCommit(commit) {
+    const control = current();
     if (areSceneSnapshotsEqual(commit.before, commit.current)) {
-        if (sceneCommitTransactionDepth === 0)
-            derivedWrites = new Map();
+        if (control.commitTransactionDepth === 0)
+            control.derivedWrites = new Map();
         return;
     }
     const author = commit.author ?? activeSceneCommitAuthor();
@@ -204,80 +226,101 @@ export function notifySceneCommit(commit) {
         ...(author ? { author } : {}),
         changedNodeIds: mergedNodeIds(commit.changedNodeIds, activeSceneCommitNodeIds()),
     };
-    if (sceneCommitTransactionDepth > 0) {
-        if (pendingSceneCommit) {
-            const pendingAuthor = pendingSceneCommit.author ?? contextualCommit.author;
-            pendingSceneCommit = {
-                origin: pendingSceneCommit.origin,
+    if (control.commitTransactionDepth > 0) {
+        const pending = control.pendingCommit;
+        if (pending) {
+            const pendingAuthor = pending.author ?? contextualCommit.author;
+            control.pendingCommit = {
+                origin: pending.origin,
                 ...(pendingAuthor ? { author: pendingAuthor } : {}),
-                before: pendingSceneCommit.before,
+                before: pending.before,
                 current: contextualCommit.current,
-                changedNodeIds: mergedNodeIds(pendingSceneCommit.changedNodeIds, contextualCommit.changedNodeIds),
+                changedNodeIds: mergedNodeIds(pending.changedNodeIds, contextualCommit.changedNodeIds),
             };
         }
         else {
-            pendingSceneCommit = contextualCommit;
+            control.pendingCommit = contextualCommit;
         }
         return;
     }
-    emitSceneCommit(contextualCommit);
+    emitSceneCommit(control, contextualCommit);
 }
-function beginSceneCommitTransaction() {
-    sceneCommitTransactionDepth += 1;
+/**
+ * Makes `commit` the one `store`'s open transaction (`runAsSingleSceneHistoryStep`) emits: the
+ * pending commit, if any, keeps its origin, author and `before` and takes `commit`'s `current`,
+ * with both sets of changed ids. Outside a transaction, `commit` is emitted.
+ */
+export function settlePendingSceneCommit(store, commit) {
+    const control = of(store);
+    if (control.commitTransactionDepth === 0) {
+        sceneEnvironmentOf(store).run(() => notifySceneCommit(commit));
+        return;
+    }
+    const pending = control.pendingCommit;
+    const author = pending?.author ?? commit.author ?? activeSceneCommitAuthor();
+    control.pendingCommit = {
+        origin: pending?.origin ?? commit.origin,
+        ...(author ? { author } : {}),
+        before: pending?.before ?? commit.before,
+        current: commit.current,
+        changedNodeIds: mergedNodeIds(pending?.changedNodeIds, commit.changedNodeIds),
+    };
 }
-function pendingSceneCommitIsNoOp() {
-    return Boolean(pendingSceneCommit &&
-        areSceneSnapshotsEqual(pendingSceneCommit.before, pendingSceneCommit.current));
+function pendingSceneCommitIsNoOp(control) {
+    const pending = control.pendingCommit;
+    return Boolean(pending && areSceneSnapshotsEqual(pending.before, pending.current));
 }
-function endSceneCommitTransaction() {
-    if (sceneCommitTransactionDepth === 0)
+function endSceneCommitTransaction(control) {
+    if (control.commitTransactionDepth === 0)
         return;
-    sceneCommitTransactionDepth -= 1;
-    if (sceneCommitTransactionDepth > 0)
+    control.commitTransactionDepth -= 1;
+    if (control.commitTransactionDepth > 0)
         return;
-    const commit = pendingSceneCommit;
-    pendingSceneCommit = null;
+    const commit = control.pendingCommit;
+    control.pendingCommit = null;
     if (!commit)
         return;
     if (areSceneSnapshotsEqual(commit.before, commit.current))
-        derivedWrites = new Map();
+        control.derivedWrites = new Map();
     else
-        emitSceneCommit(commit);
+        emitSceneCommit(control, commit);
 }
+const pauseDepthOf = (control) => control.pauseDepth + control.pauseLeases.size;
 export function pauseSceneHistory(sceneStore) {
-    if (getSceneHistoryPauseDepth() === 0) {
+    const control = of(sceneStore);
+    if (pauseDepthOf(control) === 0) {
         sceneStore.temporal.getState().pause();
     }
-    sceneHistoryPauseDepth += 1;
+    control.pauseDepth += 1;
 }
 export function resumeSceneHistory(sceneStore) {
-    if (sceneHistoryPauseDepth === 0) {
+    const control = of(sceneStore);
+    if (control.pauseDepth === 0) {
         return;
     }
-    sceneHistoryPauseDepth -= 1;
-    if (getSceneHistoryPauseDepth() === 0) {
+    control.pauseDepth -= 1;
+    if (pauseDepthOf(control) === 0) {
         sceneStore.temporal.getState().resume();
     }
 }
 export function acquireSceneHistoryPause(sceneStore) {
-    if (getSceneHistoryPauseDepth() === 0) {
+    const control = of(sceneStore);
+    if (pauseDepthOf(control) === 0) {
         sceneStore.temporal.getState().pause();
     }
     const lease = Symbol('scene-history-pause');
-    sceneHistoryPauseLeases.add(lease);
+    control.pauseLeases.add(lease);
     let released = false;
     return () => {
         if (released)
             return;
         released = true;
-        sceneHistoryPauseLeases.delete(lease);
-        if (getSceneHistoryPauseDepth() === 0) {
+        control.pauseLeases.delete(lease);
+        if (pauseDepthOf(control) === 0) {
             sceneStore.temporal.getState().resume();
         }
     };
 }
-const gesturePauseHolders = new Map();
-const livePauseHolders = new Set();
 /** Lifts `holders`' pauses for `write`, then takes back those that have not ended. */
 function runWithHoldersLifted(sceneStore, holders, write) {
     const lifted = [...holders].filter((holder) => holder.release);
@@ -308,20 +351,22 @@ function runWithHoldersLifted(sceneStore, holders, write) {
  */
 export function beginSceneHistoryPauseSession(sceneStore, options = {}) {
     const { gesture } = options;
+    const environment = sceneEnvironmentOf(sceneStore);
+    const control = controlOf(environment);
     const holder = {
         release: acquireSceneHistoryPause(sceneStore),
         ended: false,
     };
-    livePauseHolders.add(holder);
+    control.livePauseHolders.add(holder);
     let coOwners = new Set([holder]);
     if (gesture) {
-        coOwners = gesturePauseHolders.get(gesture) ?? new Set();
+        coOwners = control.gesturePauseHolders.get(gesture) ?? new Set();
         coOwners.add(holder);
-        gesturePauseHolders.set(gesture, coOwners);
+        control.gesturePauseHolders.set(gesture, coOwners);
     }
     return {
         commitStep(write) {
-            return runWithHoldersLifted(sceneStore, coOwners, () => withSceneHistoryDraftSuspended(gesture, write));
+            return environment.run(() => runWithHoldersLifted(sceneStore, coOwners, () => withSceneHistoryDraftSuspended(gesture, write)));
         },
         end() {
             if (holder.ended)
@@ -329,24 +374,26 @@ export function beginSceneHistoryPauseSession(sceneStore, options = {}) {
             holder.ended = true;
             holder.release?.();
             holder.release = null;
-            livePauseHolders.delete(holder);
+            control.livePauseHolders.delete(holder);
             coOwners.delete(holder);
             if (gesture && coOwners.size === 0)
-                gesturePauseHolders.delete(gesture);
+                control.gesturePauseHolders.delete(gesture);
         },
     };
 }
-export function getSceneHistoryPauseDepth() {
-    return sceneHistoryPauseDepth + sceneHistoryPauseLeases.size;
+/** Pauses held on `sceneStore`'s history, or on the current environment's store's. */
+export function getSceneHistoryPauseDepth(sceneStore) {
+    return pauseDepthOf(sceneStore ? of(sceneStore) : current());
 }
-export function resetSceneHistoryPauseDepth() {
-    sceneHistoryPauseDepth = 0;
-    sceneHistoryPauseLeases.clear();
+export function resetSceneHistoryPauseDepth(sceneStore) {
+    const control = sceneStore ? of(sceneStore) : current();
+    control.pauseDepth = 0;
+    control.pauseLeases.clear();
     // Open sessions no longer hold anything; a later commitStep must not re-take their pause.
-    for (const holder of livePauseHolders)
+    for (const holder of control.livePauseHolders)
         holder.release = null;
-    livePauseHolders.clear();
-    gesturePauseHolders.clear();
+    control.livePauseHolders.clear();
+    control.gesturePauseHolders.clear();
 }
 function retainedPastStateCount(before, after) {
     for (let start = 0; start < before.length; start += 1) {
@@ -366,14 +413,16 @@ function retainedPastStateCount(before, after) {
     return 0;
 }
 export function runAsSingleSceneHistoryStep(sceneStore, run) {
+    const environment = sceneEnvironmentOf(sceneStore);
+    const control = controlOf(environment);
     const beforePastStates = sceneStore.temporal.getState().pastStates;
-    beginSceneCommitTransaction();
+    control.commitTransactionDepth += 1;
     try {
-        const result = run();
+        const result = environment.run(run);
         const afterPastStates = sceneStore.temporal.getState().pastStates;
         const retainedCount = retainedPastStateCount(beforePastStates, afterPastStates);
         const addedCount = afterPastStates.length - retainedCount;
-        if (addedCount > 0 && pendingSceneCommitIsNoOp()) {
+        if (addedCount > 0 && pendingSceneCommitIsNoOp(control)) {
             sceneStore.temporal.setState({ pastStates: afterPastStates.slice(0, retainedCount) });
         }
         else if (addedCount > 1) {
@@ -387,6 +436,6 @@ export function runAsSingleSceneHistoryStep(sceneStore, run) {
         return result;
     }
     finally {
-        endSceneCommitTransaction();
+        endSceneCommitTransaction(control);
     }
 }

package/dist/store/history-drafts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history-drafts.d.ts","sourceRoot":"","sources":["../../src/store/history-drafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAgDzD,KAAK,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAWzC;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,OAAO,GAAG,IAAI,EACxB,KAAK,EAAE,OAAO,GACb,MAAM,IAAI,CAmBZ;AAcD;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAW3F;AA4BD,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAwChF;AAiCD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,GACvB,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAsBzD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAOvE;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED,6FAA6F;AAC7F,wBAAgB,2BAA2B,IAAI,SAAS,EAAE,CAIzD;AAiDD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAmC1F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAwFlF"}
+{"version":3,"file":"history-drafts.d.ts","sourceRoot":"","sources":["../../src/store/history-drafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAqDzD,KAAK,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAWzC;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,OAAO,GAAG,IAAI,EACxB,KAAK,EAAE,OAAO,GACb,MAAM,IAAI,CAoBZ;AAkBD;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAW3F;AA4BD,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAwChF;AAiCD;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,GACvB,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,CAsBzD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAOvE;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED,6FAA6F;AAC7F,wBAAgB,2BAA2B,IAAI,SAAS,EAAE,CAIzD;AAiDD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAmC1F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAwFlF"}

package/dist/store/history-drafts.js

@@ -1,3 +1,4 @@
+import { currentSceneEnvironment } from './scene-environment.js';
 /** Structural equality for node field values (plain data: arrays, objects, primitives). */
 function sameValue(a, b) {
     if (a === b)
@@ -12,7 +13,9 @@ function sameValue(a, b) {
         return false;
     return aKeys.every((key) => sameValue(a[key], b[key]));
 }
-const sceneHistoryDrafts = new Map();
+const HISTORY_DRAFTS = Symbol('scene-history-drafts');
+/** The carried drafts of the current environment's store (scene-environment.ts). */
+const sceneHistoryDrafts = () => currentSceneEnvironment().slot(HISTORY_DRAFTS, () => new Map());
 const faceHostFields = ['roofSegmentId', 'roofFace', 'blockFaceId'];
 const childIdsOf = (node) => node && 'children' in node && Array.isArray(node.children) ? node.children : [];
 const attachmentsOf = (node) => node && 'attachments' in node && node.attachments && typeof node.attachments === 'object'
@@ -23,10 +26,11 @@ const attachmentsOf = (node) => node && 'attachments' in node && node.attachment
  * already carried (split view) shares its registration, which ends with its last holder.
  */
 export function beginSceneHistoryDraft(id, original, nodes) {
-    const existing = sceneHistoryDrafts.get(id);
+    const drafts = sceneHistoryDrafts();
+    const existing = drafts.get(id);
     if (existing && !existing.ended) {
         existing.refs += 1;
-        return releaseOnce(id, existing);
+        return releaseOnce(drafts, id, existing);
     }
     const parent = original?.parentId ? nodes[original.parentId] : undefined;
     const draft = {
@@ -39,10 +43,10 @@ export function beginSceneHistoryDraft(id, original, nodes) {
         ended: false,
         suspended: false,
     };
-    sceneHistoryDrafts.set(id, draft);
-    return releaseOnce(id, draft);
+    drafts.set(id, draft);
+    return releaseOnce(drafts, id, draft);
 }
-function releaseOnce(id, draft) {
+function releaseOnce(drafts, id, draft) {
     let released = false;
     return () => {
         if (released)
@@ -52,8 +56,8 @@ function releaseOnce(id, draft) {
         if (draft.refs > 0)
             return;
         draft.ended = true;
-        if (sceneHistoryDrafts.get(id) === draft)
-            sceneHistoryDrafts.delete(id);
+        if (drafts.get(id) === draft)
+            drafts.delete(id);
     };
 }
 /**
@@ -61,7 +65,7 @@ function releaseOnce(id, draft) {
  * gesture drops it (the 3D mover or the 2D move overlay) records the change.
  */
 export function withSceneHistoryDraftSuspended(id, write) {
-    const draft = id ? sceneHistoryDrafts.get(id) : undefined;
+    const draft = id ? sceneHistoryDrafts().get(id) : undefined;
     if (!(id && draft))
         return write();
     // Visible to history for this write, but still the carry's: its own restore can revert it.
@@ -92,7 +96,7 @@ function heldHostEntries(draft, id, nodes) {
     return [...draft.hostEntries].filter(([hostId, entry]) => nodes[hostId] && sameValue(hostEntry(nodes, hostId, id), entry.carried));
 }
 export function hasSceneHistoryDrafts() {
-    return sceneHistoryDrafts.size > 0;
+    return sceneHistoryDrafts().size > 0;
 }
 /**
  * Records a carry's own write: each field it changed on an adopted draft is held with the value
@@ -100,7 +104,7 @@ export function hasSceneHistoryDrafts() {
  * the carry wrote. A write back to that earlier value ends the hold.
  */
 export function noteSceneHistoryDraftWrite(before, after) {
-    for (const [id, draft] of sceneHistoryDrafts) {
+    for (const [id, draft] of sceneHistoryDrafts()) {
         const previous = before[id];
         const next = after[id];
         if (!(draft.original && previous && next))
@@ -181,7 +185,7 @@ function heldFields(draft, live) {
 export function sceneHistoryDraftRevertUpdates(nodes, ids) {
     const updates = [];
     for (const id of ids) {
-        const draft = sceneHistoryDrafts.get(id);
+        const draft = sceneHistoryDrafts().get(id);
         const live = nodes[id];
         if (!(draft?.original && live))
             continue;
@@ -212,7 +216,7 @@ export function sceneHistoryDraftRevertUpdates(nodes, ids) {
  */
 export function settleSceneHistoryDrafts(ids) {
     for (const id of ids) {
-        const draft = sceneHistoryDrafts.get(id);
+        const draft = sceneHistoryDrafts().get(id);
         if (!draft)
             continue;
         draft.owned.clear();
@@ -220,11 +224,11 @@ export function settleSceneHistoryDrafts(ids) {
     }
 }
 export function clearSceneHistoryDrafts() {
-    sceneHistoryDrafts.clear();
+    sceneHistoryDrafts().clear();
 }
 /** Created drafts: history excludes them (and their subtrees) like fresh-placement nodes. */
 export function createdSceneHistoryDraftIds() {
-    return [...sceneHistoryDrafts]
+    return [...sceneHistoryDrafts()]
         .filter(([, draft]) => !(draft.original || draft.suspended))
         .map(([id]) => id);
 }
@@ -277,7 +281,7 @@ function placeChild(nodes, id, fromParentId, toParentId, index, attachment) {
  */
 export function withAdoptedDraftsAsOriginal(nodes, historyNodes) {
     let result = null;
-    for (const [id, draft] of sceneHistoryDrafts) {
+    for (const [id, draft] of sceneHistoryDrafts()) {
         if (draft.suspended)
             continue;
         const live = nodes[id];
@@ -316,7 +320,7 @@ export function withAdoptedDraftsAsOriginal(nodes, historyNodes) {
  */
 export function withDraftsRestored(before, after) {
     let result = null;
-    for (const [id, draft] of sceneHistoryDrafts) {
+    for (const [id, draft] of sceneHistoryDrafts()) {
         if (draft.suspended)
             continue;
         const live = before[id];

package/dist/store/live-previews.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether the editor's live previews (field overrides, drag transforms, an in-flight terrain
+ * stroke) are part of what is being read. They are not inside `withoutLivePreviews`: a detached
+ * scene, and the document reconciliation, compute from saved state only, since a preview is
+ * neither a dependency anyone can check nor a value that will necessarily be committed.
+ */
+export declare function livePreviewsVisible(): boolean;
+export declare function withoutLivePreviews<T>(run: () => T): T;
+//# sourceMappingURL=live-previews.d.ts.map

package/dist/store/live-previews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-previews.d.ts","sourceRoot":"","sources":["../../src/store/live-previews.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAOtD"}

package/dist/store/live-previews.js

@@ -0,0 +1,19 @@
+let hidden = 0;
+/**
+ * Whether the editor's live previews (field overrides, drag transforms, an in-flight terrain
+ * stroke) are part of what is being read. They are not inside `withoutLivePreviews`: a detached
+ * scene, and the document reconciliation, compute from saved state only, since a preview is
+ * neither a dependency anyone can check nor a value that will necessarily be committed.
+ */
+export function livePreviewsVisible() {
+    return hidden === 0;
+}
+export function withoutLivePreviews(run) {
+    hidden += 1;
+    try {
+        return run();
+    }
+    finally {
+        hidden -= 1;
+    }
+}