@pascal-app/core 1.0.1 → 1.0.4

package/dist/store/history-control.d.ts

@@ -1,12 +1,22 @@
 import type { Collection, CollectionId } from '../schema/collections.js';
 import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
 import type { AnyNode, AnyNodeId } from '../schema/types.js';
+export declare function isRestoringSceneHistory(): boolean;
+export declare function runAsSceneHistoryRestore<T>(run: () => T): T;
+/**
+ * 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 declare function isApplyingRemoteSceneChange(): boolean;
+export declare function runAsRemoteSceneChange<T>(run: () => T): T;
 export type SceneSnapshot = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     collections: Record<CollectionId, Collection>;
     materials: Record<SceneMaterialId, SceneMaterial>;
     installedPlugins: string[];
+    hasExplicitPluginInstallState?: boolean;
 };
 export type SceneCommitOrigin = 'local' | 'load' | 'host';
 export type SceneCommit = {
@@ -43,6 +53,30 @@ export declare function notifySceneCommit(commit: SceneCommit): void;
 export declare function pauseSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function resumeSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function acquireSceneHistoryPause(sceneStore: TemporalStoreLike): () => void;
+export type SceneHistoryPauseSession = {
+    /**
+     * Runs one committing write with this gesture's pauses lifted, then takes them back.
+     * The write lands as tracked history only when no other owner is pausing it.
+     */
+    commitStep<T>(write: () => T): T;
+    /** Releases this session's pause. Idempotent. */
+    end(): void;
+};
+export type SceneHistoryPauseSessionOptions = {
+    /** Sessions with the same key co-own one gesture; see `beginSceneHistoryPauseSession`. */
+    gesture?: string;
+};
+/**
+ * Holds a refcounted pause for a whole gesture (drag). Unlike a raw
+ * `temporal.pause()`, cooperating systems see the gesture through
+ * `getSceneHistoryPauseDepth()`, and their balanced pause/resume pairs cannot
+ * resume history under it.
+ *
+ * Sessions opened with the same `gesture` key co-own the gesture (the 3D mover
+ * and the 2D move overlay of one moving node): either one's `commitStep` lifts
+ * both pauses, so whichever view drops records the one step.
+ */
+export declare function beginSceneHistoryPauseSession(sceneStore: TemporalStoreLike, options?: SceneHistoryPauseSessionOptions): SceneHistoryPauseSession;
 export declare function getSceneHistoryPauseDepth(): number;
 export declare function resetSceneHistoryPauseDepth(): void;
 export declare function runAsSingleSceneHistoryStep<TPastState, TResult>(sceneStore: TemporalHistoryStoreLike<TPastState>, run: () => TResult): TResult;

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

