@ifc-lite/mutations 1.23.0 → 1.24.2

package/dist/mutable-property-view.js

@@ -3,10 +3,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 import { PropertyValueType, QuantityType } from '@ifc-lite/data';
 import { propertyKey, quantityKey, attributeKey, generateMutationId } from './types.js';
+import { collectEffectiveChanges } from './effective-changes.js';
 export class MutablePropertyView {
     baseTable;
     onDemandExtractor = null;
     quantityExtractor = null;
+    attributeExtractor = null;
     propertyMutations = new Map();
     quantityMutations = new Map();
     /**
@@ -28,6 +30,39 @@ export class MutablePropertyView {
     typeMutations = new Map(); // entityId -> retype intent
     newEntities = new Map();
     tombstones = new Set();
+    /**
+     * Ids `createEntity` allocated and `deleteEntity` then forgot (removed from
+     * `newEntities`, per that method's "existing entities are tombstoned; new
+     * entities are simply forgotten" contract). Tracked separately so
+     * `getEffectiveChanges()` / `collectEffectiveChanges` can tell "overlay-created
+     * then forgotten" apart from "an ordinary source-buffer entity" — both are
+     * otherwise indistinguishable, being simply absent from `newEntities`.
+     * `restoreNewEntity` (the undo-of-delete counterpart) clears the id back out.
+     */
+    forgottenCreatedEntities = new Set();
+    /**
+     * Snapshot of a forgotten-created entity's overlay rows, stashed by
+     * `deleteEntity` and restored by `restoreNewEntity`.
+     *
+     * `deleteEntity` on an overlay-created entity does more than drop it from
+     * `newEntities` — it also PURGES every other overlay entry the entity left
+     * behind (property/quantity/attribute/positional/type mutations, its
+     * `newPsets`/`newQsets` entries, and its own `mutationHistory` records).
+     * Without that purge, an entity that was created, edited, then deleted
+     * before export left a dangling reference: `StepExporter` derives its
+     * property/quantity work list from `getMutations()` (the append-only
+     * history) and reads `getForEntity()` / `getQuantitiesForEntity()` straight
+     * off `newPsets` / `newQsets` — neither of which the review-side
+     * `forgottenCreatedEntities` filter in `effective-changes.ts` touches. The
+     * review dialog looked clean while the exported file still contained an
+     * `IFCPROPERTYSET` + `IFCRELDEFINESBYPROPERTIES` pointing at an expressId
+     * that was never actually created (maintainer finding on #1967).
+     *
+     * The purged data is captured here, not discarded, because `restoreNewEntity`
+     * (undo of the delete) must bring it all back — rows AND count AND what the
+     * exporter would see — not just re-add the bare `NewEntity` record.
+     */
+    forgottenEntityOverlay = new Map();
     /**
      * Overlay-entity → source-entity aliases for property/quantity reads.
      *
@@ -143,6 +178,16 @@ export class MutablePropertyView {
     setQuantityExtractor(extractor) {
         this.quantityExtractor = extractor;
     }
+    /**
+     * Set the base entity-attribute extractor (Name, Description, ObjectType,
+     * Tag, ...), used only to resolve `previousValue` in `getEffectiveChanges()`.
+     * Without one, attribute `previousValue` falls back to whatever `oldValue`
+     * the overlay entry itself carries — which undo can leave stale/absent (see
+     * `getEffectiveChanges()` doc).
+     */
+    setAttributeExtractor(extractor) {
+        this.attributeExtractor = extractor;
+    }
     /**
      * Get base properties for an entity (before mutations)
      * Uses on-demand extraction if available, otherwise falls back to base table.
@@ -385,7 +430,23 @@ export class MutablePropertyView {
         if (oldValue === null && !inNewPset) {
             return null; // Property doesn't exist
         }
-        this.setPropertyMutation(entityId, key, { operation: 'DELETE' });
+        // A DELETE marker in `propertyMutations` only earns its keep when it is
+        // masking a value that genuinely exists in the base data — that's what
+        // `getForEntity`'s base-pset walk (and `collectPropertyChanges`) needs to
+        // skip. A purely in-session property (added via `setProperty`/
+        // `createPropertySet`, never in base) has nothing to mask: leaving a
+        // DELETE marker for it kept `collectModifiedEntityIds()` counting this
+        // entity as modified with zero effective rows to show for it (the same
+        // class of bug as the `newPsets` empty-map leak above, #1967 finding
+        // 2(b)) — so drop the mutation entry outright instead.
+        const basePsets = this.getBasePropertiesForEntity(entityId);
+        const propExistsInBase = basePsets.some(p => p.name === psetName && p.properties.some(prop => prop.name === propName));
+        if (propExistsInBase) {
+            this.setPropertyMutation(entityId, key, { operation: 'DELETE' });
+        }
+        else {
+            this.deletePropertyMutation(entityId, key);
+        }
         // Keep the verbatim newPsets read path (getForEntity / STEP export)
         // consistent with getPropertyValue when the prop lives in an in-session
         // pset: splice it out, and drop the pset if it becomes empty.
@@ -395,6 +456,14 @@ export class MutablePropertyView {
             newPset.properties = newPset.properties.filter(p => p.name !== propName);
             if (newPset.properties.length === 0) {
                 entityPsets.delete(psetName);
+                // An empty Map is still truthy, so leaving it in `newPsets` would keep
+                // `collectModifiedEntityIds()` / `hasChanges(entityId)` reporting this
+                // entity as modified with zero rows to show for it (maintainer finding
+                // 2(b) on #1967 — deleting the last property of an auto-created pset
+                // never cleared the entity out of `newPsets`).
+                if (entityPsets.size === 0) {
+                    this.newPsets.delete(entityId);
+                }
             }
         }
         const mutation = {
@@ -459,16 +528,41 @@ export class MutablePropertyView {
      * Delete an entire property set
      */
     deletePropertySet(entityId, psetName) {
-        this.deletedPsets.add(`${entityId}:${psetName}`);
         // Also remove from new psets if it was created in this session
         const entityPsets = this.newPsets.get(entityId);
-        if (entityPsets) {
+        const inSessionPset = entityPsets?.get(psetName);
+        if (entityPsets && inSessionPset) {
             entityPsets.delete(psetName);
+            // An empty Map is still truthy, so leaving it in `newPsets` would keep
+            // `collectModifiedEntityIds()` / `hasChanges(entityId)` reporting this
+            // entity as modified with zero rows to show for it (maintainer finding
+            // 2(b) on #1967 — the `newPsets` empty-map leak that also affects
+            // `deleteProperty`).
+            if (entityPsets.size === 0) {
+                this.newPsets.delete(entityId);
+            }
+            // The individual SET mutations `createPropertySet` recorded for this
+            // pset's properties have nothing to mask either — same argument as
+            // `deleteProperty`'s in-session branch below, applied to every
+            // property this in-session pset carried, so drop each entry outright
+            // instead of leaving it orphaned in `propertyMutations`.
+            for (const prop of inSessionPset.properties) {
+                const key = propertyKey(entityId, psetName, prop.name);
+                this.deletePropertyMutation(entityId, key);
+            }
         }
-        // Mark all properties as deleted
+        // A DELETE marker in `deletedPsets` only earns its keep when it is
+        // masking a pset that genuinely exists in the base data — same argument
+        // as `deleteProperty` one level down (see the comment above its own
+        // base-existence check): a purely in-session pset (added via
+        // `createPropertySet`, never in the base file) has nothing to mask, so
+        // dropping the pset above already nets to nothing and there is no
+        // deletion to report. Recording it as deleted here told the export
+        // review a pset would be removed when the net change was zero.
         const existingPsets = this.getBasePropertiesForEntity(entityId);
         const pset = existingPsets.find(p => p.name === psetName);
         if (pset) {
+            this.deletedPsets.add(`${entityId}:${psetName}`);
             for (const prop of pset.properties) {
                 const key = propertyKey(entityId, psetName, prop.name);
                 this.setPropertyMutation(entityId, key, { operation: 'DELETE' });
@@ -639,10 +733,28 @@ export class MutablePropertyView {
                 qset.quantities.push({ name: quantName, type: qType, value, unit });
             }
         }
-        // Get old value for undo and to determine CREATE vs UPDATE
+        // Get old value for undo and to determine CREATE vs UPDATE. An overlay
+        // mutation (a prior edit this session) wins; otherwise fall back to the
+        // base quantity's own value — `qsetExistsInBase` alone is not enough,
+        // since a *new* quantity name can be added to an already-existing qset.
+        // Without the base-value fallback, the first edit of an existing base
+        // quantity reported `oldValue: null` (UPDATE_QUANTITY with nothing to
+        // restore), which is exactly the null the viewer's undo handler treats
+        // as "nothing to revert to" — undo silently did nothing (#2297 shape).
         const existingMutation = this.quantityMutations.get(key);
-        const oldValue = existingMutation?.value ?? null;
-        const isUpdate = existingMutation != null || qsetExistsInBase;
+        let oldValue;
+        let isUpdate;
+        if (existingMutation) {
+            oldValue = existingMutation.value ?? null;
+            isUpdate = true;
+        }
+        else {
+            const baseQuantity = baseQsets
+                .find(q => q.name === qsetName)
+                ?.quantities.find(q => q.name === quantName);
+            oldValue = baseQuantity ? baseQuantity.value : null;
+            isUpdate = baseQuantity !== undefined;
+        }
         this.setQuantityMutation(entityId, key, {
             operation: 'SET',
             value,
@@ -892,7 +1004,21 @@ export class MutablePropertyView {
     deleteEntity(expressId) {
         if (this.newEntities.has(expressId)) {
             this.newEntities.delete(expressId);
+            // Both sets are needed: `tombstones` is what the unified isDeleted() /
+            // getEffectiveEntityIndex() answer from (#2036), while
+            // `forgottenCreatedEntities` is what collectEffectiveChanges()'s row
+            // filter uses to drop ALL rows for a created-then-deleted entity
+            // (create and delete cancel out) rather than keeping an entity-deleted
+            // row the way a tombstoned source entity does.
             this.tombstones.add(expressId);
+            this.forgottenCreatedEntities.add(expressId);
+            // Purge every other overlay trace of this entity — property/quantity/
+            // attribute/positional/type mutations, `newPsets`/`newQsets`, and this
+            // entity's own mutation-history records — BEFORE pushing the
+            // DELETE_ENTITY record below, so that record is the only history entry
+            // left for this id. See `forgottenEntityOverlay`'s doc for why this is
+            // a stash-and-remove rather than an outright discard.
+            this.stashAndPurgeEntityOverlay(expressId);
             this.mutationHistory.push({
                 id: generateMutationId(),
                 type: 'DELETE_ENTITY',
@@ -974,16 +1100,162 @@ export class MutablePropertyView {
      */
     restoreNewEntity(entity) {
         this.newEntities.set(entity.expressId, entity);
-        // `deleteEntity` tombstones an overlay-created entity as well as forgetting
-        // it, so the inverse has to lift the tombstone — otherwise the restored
-        // record is live in `newEntities` and still deleted according to
-        // `isDeleted`, and the export drops it again.
+        // `deleteEntity` both tombstones an overlay-created entity (for the
+        // unified isDeleted() / getEffectiveEntityIndex() answer) and forgets it
+        // (for collectEffectiveChanges()'s row filter), so the inverse has to
+        // clear both — otherwise the restored record is either still "deleted"
+        // per isDeleted() (stale tombstone) or still invisible to the review
+        // diff (stale forgotten-entity mark).
         this.tombstones.delete(entity.expressId);
+        this.forgottenCreatedEntities.delete(entity.expressId);
         // Without this the next createEntity() can hand out the same id and
         // overwrite the restored entity.
         if (entity.expressId > this.nextAllocatedId) {
             this.nextAllocatedId = entity.expressId;
         }
+        // Bring back whatever `deleteEntity` purged (property/quantity/attribute
+        // mutations, newPsets/newQsets, history) — a no-op if this entity was
+        // never forgotten (e.g. a plain create with nothing purged).
+        this.unstashEntityOverlay(entity.expressId);
+    }
+    /**
+     * Move every current overlay entry for `expressId` out of the live maps
+     * and into `forgottenEntityOverlay`, and drop this entity's own records
+     * from `mutationHistory`. Called by `deleteEntity` when it forgets a
+     * created entity. Only stashes a key if something was actually captured,
+     * so `unstashEntityOverlay` on a plain (never-edited) create is a no-op.
+     */
+    stashAndPurgeEntityOverlay(expressId) {
+        const stash = {
+            propertyEntries: [],
+            quantityEntries: [],
+            attributeEntries: [],
+            positionalAttrs: null,
+            typeMutation: null,
+            newPsets: null,
+            newQsets: null,
+            deletedPsetKeys: [],
+            deletedQsetKeys: [],
+            historyEntries: [],
+        };
+        for (const key of Array.from(this.propertyKeysByEntity.get(expressId) ?? [])) {
+            const mutation = this.propertyMutations.get(key);
+            if (mutation)
+                stash.propertyEntries.push([key, mutation]);
+            this.deletePropertyMutation(expressId, key);
+        }
+        for (const key of Array.from(this.quantityKeysByEntity.get(expressId) ?? [])) {
+            const mutation = this.quantityMutations.get(key);
+            if (mutation)
+                stash.quantityEntries.push([key, mutation]);
+            this.deleteQuantityMutation(expressId, key);
+        }
+        for (const key of Array.from(this.attributeKeysByEntity.get(expressId) ?? [])) {
+            const mutation = this.attributeMutations.get(key);
+            if (mutation)
+                stash.attributeEntries.push([key, mutation]);
+            this.deleteAttributeMutation(expressId, key);
+        }
+        const positional = this.positionalAttrMutations.get(expressId);
+        if (positional) {
+            stash.positionalAttrs = new Map(positional);
+            this.positionalAttrMutations.delete(expressId);
+        }
+        const typeMutation = this.typeMutations.get(expressId);
+        if (typeMutation) {
+            stash.typeMutation = typeMutation;
+            this.typeMutations.delete(expressId);
+        }
+        const psets = this.newPsets.get(expressId);
+        if (psets) {
+            stash.newPsets = new Map(psets);
+            this.newPsets.delete(expressId);
+        }
+        const qsets = this.newQsets.get(expressId);
+        if (qsets) {
+            stash.newQsets = new Map(qsets);
+            this.newQsets.delete(expressId);
+        }
+        const psetPrefix = `${expressId}:`;
+        for (const key of Array.from(this.deletedPsets)) {
+            if (!key.startsWith(psetPrefix))
+                continue;
+            stash.deletedPsetKeys.push(key);
+            this.deletedPsets.delete(key);
+        }
+        for (const key of Array.from(this.deletedQsets)) {
+            if (!key.startsWith(psetPrefix))
+                continue;
+            stash.deletedQsetKeys.push(key);
+            this.deletedQsets.delete(key);
+        }
+        const keptHistory = [];
+        for (const mutation of this.mutationHistory) {
+            if (mutation.entityId === expressId) {
+                stash.historyEntries.push(mutation);
+            }
+            else {
+                keptHistory.push(mutation);
+            }
+        }
+        this.mutationHistory = keptHistory;
+        const hasStashedData = stash.propertyEntries.length > 0 ||
+            stash.quantityEntries.length > 0 ||
+            stash.attributeEntries.length > 0 ||
+            stash.positionalAttrs !== null ||
+            stash.typeMutation !== null ||
+            stash.newPsets !== null ||
+            stash.newQsets !== null ||
+            stash.deletedPsetKeys.length > 0 ||
+            stash.deletedQsetKeys.length > 0 ||
+            stash.historyEntries.length > 0;
+        if (hasStashedData) {
+            this.forgottenEntityOverlay.set(expressId, stash);
+        }
+    }
+    /**
+     * Reverse `stashAndPurgeEntityOverlay`: put everything `deleteEntity`
+     * purged back into the live overlay maps. Called by `restoreNewEntity`.
+     * A no-op if nothing was stashed for `expressId`.
+     */
+    unstashEntityOverlay(expressId) {
+        const stash = this.forgottenEntityOverlay.get(expressId);
+        if (!stash)
+            return;
+        this.forgottenEntityOverlay.delete(expressId);
+        for (const [key, mutation] of stash.propertyEntries)
+            this.setPropertyMutation(expressId, key, mutation);
+        for (const [key, mutation] of stash.quantityEntries)
+            this.setQuantityMutation(expressId, key, mutation);
+        for (const [key, mutation] of stash.attributeEntries)
+            this.setAttributeMutation(expressId, key, mutation);
+        if (stash.positionalAttrs)
+            this.positionalAttrMutations.set(expressId, stash.positionalAttrs);
+        if (stash.typeMutation)
+            this.typeMutations.set(expressId, stash.typeMutation);
+        if (stash.newPsets)
+            this.newPsets.set(expressId, stash.newPsets);
+        if (stash.newQsets)
+            this.newQsets.set(expressId, stash.newQsets);
+        for (const key of stash.deletedPsetKeys)
+            this.deletedPsets.add(key);
+        for (const key of stash.deletedQsetKeys)
+            this.deletedQsets.add(key);
+        // The DELETE_ENTITY `deleteEntity` pushed AFTER the purge (so it would be
+        // the only history entry left for this id) is superseded by this
+        // restore — same reasoning `forgottenCreatedEntities` already applies to
+        // collectEffectiveChanges()'s row filter one layer down: a create and
+        // its delete cancel, they don't survive as a create followed by a delete.
+        // Re-appending the stashed CREATE_ENTITY/CREATE_PROPERTY records BEHIND
+        // that DELETE_ENTITY (the old bug) reordered mutationHistory to
+        // DELETE_ENTITY,CREATE_ENTITY,..., which defeats applyMutations()'s
+        // skippedCreateIds guard (#2036) on replay: the DELETE_ENTITY is seen
+        // before the CREATE_ENTITY it should pair with, so it tombstones an id
+        // that was never really deleted — silent data loss through
+        // exportMutations()/importMutations() on a published package.
+        this.mutationHistory = this.mutationHistory.filter(m => !(m.entityId === expressId && m.type === 'DELETE_ENTITY'));
+        if (stash.historyEntries.length > 0)
+            this.mutationHistory.push(...stash.historyEntries);
     }
     /**
      * Every express id this session deleted — source-buffer entities AND ones it
@@ -1044,6 +1316,12 @@ export class MutablePropertyView {
                     qset.quantities = qset.quantities.filter(q => q.name !== quantName);
                     if (qset.quantities.length === 0) {
                         entityQsets.delete(qsetName);
+                        // Same empty-Map trap as `deleteProperty`/`newPsets` (#1967
+                        // finding 2(b)) — an empty Map is still truthy, so leave no
+                        // trace of this entity in `newQsets` once its last qset is gone.
+                        if (entityQsets.size === 0) {
+                            this.newQsets.delete(entityId);
+                        }
                     }
                 }
             }
@@ -1053,6 +1331,9 @@ export class MutablePropertyView {
             const entityQsets = this.newQsets.get(entityId);
             if (entityQsets) {
                 entityQsets.delete(qsetName);
+                if (entityQsets.size === 0) {
+                    this.newQsets.delete(entityId);
+                }
             }
             // Remove all quantity mutations for this qset (only those for this entity).
             const bucket = this.quantityKeysByEntity.get(entityId);
@@ -1088,13 +1369,70 @@ export class MutablePropertyView {
         return this.mutationHistory.filter(m => m.entityId === entityId);
     }
     /**
-     * Check if an entity has any mutations
+     * Check if an entity currently carries an overlay change.
+     *
+     * Reads the live overlay (same footprint as {@link hasPendingChanges}),
+     * NOT the append-only `mutationHistory` — undo does not pop history (see
+     * `getMutations()`), so a history-based check could report `true` for an
+     * entity whose edit was fully undone. Called with no `entityId`, this is
+     * exactly {@link hasPendingChanges}.
+     *
+     * Unlike {@link getModifiedEntityCount} (derived from
+     * {@link getEffectiveChanges} so it can't diverge), this is a direct
+     * per-entity map lookup kept O(1)-ish for callers that probe many entities
+     * (e.g. a per-row "has changes" indicator) — re-deriving effective changes
+     * per call would be O(overlay size) each time. That means it can still
+     * report `true` for an entity whose only overlay entry is a no-op edit
+     * (undo landed it back at the base value, so `previousValue === newValue`
+     * — see {@link getEffectiveChanges}'s doc). Over-reporting here is the same
+     * safe direction {@link hasPendingChanges} already documents; nothing in
+     * this repo reads this per-entity form in production as of #1967.
      */
     hasChanges(entityId) {
-        if (entityId !== undefined) {
-            return this.mutationHistory.some(m => m.entityId === entityId);
+        if (entityId === undefined) {
+            return this.hasPendingChanges();
+        }
+        // A create->delete entity is forgotten, not tombstoned (see `deleteEntity`),
+        // so any other per-entity map entries it left behind (attribute/property/
+        // quantity edits made before the delete) are orphaned — they belong to an
+        // entity that will never be exported. `getEffectiveChanges()` already drops
+        // every row for these ids with no exception; this must agree (issue: the
+        // #1915 forgotten-created blind spot). `restoreNewEntity` removes the id
+        // from this set, so a restored entity falls through to the checks below
+        // exactly as before.
+        if (this.forgottenCreatedEntities.has(entityId))
+            return false;
+        if (this.propertyKeysByEntity.has(entityId))
+            return true;
+        if (this.quantityKeysByEntity.has(entityId))
+            return true;
+        if (this.positionalAttrMutations.has(entityId))
+            return true;
+        if (this.typeMutations.has(entityId))
+            return true;
+        if (this.newPsets.has(entityId))
+            return true;
+        if (this.newQsets.has(entityId))
+            return true;
+        if (this.newEntities.has(entityId))
+            return true;
+        if (this.tombstones.has(entityId))
+            return true;
+        const attrPrefix = `${entityId}:attr:`;
+        for (const key of this.attributeMutations.keys()) {
+            if (key.startsWith(attrPrefix))
+                return true;
+        }
+        const setPrefix = `${entityId}:`;
+        for (const key of this.deletedPsets) {
+            if (key.startsWith(setPrefix))
+                return true;
         }
-        return this.mutationHistory.length > 0;
+        for (const key of this.deletedQsets) {
+            if (key.startsWith(setPrefix))
+                return true;
+        }
+        return false;
     }
     /**
      * True when the overlay currently carries anything the STEP exporter would
@@ -1125,14 +1463,72 @@ export class MutablePropertyView {
             this.tombstones.size > 0);
     }
     /**
-     * Get count of modified entities
+     * Get count of modified entities.
+     *
+     * Reads the live overlay, NOT `mutationHistory` (issue #1915): undo does
+     * not pop history, so a history-based count could over-report — e.g. after
+     * `setAttribute` + `removeAttributeMutation` (exactly what undoing a
+     * freshly-created attribute mutation does), the overlay is empty again but
+     * history still holds the one entry. This must agree with
+     * {@link hasPendingChanges}: zero here iff that is `false`.
+     *
+     * Must also agree with {@link getEffectiveChanges} — an entity contributing
+     * zero effective rows (a create -> edit -> delete `deleteEntity` forgot, or
+     * an edit fully undone back to its base value) must not be counted here
+     * either. `collectModifiedEntityIds` is deliberately DERIVED FROM
+     * `getEffectiveChanges()` rather than hand-walking the overlay maps a
+     * second time, so the two structurally cannot diverge again (issue: the
+     * #1915 forgotten-created blind spot, and the #1967 no-op-edit blind spot
+     * that a second hand-rolled walk reintroduced).
      */
     getModifiedEntityCount() {
-        const entities = new Set();
-        for (const mutation of this.mutationHistory) {
-            entities.add(mutation.entityId);
-        }
-        return entities.size;
+        return this.collectModifiedEntityIds().size;
+    }
+    /** Distinct entity ids with at least one row in {@link getEffectiveChanges}. */
+    collectModifiedEntityIds() {
+        const ids = new Set();
+        for (const change of this.getEffectiveChanges())
+            ids.add(change.entityId);
+        return ids;
+    }
+    /**
+     * Enumerate every change the overlay currently carries, as it stands right
+     * now — never from `mutationHistory` (see {@link getModifiedEntityCount}).
+     * This is what the export-review UI (issue #1915) and any snapshot test
+     * should read: `previousValue` is derived from the base data (property
+     * table / on-demand extractor / attribute extractor), so an undo→redo
+     * cycle reports the true original, not a stale history entry.
+     *
+     * Whole-pset/qset deletes and creates are reported as a single
+     * `pset-added` / `pset-deleted` / `qset-added` / `qset-deleted` row rather
+     * than one row per property/quantity inside them (deletePropertySet /
+     * createPropertySet also populate individual property/quantity mutations
+     * internally — those are intentionally not double-reported here).
+     *
+     * Deterministic ordering: entityId, then kind, then name, then setName.
+     */
+    getEffectiveChanges() {
+        return collectEffectiveChanges({
+            attributeMutations: this.attributeMutations,
+            positionalAttrMutations: this.positionalAttrMutations,
+            typeMutations: this.typeMutations,
+            newPsets: this.newPsets,
+            deletedPsets: this.deletedPsets,
+            newQsets: this.newQsets,
+            deletedQsets: this.deletedQsets,
+            propertyKeysByEntity: this.propertyKeysByEntity,
+            propertyMutations: this.propertyMutations,
+            quantityKeysByEntity: this.quantityKeysByEntity,
+            quantityMutations: this.quantityMutations,
+            newEntities: this.newEntities,
+            tombstones: this.tombstones,
+            forgottenCreatedEntities: this.forgottenCreatedEntities,
+        }, {
+            attributeExtractor: this.attributeExtractor,
+            resolveBaseEntityId: (entityId) => this.resolveBaseEntityId(entityId),
+            getBasePropertiesForEntity: (entityId) => this.getBasePropertiesForEntity(entityId),
+            getBaseQuantitiesForEntity: (entityId) => this.getBaseQuantitiesForEntity(entityId),
+        });
     }
     /**
      * Clear all mutations (reset to base state)
@@ -1152,6 +1548,8 @@ export class MutablePropertyView {
         this.typeMutations.clear();
         this.newEntities.clear();
         this.tombstones.clear();
+        this.forgottenCreatedEntities.clear();
+        this.forgottenEntityOverlay.clear();
         this.entityAliases.clear();
         this.nextAllocatedId = 0;
         this.mutationHistory = [];
@@ -1166,8 +1564,46 @@ export class MutablePropertyView {
         // entity that never made it into this view — that stale tombstone
         // would later suppress a freshly-allocated overlay entity reusing
         // the same expressId.
+        // Pass 1: collect every CREATE_ENTITY id up front, over the whole
+        // array, before applying anything. CREATE_ENTITY is unconditionally
+        // skipped below (every id it's called for lands here) — but a caller
+        // supplying an arbitrary (e.g. imported/merged) Mutation[] may not have
+        // its CREATE_ENTITY appear before the mutations that depend on it. A
+        // single incremental forward pass would only "see" a create once the
+        // loop reaches it, so a dependent mutation earlier in the array would
+        // replay before its own entity's creation was known to be skipped —
+        // reproducing the orphaned-pset bug via ordering instead of via the
+        // original bug shape. Doing the full collection first makes the result
+        // order-independent.
         const skippedCreateIds = new Set();
         for (const mutation of mutations) {
+            if (mutation.type === 'CREATE_ENTITY') {
+                skippedCreateIds.add(mutation.entityId);
+            }
+        }
+        // Pass 2: apply mutations against the now-complete skip set.
+        for (const mutation of mutations) {
+            // Any mutation recorded against an entity whose own CREATE_ENTITY was
+            // skipped above would otherwise replay into an orphan — a pset (or
+            // attribute/quantity/type edit) keyed to an expressId that exists in
+            // neither the source buffer nor `newEntities`. Refuse those too, so
+            // the round trip is lossy (entity + its edits both dropped) rather
+            // than corrupting (edits surviving without their entity). This keys
+            // off `skippedCreateIds`, not "id absent from newEntities", so a
+            // mutation against a normal, pre-existing source-buffer entity is
+            // never affected — only ids that had their own CREATE_ENTITY skipped
+            // in this same batch land here.
+            // The `newEntities` check makes the condition "the create was skipped
+            // AND nothing else supplied the entity". A caller following the
+            // documented recovery flow calls `restoreNewEntity()` first and
+            // *then* replays the history; the id is live by the time we get here,
+            // so there is no orphan to guard against and dropping its edits would
+            // silently lose data on the exact path the console.warn recommends.
+            if (mutation.type !== 'CREATE_ENTITY' &&
+                skippedCreateIds.has(mutation.entityId) &&
+                !this.newEntities.has(mutation.entityId)) {
+                continue;
+            }
             switch (mutation.type) {
                 case 'CREATE_PROPERTY':
                 case 'UPDATE_PROPERTY':
@@ -1190,6 +1626,22 @@ export class MutablePropertyView {
                     if (mutation.psetName && mutation.propName && mutation.newValue !== undefined) {
                         this.setQuantity(mutation.entityId, mutation.psetName, mutation.propName, Number(mutation.newValue), mutation.quantityType ?? QuantityType.Count, mutation.unit);
                     }
+                    else if (mutation.type === 'CREATE_QUANTITY' &&
+                        mutation.psetName &&
+                        Array.isArray(mutation.newValue)) {
+                        // `createQuantitySet()` (whole-qset creation, e.g.
+                        // `StoreEditor.addQuantitySet`) records ONE CREATE_QUANTITY mutation
+                        // for the whole set — no `propName`, `newValue` is the full
+                        // quantities array — unlike `setQuantity()`'s per-quantity
+                        // CREATE_QUANTITY, which always carries both. Mirrors the
+                        // CREATE_PROPERTY_SET handling below. Without this branch the
+                        // `psetName && propName` check above is false and the record
+                        // matched this `case` with nothing done — never falling through to
+                        // the "unhandled mutation type" warning either — so a freshly
+                        // created quantity set silently vanished on
+                        // exportMutations()/importMutations() round trip.
+                        this.createQuantitySet(mutation.entityId, mutation.psetName, mutation.newValue);
+                    }
                     break;
                 case 'UPDATE_POSITIONAL_ATTRIBUTE': {
                     // attributeName is `@<index>` for positional mutations.
@@ -1229,15 +1681,19 @@ export class MutablePropertyView {
                     // doesn't carry the type+attributes payload — applying a bare
                     // CREATE_ENTITY would lose the entity. We log and skip rather
                     // than silently dropping it, so callers see they need to
-                    // restore the payload through the dedicated path.
-                    skippedCreateIds.add(mutation.entityId);
+                    // restore the payload through the dedicated path. Unless the
+                    // caller already restored it, every other mutation recorded
+                    // against this id in this batch is dropped too (see the guard
+                    // above this switch) — otherwise the entity is gone but its edits
+                    // survive as an orphan. (skippedCreateIds was already fully
+                    // populated in pass 1, above.)
                     // eslint-disable-next-line no-console
-                    console.warn(`applyMutations: CREATE_ENTITY for #${mutation.entityId} requires a NewEntity payload — restore via restoreNewEntity()`);
+                    console.warn(`applyMutations: CREATE_ENTITY for #${mutation.entityId} requires a NewEntity payload — ` +
+                        `restore via restoreNewEntity(). Skipping the record; dependent mutations recorded against ` +
+                        `#${mutation.entityId} are dropped too unless the entity was restored before this call.`);
                     break;
                 }
                 case 'DELETE_ENTITY':
-                    if (skippedCreateIds.has(mutation.entityId))
-                        break;
                     this.deleteEntity(mutation.entityId);
                     break;
                 default:
@@ -1250,7 +1706,9 @@ export class MutablePropertyView {
         }
     }
     /**
-     * Export mutations as JSON
+     * Export mutations as JSON. Includes every record in `mutationHistory`,
+     * including `CREATE_ENTITY` — but see `importMutations` for why replaying
+     * that record on another view does not reconstruct the entity.
      */
     exportMutations() {
         return JSON.stringify({
@@ -1260,7 +1718,23 @@ export class MutablePropertyView {
         }, null, 2);
     }
     /**
-     * Import mutations from JSON
+     * Import mutations from JSON produced by `exportMutations`.
+     *
+     * **Not a full inverse of `exportMutations`.** A `CREATE_ENTITY` record
+     * carries only the expressId in the history — not the entity's type and
+     * attributes — so `importMutations` cannot rebuild the entity from the
+     * record alone: it logs a `console.warn` and skips the record, and drops
+     * every other mutation recorded against that same entity id in the same
+     * batch too (so the round trip is lossy — entity and edits both dropped —
+     * rather than leaving an orphaned property/attribute/quantity keyed to an
+     * id that was never created on the receiving view).
+     *
+     * To carry an overlay-created entity across, call `restoreNewEntity()`
+     * with its `NewEntity` payload (from `getNewEntity`/`getNewEntities` on
+     * the source view) **before** calling `importMutations`. Once the id is
+     * live in `newEntities`, its dependent mutations replay normally — only
+     * the `console.warn` for the (now redundant) `CREATE_ENTITY` record still
+     * fires.
      */
     importMutations(json) {
         const data = JSON.parse(json);