@ifc-lite/mutations 1.22.0 → 1.24.0

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' });
@@ -870,13 +964,43 @@ export class MutablePropertyView {
         return entity;
     }
     /**
-     * Mark an entity for deletion. Existing entities are tombstoned; new
-     * entities (from `createEntity`) are simply forgotten. Returns false if
-     * the id is unknown to this view.
+     * Mark an entity for deletion. Returns false if the id is unknown to this
+     * view, or was already tombstoned.
+     *
+     * An overlay-created entity is dropped from `newEntities` — so it is emitted
+     * nowhere, which is the right answer for something created and deleted in one
+     * session — AND tombstoned, so `isDeleted` tells the truth about it.
+     *
+     * It used to be only forgotten, and that made `isDeleted` lie: every guard
+     * that asks "was this deleted" got `false` for an entity that no longer
+     * exists, so the export still emitted the `IFCRELDEFINESBYPROPERTIES` for a
+     * pset queued on it, dangling at a record nothing wrote (#2012). Forgetting
+     * without tombstoning cannot be made safe one guard at a time, because the
+     * question the guards ask has no true answer to find.
+     *
+     * Consumers that count entities must therefore intersect tombstones with the
+     * source store rather than subtracting `tombstones.size` wholesale — a
+     * created-then-deleted id is absent from BOTH the store and `getNewEntities`,
+     * so counting it as a deletion would subtract it twice.
      */
     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',
@@ -958,12 +1082,169 @@ export class MutablePropertyView {
      */
     restoreNewEntity(entity) {
         this.newEntities.set(entity.expressId, entity);
+        // `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
+     * created and then deleted. The two are not distinguishable from this set
+     * alone; a caller that needs to tell them apart intersects it with the store's
+     * own index (see `deleteEntity`).
+     */
     getTombstones() {
         return new Set(this.tombstones);
     }
@@ -1017,6 +1298,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);
+                        }
                     }
                 }
             }
@@ -1026,6 +1313,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);
@@ -1061,13 +1351,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;
+        }
+        for (const key of this.deletedQsets) {
+            if (key.startsWith(setPrefix))
+                return true;
         }
-        return this.mutationHistory.length > 0;
+        return false;
     }
     /**
      * True when the overlay currently carries anything the STEP exporter would
@@ -1098,14 +1445,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)
@@ -1125,6 +1530,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 = [];