@@ -1 +1 @@
-{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAKzD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC7C,SAAS,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IACjD,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAEzD,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,EAAE,aAAa,CAAA;IACrB,OAAO,EAAE,aAAa,CAAA;IACtB,cAAc,CAAC,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;AAE/D,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,KAAK,IAAI,IAAI,CAAA;YACb,MAAM,IAAI,IAAI,CAAA;SACf,CAAA;KACF,CAAA;CACF,CAAA;AAED,KAAK,wBAAwB,CAAC,UAAU,IAAI;IAC1C,QAAQ,EAAE;QACR,QAAQ,IAAI;YACV,UAAU,EAAE,UAAU,EAAE,CAAA;SACzB,CAAA;QACD,QAAQ,CAAC,KAAK,EAAE;YAAE,UAAU,EAAE,UAAU,EAAE,CAAA;SAAE,GAAG,IAAI,CAAA;KACpD,CAAA;CACF,CAAA;AAeD,wBAAgB,wBAAwB,IAAI,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,CAO7E;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAI9E;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAC/C,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,EAC5B,GAAG,EAAE,MAAM,OAAO,GACjB,OAAO,CAYT;AA2BD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAQzF;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAK/E;AAYD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAyB3D;AAyBD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAKrE;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI,CAStE;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,IAAI,CAelF;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAGlD;AAkBD,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,OAAO,EAC7D,UAAU,EAAE,wBAAwB,CAAC,UAAU,CAAC,EAChD,GAAG,EAAE,MAAM,OAAO,GACjB,OAAO,CAuBT"}
+{"version":3,"file":"history-control.d.ts","sourceRoot":"","sources":["../../src/store/history-control.ts"],"names":[],"mappings":"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"}

package/dist/store/history-control.js

@@ -1,3 +1,35 @@
+import { withSceneHistoryDraftSuspended } from './history-drafts.js';
+let sceneHistoryRestoreDepth = 0;
+export function isRestoringSceneHistory() {
+    return sceneHistoryRestoreDepth > 0;
+}
+export function runAsSceneHistoryRestore(run) {
+    sceneHistoryRestoreDepth += 1;
+    try {
+        return run();
+    }
+    finally {
+        sceneHistoryRestoreDepth -= 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;
+}
+export function runAsRemoteSceneChange(run) {
+    remoteSceneOperationDepth += 1;
+    try {
+        return run();
+    }
+    finally {
+        remoteSceneOperationDepth -= 1;
+    }
+}
 let sceneHistoryPauseDepth = 0;
 const sceneHistoryPauseLeases = new Set();
 const sceneCommitListeners = new Set();
@@ -71,7 +103,8 @@ export function areSceneSnapshotsEqual(left, right) {
         areSemanticValuesEqual(left.rootNodeIds, right.rootNodeIds) &&
         areSemanticValuesEqual(left.collections, right.collections) &&
         areSemanticValuesEqual(left.materials, right.materials) &&
-        areSemanticValuesEqual(left.installedPlugins, right.installedPlugins));
+        areSemanticValuesEqual(left.installedPlugins, right.installedPlugins) &&
+        (left.hasExplicitPluginInstallState ?? false) === (right.hasExplicitPluginInstallState ?? false));
 }
 export function subscribeSceneCommits(listener) {
     sceneCommitListeners.add(listener);
@@ -163,12 +196,77 @@ export function acquireSceneHistoryPause(sceneStore) {
         }
     };
 }
+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);
+    for (const holder of lifted) {
+        const release = holder.release;
+        holder.release = null;
+        release();
+    }
+    try {
+        return write();
+    }
+    finally {
+        for (const holder of lifted) {
+            if (!holder.ended)
+                holder.release = acquireSceneHistoryPause(sceneStore);
+        }
+    }
+}
+/**
+ * Holds a refcounted pause for a whole gesture (drag). Unlike a raw
+ * `temporal.pause()`, cooperating systems see the gesture through
+ * `getSceneHistoryPauseDepth()`, and their balanced pause/resume pairs cannot
+ * resume history under it.
+ *
+ * Sessions opened with the same `gesture` key co-own the gesture (the 3D mover
+ * and the 2D move overlay of one moving node): either one's `commitStep` lifts
+ * both pauses, so whichever view drops records the one step.
+ */
+export function beginSceneHistoryPauseSession(sceneStore, options = {}) {
+    const { gesture } = options;
+    const holder = {
+        release: acquireSceneHistoryPause(sceneStore),
+        ended: false,
+    };
+    livePauseHolders.add(holder);
+    let coOwners = new Set([holder]);
+    if (gesture) {
+        coOwners = gesturePauseHolders.get(gesture) ?? new Set();
+        coOwners.add(holder);
+        gesturePauseHolders.set(gesture, coOwners);
+    }
+    return {
+        commitStep(write) {
+            return runWithHoldersLifted(sceneStore, coOwners, () => withSceneHistoryDraftSuspended(gesture, write));
+        },
+        end() {
+            if (holder.ended)
+                return;
+            holder.ended = true;
+            holder.release?.();
+            holder.release = null;
+            livePauseHolders.delete(holder);
+            coOwners.delete(holder);
+            if (gesture && coOwners.size === 0)
+                gesturePauseHolders.delete(gesture);
+        },
+    };
+}
 export function getSceneHistoryPauseDepth() {
     return sceneHistoryPauseDepth + sceneHistoryPauseLeases.size;
 }
 export function resetSceneHistoryPauseDepth() {
     sceneHistoryPauseDepth = 0;
     sceneHistoryPauseLeases.clear();
+    // Open sessions no longer hold anything; a later commitStep must not re-take their pause.
+    for (const holder of livePauseHolders)
+        holder.release = null;
+    livePauseHolders.clear();
+    gesturePauseHolders.clear();
 }
 function retainedPastStateCount(before, after) {
     for (let start = 0; start < before.length; start += 1) {

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

@@ -0,0 +1,48 @@
+import type { AnyNode, AnyNodeId } from '../schema/types.js';
+type NodeMap = Record<AnyNodeId, AnyNode>;
+/**
+ * Registers `id` as a carried draft; returns the call that ends it. A second holder of a node
+ * already carried (split view) shares its registration, which ends with its last holder.
+ */
+export declare function beginSceneHistoryDraft(id: AnyNodeId, original: AnyNode | null, nodes: NodeMap): () => void;
+/**
+ * Runs a gesture's committing write with `id` visible to history, so whichever co-owner of the
+ * gesture drops it (the 3D mover or the 2D move overlay) records the change.
+ */
+export declare function withSceneHistoryDraftSuspended<T>(id: string | undefined, write: () => T): T;
+export declare function hasSceneHistoryDrafts(): boolean;
+/**
+ * Records a carry's own write: each field it changed on an adopted draft is held with the value
+ * it had before (kept from an earlier carry write while the carry still held it) and the value
+ * the carry wrote. A write back to that earlier value ends the hold.
+ */
+export declare function noteSceneHistoryDraftWrite(before: NodeMap, after: NodeMap): void;
+/**
+ * Updates that put an adopted draft's held fields back to their values before the carry,
+ * leaving everything others wrote. A parent that no longer exists is never restored.
+ */
+export declare function sceneHistoryDraftRevertUpdates(nodes: NodeMap, ids: Iterable<AnyNodeId>): Array<{
+    id: AnyNodeId;
+    data: Record<string, unknown>;
+}>;
+/**
+ * A drop committed these drafts' carried state: nothing the carry wrote is left to revert, so a
+ * co-holder's later cancel or cleanup (the 3D mover after a split-view 2D drop) keeps the drop.
+ */
+export declare function settleSceneHistoryDrafts(ids: Iterable<AnyNodeId>): void;
+export declare function clearSceneHistoryDrafts(): void;
+/** Created drafts: history excludes them (and their subtrees) like fresh-placement nodes. */
+export declare function createdSceneHistoryDraftIds(): AnyNodeId[];
+/**
+ * Records the carry-owned fields of adopted drafts as they were before the carry. The original
+ * parent link is restored only while that parent still exists. `historyNodes` may be `nodes`.
+ */
+export declare function withAdoptedDraftsAsOriginal(nodes: NodeMap, historyNodes: NodeMap): NodeMap;
+/**
+ * After an undo or redo, puts back what the carry holds: a created draft (and its subtree)
+ * whole, and on an adopted draft only its held fields, as they were just before the jump.
+ * Everything else keeps the jumped-to state. Returns null when nothing needs restoring.
+ */
+export declare function withDraftsRestored(before: NodeMap, after: NodeMap): NodeMap | null;
+export {};
+//# sourceMappingURL=history-drafts.d.ts.map

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

@@ -0,0 +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"}

package/dist/store/history-drafts.js

@@ -0,0 +1,403 @@
+/** Structural equality for node field values (plain data: arrays, objects, primitives). */
+function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((key) => sameValue(a[key], b[key]));
+}
+const sceneHistoryDrafts = 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'
+    ? node.attachments
+    : undefined;
+/**
+ * Registers `id` as a carried draft; returns the call that ends it. A second holder of a node
+ * already carried (split view) shares its registration, which ends with its last holder.
+ */
+export function beginSceneHistoryDraft(id, original, nodes) {
+    const existing = sceneHistoryDrafts.get(id);
+    if (existing && !existing.ended) {
+        existing.refs += 1;
+        return releaseOnce(id, existing);
+    }
+    const parent = original?.parentId ? nodes[original.parentId] : undefined;
+    const draft = {
+        original,
+        parentIndex: childIdsOf(parent).indexOf(id),
+        attachment: attachmentsOf(parent)?.[id],
+        owned: new Map(),
+        hostEntries: new Map(),
+        refs: 1,
+        ended: false,
+        suspended: false,
+    };
+    sceneHistoryDrafts.set(id, draft);
+    return releaseOnce(id, draft);
+}
+function releaseOnce(id, draft) {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        draft.refs -= 1;
+        if (draft.refs > 0)
+            return;
+        draft.ended = true;
+        if (sceneHistoryDrafts.get(id) === draft)
+            sceneHistoryDrafts.delete(id);
+    };
+}
+/**
+ * Runs a gesture's committing write with `id` visible to history, so whichever co-owner of the
+ * 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;
+    if (!(id && draft))
+        return write();
+    // Visible to history for this write, but still the carry's: its own restore can revert it.
+    const wasSuspended = draft.suspended;
+    draft.suspended = true;
+    try {
+        return write();
+    }
+    finally {
+        draft.suspended = wasSuspended;
+    }
+}
+/** A host's attachment entry for `id`, or ABSENT. */
+const ABSENT = Symbol('absent');
+function hostEntry(nodes, hostId, id) {
+    const attachments = attachmentsOf(nodes[hostId]);
+    return attachments && Object.hasOwn(attachments, id) ? attachments[id] : ABSENT;
+}
+/** `host` with its attachment entry for `id` set to `value` (ABSENT removes it). */
+function withHostEntry(host, id, value) {
+    const { [id]: _previous, ...rest } = attachmentsOf(host) ?? {};
+    return {
+        ...host,
+        attachments: value === ABSENT ? rest : { ...rest, [id]: value },
+    };
+}
+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;
+}
+/**
+ * Records a carry's own write: each field it changed on an adopted draft is held with the value
+ * it had before (kept from an earlier carry write while the carry still held it) and the value
+ * the carry wrote. A write back to that earlier value ends the hold.
+ */
+export function noteSceneHistoryDraftWrite(before, after) {
+    for (const [id, draft] of sceneHistoryDrafts) {
+        const previous = before[id];
+        const next = after[id];
+        if (!(draft.original && previous && next))
+            continue;
+        const hosts = new Set([
+            previous.parentId,
+            next.parentId,
+            draft.original.parentId,
+            ...draft.hostEntries.keys(),
+        ].filter((hostId) => typeof hostId === 'string'));
+        for (const hostId of hosts) {
+            const was = hostEntry(before, hostId, id);
+            const now = hostEntry(after, hostId, id);
+            if (sameValue(was, now))
+                continue;
+            const held = draft.hostEntries.get(hostId);
+            const baseline = held && sameValue(held.carried, was) ? held.baseline : was;
+            if (sameValue(baseline, now))
+                draft.hostEntries.delete(hostId);
+            else
+                draft.hostEntries.set(hostId, { baseline, carried: now });
+        }
+        if (previous === next)
+            continue;
+        for (const key of new Set([...Object.keys(previous), ...Object.keys(next)])) {
+            if (sameValue(previous[key], next[key]))
+                continue;
+            const held = key === 'metadata'
+                ? heldFields(draft, before[id]).find(([name]) => name === key)?.[1]
+                : draft.owned.get(key);
+            const baseline = held && sameValue(held.carried, previous[key])
+                ? held.baseline
+                : { present: Object.hasOwn(previous, key), value: previous[key] };
+            if (baseline.present === Object.hasOwn(next, key) && sameValue(baseline.value, next[key])) {
+                draft.owned.delete(key);
+            }
+            else {
+                draft.owned.set(key, { baseline, carried: next[key] });
+            }
+        }
+    }
+}
+/**
+ * The fields the carry still holds on an adopted draft: those whose live value is still the
+ * carry's. A foreign write over one ends the hold (until the carry writes it again).
+ */
+function heldFields(draft, live) {
+    const values = live;
+    return [...draft.owned].flatMap(([key, field]) => {
+        if (sameValue(values[key], field.carried))
+            return [[key, field]];
+        if (key !== 'metadata')
+            return [];
+        const current = values[key];
+        const carried = field.carried;
+        const baseline = (field.baseline.present ? field.baseline.value : {});
+        if (!(current && carried && baseline))
+            return [];
+        // Metadata writers commonly spread the current record before adding their own key.
+        // Retain ownership of unchanged carry keys without masking that writer's additions.
+        const heldKeys = [...new Set([...Object.keys(baseline), ...Object.keys(carried)])].filter((name) => !sameValue(baseline[name], carried[name]) && sameValue(current[name], carried[name]));
+        if (heldKeys.length === 0)
+            return [];
+        const restored = { ...current };
+        for (const name of heldKeys) {
+            if (Object.hasOwn(baseline, name))
+                restored[name] = baseline[name];
+            else
+                delete restored[name];
+        }
+        return [[key, { baseline: { present: true, value: restored }, carried: current, heldKeys }]];
+    });
+}
+/**
+ * Updates that put an adopted draft's held fields back to their values before the carry,
+ * leaving everything others wrote. A parent that no longer exists is never restored.
+ */
+export function sceneHistoryDraftRevertUpdates(nodes, ids) {
+    const updates = [];
+    for (const id of ids) {
+        const draft = sceneHistoryDrafts.get(id);
+        const live = nodes[id];
+        if (!(draft?.original && live))
+            continue;
+        const data = {};
+        for (const [key, { baseline }] of heldFields(draft, live)) {
+            if (key === 'parentId' && baseline.value && !nodes[baseline.value])
+                continue;
+            data[key] = baseline.present ? baseline.value : undefined;
+        }
+        if (Object.keys(data).length > 0)
+            updates.push({ id, data });
+        for (const [hostId, { baseline }] of heldHostEntries(draft, id, nodes)) {
+            const pending = updates.find((update) => update.id === hostId);
+            const host = { ...nodes[hostId], ...(pending?.data ?? {}) };
+            const attachments = withHostEntry(host, id, baseline)
+                .attachments;
+            if (pending)
+                pending.data.attachments = attachments;
+            else
+                updates.push({ id: hostId, data: { attachments } });
+        }
+    }
+    return updates;
+}
+/**
+ * A drop committed these drafts' carried state: nothing the carry wrote is left to revert, so a
+ * co-holder's later cancel or cleanup (the 3D mover after a split-view 2D drop) keeps the drop.
+ */
+export function settleSceneHistoryDrafts(ids) {
+    for (const id of ids) {
+        const draft = sceneHistoryDrafts.get(id);
+        if (!draft)
+            continue;
+        draft.owned.clear();
+        draft.hostEntries.clear();
+    }
+}
+export function clearSceneHistoryDrafts() {
+    sceneHistoryDrafts.clear();
+}
+/** Created drafts: history excludes them (and their subtrees) like fresh-placement nodes. */
+export function createdSceneHistoryDraftIds() {
+    return [...sceneHistoryDrafts]
+        .filter(([, draft]) => !(draft.original || draft.suspended))
+        .map(([id]) => id);
+}
+/** Moves `id` from wherever it lives in `nodes` to `parentId` (at `index`), with `attachment`. */
+function placeChild(nodes, id, fromParentId, toParentId, index, attachment) {
+    const update = (parentId, edit) => {
+        const parent = nodes[parentId];
+        if (!parent)
+            return;
+        const next = { ...parent };
+        edit(next);
+        nodes[parentId] = next;
+    };
+    if (fromParentId && fromParentId !== toParentId) {
+        update(fromParentId, (parent) => {
+            const children = parent.children;
+            if (Array.isArray(children))
+                parent.children = children.filter((child) => child !== id);
+            const attachments = parent.attachments;
+            if (attachments && Object.hasOwn(attachments, id)) {
+                const { [id]: _removed, ...rest } = attachments;
+                parent.attachments = rest;
+            }
+        });
+    }
+    if (!toParentId)
+        return;
+    update(toParentId, (parent) => {
+        const children = parent.children;
+        if (Array.isArray(children) && !children.includes(id)) {
+            const next = [...children];
+            next.splice(index < 0 ? next.length : Math.min(index, next.length), 0, id);
+            parent.children = next;
+        }
+        const attachments = parent.attachments;
+        if (attachment === undefined) {
+            if (attachments && Object.hasOwn(attachments, id)) {
+                const { [id]: _removed, ...rest } = attachments;
+                parent.attachments = rest;
+            }
+        }
+        else if (attachments?.[id] !== attachment) {
+            parent.attachments = { ...(attachments ?? {}), [id]: attachment };
+        }
+    });
+}
+/**
+ * Records the carry-owned fields of adopted drafts as they were before the carry. The original
+ * parent link is restored only while that parent still exists. `historyNodes` may be `nodes`.
+ */
+export function withAdoptedDraftsAsOriginal(nodes, historyNodes) {
+    let result = null;
+    for (const [id, draft] of sceneHistoryDrafts) {
+        if (draft.suspended)
+            continue;
+        const live = nodes[id];
+        const held = draft.original && live ? heldFields(draft, live) : [];
+        const heldHosts = draft.original && live ? heldHostEntries(draft, id, nodes) : [];
+        if (!(draft.original && live) || held.length + heldHosts.length === 0)
+            continue;
+        const heldParent = held.find(([key]) => key === 'parentId')?.[1].baseline;
+        const originalParentId = heldParent?.value;
+        const restoreParent = Boolean(heldParent) && (!originalParentId || Boolean(nodes[originalParentId]));
+        const recorded = { ...live };
+        for (const [key, { baseline }] of held) {
+            if (key === 'parentId' && !restoreParent)
+                continue;
+            if (baseline.present)
+                recorded[key] = baseline.value;
+            else
+                delete recorded[key];
+        }
+        result ??= { ...historyNodes };
+        result[id] = recorded;
+        if (restoreParent) {
+            placeChild(result, id, live.parentId, originalParentId, originalParentId === draft.original.parentId ? draft.parentIndex : -1, originalParentId === draft.original.parentId ? draft.attachment : undefined);
+        }
+        for (const [hostId, { baseline }] of heldHosts) {
+            if (result[hostId])
+                result[hostId] = withHostEntry(result[hostId], id, baseline);
+        }
+    }
+    return result ?? historyNodes;
+}
+/**
+ * After an undo or redo, puts back what the carry holds: a created draft (and its subtree)
+ * whole, and on an adopted draft only its held fields, as they were just before the jump.
+ * Everything else keeps the jumped-to state. Returns null when nothing needs restoring.
+ */
+export function withDraftsRestored(before, after) {
+    let result = null;
+    for (const [id, draft] of sceneHistoryDrafts) {
+        if (draft.suspended)
+            continue;
+        const live = before[id];
+        if (!live)
+            continue;
+        if (draft.original) {
+            const jumped = after[id];
+            if (!jumped)
+                continue;
+            for (const [hostId, { carried }] of heldHostEntries(draft, id, before)) {
+                const host = (result ?? after)[hostId];
+                if (!host || sameValue(hostEntry(result ?? after, hostId, id), carried))
+                    continue;
+                result ??= { ...after };
+                result[hostId] = withHostEntry(host, id, carried);
+            }
+            const values = live;
+            const heldEntries = new Map(heldFields(draft, live));
+            const held = [...heldEntries]
+                .map(([key]) => key)
+                .filter((key) => !sameValue(values[key], jumped[key]));
+            if (held.length === 0)
+                continue;
+            result ??= { ...after };
+            const restored = { ...jumped };
+            const lostParent = live.parentId && !result[live.parentId];
+            for (const key of held) {
+                // A missing host's binding must not replace the jumped-to parent's valid binding.
+                if (lostParent && (key === 'parentId' || faceHostFields.includes(key)))
+                    continue;
+                const heldKeys = heldEntries.get(key)?.heldKeys;
+                if (heldKeys) {
+                    const metadata = { ...restored[key] };
+                    const carried = values[key];
+                    for (const name of heldKeys) {
+                        if (Object.hasOwn(carried, name))
+                            metadata[name] = carried[name];
+                        else
+                            delete metadata[name];
+                    }
+                    restored[key] = metadata;
+                    continue;
+                }
+                if (Object.hasOwn(values, key))
+                    restored[key] = values[key];
+                else
+                    delete restored[key];
+            }
+            result[id] = restored;
+            const parentId = live.parentId;
+            if (held.includes('parentId') && parentId && result[parentId]) {
+                const beforeParent = before[parentId];
+                placeChild(result, id, jumped.parentId, parentId, childIdsOf(beforeParent).indexOf(id), attachmentsOf(beforeParent)?.[id]);
+            }
+            continue;
+        }
+        const subtree = [id];
+        for (let index = 0; index < subtree.length; index++) {
+            for (const childId of childIdsOf(before[subtree[index]]))
+                subtree.push(childId);
+        }
+        if (subtree.every((nodeId) => after[nodeId] === before[nodeId]))
+            continue;
+        result ??= { ...after };
+        for (const nodeId of subtree)
+            result[nodeId] = before[nodeId];
+        let parentId = live.parentId;
+        const visited = new Set();
+        while (parentId && !result[parentId] && !visited.has(parentId)) {
+            visited.add(parentId);
+            parentId = before[parentId]?.parentId;
+        }
+        if (parentId !== live.parentId) {
+            const restored = { ...live, parentId: parentId ?? null };
+            for (const key of faceHostFields)
+                delete restored[key];
+            result[id] = restored;
+        }
+        const previousParentId = after[id]?.parentId;
+        const beforeParent = parentId ? before[parentId] : undefined;
+        placeChild(result, id, previousParentId, parentId, childIdsOf(beforeParent).indexOf(id), attachmentsOf(beforeParent)?.[id]);
+    }
+    return result;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"history-invalidation.d.ts","sourceRoot":"","sources":["../../src/store/history-invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAG7D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,GAAG,CAAC,SAAS,CAAC,CAyEhB"}
+{"version":3,"file":"history-invalidation.d.ts","sourceRoot":"","sources":["../../src/store/history-invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAG7D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,GAAG,CAAC,SAAS,CAAC,CA0EhB"}

package/dist/store/history-invalidation.js

@@ -20,6 +20,7 @@ export function getHistoryDirtyNodeIds(before, after) {
             if (previous?.type !== 'wall' ||
                 next?.type !== 'wall' ||
                 previous.thickness !== next.thickness ||
+                previous.justification !== next.justification ||
                 previous.height !== next.height ||
                 previous.curveOffset !== next.curveOffset) {
                 changedHosts.add(id);