@ifc-lite/export 2.7.0 → 2.8.0

package/dist/step-exporter.js

@@ -1,16 +1,21 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-import { EntityExtractor, generateHeader, parseSourceHeader, getAttributeNames, serializeValue, ref, } from '@ifc-lite/parser';
+import { EntityExtractor, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
 import { safeUtf8Decode } from '@ifc-lite/data';
 import { generateIfcGuid } from '@ifc-lite/encoding';
 import { collectReferencedEntityIds, getVisibleEntityIds, collectStyleEntities } from './reference-collector.js';
 import { convertStepLine, needsConversion } from './schema-converter.js';
 import { retypeStepLine, retypeArgTokens } from './retype.js';
 import { getCompleteEntityIndex, getMaxExpressId } from './entity-iteration.js';
+import { authoredEntityRefs, getEffectiveEntityIndex } from './effective-index.js';
+import { HAS_PROPERTY_SETS_SLOT, hasPropertySetsToken, isTypeClass, resolveTypeOwnedPsetIds, } from './type-owned-psets.js';
 import { escapeStepString, toStepReal, quantityTypeToIfcType, serializePropertyValue, serializeAttributeValue, serializeStepValue, tokenIsRealLiteral, splitTopLevelArgs, splitTopLevelStepArguments, assembleStepBytes, } from './step-serialization.js';
 import { getRealTypedSlots, serializeEntityArgs, serializeAttributeSlot, isTypedMarker } from './attribute-real-slots.js';
+import { getEnumTypedSlots, getStringTypedSlots, serializeEnumToken, serializeStringSlot, } from './attribute-slot-types.js';
 import { serializeQualifiedSelectSlot } from './select-qualification.js';
+/** `OwnerHistory` is slot 1 on every `IfcRoot` subtype, all schemas. */
+const OWNER_HISTORY_SLOT = 1;
 /**
  * IFC STEP file exporter
  */
@@ -41,6 +46,12 @@ export class StepExporter {
         const entities = [];
         let newEntityCount = 0;
         let modifiedEntityCount = 0;
+        // Both owner-history caches are per-EXPORT, not per-exporter: they now
+        // depend on `willBeEmitted`, which depends on this call's options. Reusing
+        // one exporter for a `visibleOnly` export and then a full one would
+        // otherwise answer the second from the first one's closure.
+        this.ownerHistoryFallbackRef = undefined;
+        this.ownerHistoryByEntity.clear();
         // Determine target schema from options, source schema from data store
         const schema = options.schema || this.dataStore.schemaVersion || 'IFC4';
         const sourceSchema = this.dataStore.schemaVersion || 'IFC4';
@@ -95,6 +106,15 @@ export class StepExporter {
                 timeStamp: options.timeStamp,
             });
         };
+        // The one authority for exists / class / deleted, overlay first and source
+        // buffer second. Every pass below asks this instead of `this.dataStore`,
+        // which answers only for the file as parsed (#2012).
+        const effective = getEffectiveEntityIndex(this.dataStore, this.mutationView, options.applyMutations !== false);
+        // Does this id belong to an entity the OVERLAY created (`createEntity` /
+        // `store.addEntity`) rather than to a record in the source buffer? Such an
+        // entity has no source bytes, so the source-iteration pass below never sees
+        // it and the new-entities pass at the end owns its line entirely (#2006).
+        const isOverlayCreated = (entityId) => effective.isOverlayCreated(entityId);
         // Collect entities that need to be modified or created
         const modifiedEntities = new Set();
         const modifiedPsets = new Map(); // entityId -> psetNames being modified
@@ -105,24 +125,43 @@ export class StepExporter {
         const typeOwnedPsetIdsByEntity = new Map();
         const rewrittenEntityIds = new Set();
         const rewrittenEntityLines = new Map();
+        /** HasPropertySets slot value for an OVERLAY-CREATED type object, applied
+         *  by the new-entities pass (there is no source line to rewrite). */
+        const overlayTypeOwnedPsets = new Map();
         // Track property set IDs and relationship IDs to skip
         const skipPropertySetIds = new Set();
         const skipRelationshipIds = new Set();
+        const overlayActive = !!this.mutationView && (options.applyMutations !== false);
         // Process mutations if we have a mutation view
         if (this.mutationView && (options.applyMutations !== false)) {
             const mutations = this.mutationView.getMutations();
+            // Attribute values come from the *overlay*, never from the mutation
+            // history. The history is append-only and undo writes its reverse edit
+            // with `skipHistory: true`, so a superseded UPDATE_ATTRIBUTE record keeps
+            // its stale `newValue` forever — replaying it resurrects edits the user
+            // undid (#1957). The overlay is what the editor shows, and it is already
+            // the source for psets, quantities, positional attributes and retypes
+            // below, so attributes were the sole outlier.
+            for (const [entityId, attrs] of this.mutationView.getAttributeMutationsByEntity()) {
+                modifiedEntities.add(entityId);
+                let target = modifiedAttributes.get(entityId);
+                if (!target) {
+                    target = new Map();
+                    modifiedAttributes.set(entityId, target);
+                }
+                for (const [name, value] of attrs)
+                    target.set(name, value);
+            }
             // Group mutations by entity, separating property vs quantity mutations
             const entityPropMutations = new Map();
             const entityQuantMutations = new Map();
             for (const mutation of mutations) {
-                if (mutation.type === 'UPDATE_ATTRIBUTE' && mutation.attributeName) {
-                    modifiedEntities.add(mutation.entityId);
-                    if (!modifiedAttributes.has(mutation.entityId)) {
-                        modifiedAttributes.set(mutation.entityId, new Map());
-                    }
-                    modifiedAttributes.get(mutation.entityId).set(mutation.attributeName, mutation.newValue == null ? '' : String(mutation.newValue));
+                // Handled above, off the overlay. Skipped explicitly because an
+                // UPDATE_ATTRIBUTE record can also carry a `psetName` (georef fields
+                // encode their target entity there) and must not be mistaken for a
+                // property-set edit.
+                if (mutation.type === 'UPDATE_ATTRIBUTE')
                     continue;
-                }
                 if (!mutation.psetName)
                     continue;
                 const isQuantity = mutation.type === 'CREATE_QUANTITY' || mutation.type === 'UPDATE_QUANTITY' || mutation.type === 'DELETE_QUANTITY';
@@ -137,12 +176,48 @@ export class StepExporter {
             // below previously walked every entity in `entityIndex.byId` per
             // modified entity (O(E·N)); the index keeps the per-entity step
             // O(K) where K is the number of rels referencing that entity.
-            const relDefinesByEntity = this.buildRelDefinesByPropertiesIndex();
+            const { byEntity: relDefinesByEntity, relatedByRel } = this.buildRelDefinesByPropertiesIndex();
+            // A source IfcRelDefinesByProperties whose EVERY related object the
+            // session deleted has nothing left to relate, and emitting it leaves a
+            // `#id` pointing at a record the export skipped. Dropped only when all of
+            // them are gone: a rel that still names a live entity is that entity's
+            // only link to its psets, and nothing here rewrites a RelatedObjects list.
+            for (const [relId, related] of relatedByRel) {
+                if (related.length > 0 && related.every((id) => effective.isDeleted(id))) {
+                    skipRelationshipIds.add(relId);
+                }
+            }
             // Collect modified property sets and find original psets to skip
             for (const [entityId, psetNames] of entityPropMutations) {
+                // A deleted entity must not cause the exporter to REMOVE anything.
+                //
+                // This is the other half of the dangling-reference class, and the half
+                // `willBeEmitted` cannot reach: that predicate guards what gets ADDED,
+                // and this loop's real work is deciding what gets SKIPPED. An edited
+                // pset is replaced wholesale, so its original id goes into
+                // `skipPropertySetIds` — but IFC exporters share one IfcPropertySet
+                // between entities, and once the host is deleted there is no
+                // replacement to take its place. The surviving entity's relation then
+                // points at a container nobody wrote. Verified against main at
+                // e6516991 (#2030's own merge): edit `Pset_WallCommon` on one of two
+                // walls sharing it, delete that wall, and the export drops #11 while
+                // #12 still names it. `retainSharedAtoms` rescues a shared ATOM one
+                // level down; nothing rescues the shared container.
+                //
+                // Leaving the pset alone makes it an orphan when nothing else
+                // references it, which is valid IFC. Its relation is dropped by the
+                // sweep above, which handles a plain delete too — no pset edit needed.
+                if (effective.isDeleted(entityId))
+                    continue;
                 modifiedEntities.add(entityId);
                 modifiedPsets.set(entityId, psetNames);
-                modifiedEntityCount++;
+                // Same rule as the attribute loop below: an overlay-CREATED entity is
+                // emitted once, by the new-entities pass, and already counted in
+                // `newEntityCount` — as are the pset entities this loop goes on to
+                // generate. Only the COUNT is guarded; the entity still records its
+                // pset edits and still emits them.
+                if (!isOverlayCreated(entityId))
+                    modifiedEntityCount++;
                 // Get the FULL mutated property sets for this entity (merged base + mutations)
                 const allPsets = this.mutationView.getForEntity(entityId);
                 const relevantPsets = allPsets.filter((pset) => psetNames.has(pset.name));
@@ -171,8 +246,8 @@ export class StepExporter {
                         }
                     }
                 }
-                if (this.isTypeEntity(entityId)) {
-                    const typeOwnedPsetIds = this.getTypeOwnedHasPropertySetIds(entityId);
+                if (isTypeClass(effective.typeOf(entityId))) {
+                    const typeOwnedPsetIds = this.getTypeOwnedHasPropertySetIds(entityId, effective);
                     const typeOwnedAffected = new Set();
                     for (const psetId of typeOwnedPsetIds) {
                         const psetName = this.getPropertySetName(psetId);
@@ -201,8 +276,13 @@ export class StepExporter {
             if (options.includeQuantities === false)
                 entityQuantMutations.clear();
             for (const [entityId, qsetNames] of entityQuantMutations) {
+                // Same rule as the property loop above: a deleted entity removes nothing.
+                if (effective.isDeleted(entityId))
+                    continue;
                 modifiedEntities.add(entityId);
-                if (!modifiedPsets.has(entityId))
+                // See the property loop above — an overlay-created entity is counted as
+                // new, not modified.
+                if (!isOverlayCreated(entityId) && !modifiedPsets.has(entityId))
                     modifiedEntityCount++;
                 const allQsets = this.mutationView.getQuantitiesForEntity(entityId);
                 const relevantQsets = allQsets.filter((qset) => qsetNames.has(qset.name));
@@ -227,6 +307,12 @@ export class StepExporter {
                 }
             }
             for (const [entityId] of modifiedAttributes) {
+                // An overlay-CREATED entity carrying attribute edits is emitted once,
+                // by the new-entities pass, and already counted in `newEntityCount`.
+                // Counting it here too made the header claim two affected entities for
+                // one created-then-renamed wall.
+                if (isOverlayCreated(entityId))
+                    continue;
                 if (!entityPropMutations.has(entityId) && !entityQuantMutations.has(entityId)) {
                     modifiedEntityCount++;
                 }
@@ -397,20 +483,65 @@ export class StepExporter {
                 },
             };
         }
-        // Complete view over byId + any deferred property atoms. Walking byId alone
-        // drops deferred atoms while keeping the IfcPropertySet/IfcElementQuantity
-        // references to them, producing dangling #-refs in the output.
-        const completeIndex = getCompleteEntityIndex(this.dataStore);
-        // Build visible-only closure if requested
+        // Build visible-only closure if requested. Classification, the closure walk
+        // and the style pass all run over the EFFECTIVE index: an overlay-created
+        // product becomes a root by the same type rules as a parsed one, the walk
+        // follows its authored references into the geometry it alone owns, and a
+        // tombstoned entity is simply not there. Run over the source buffer, a
+        // created wall could never be a root and nothing referenced it, so
+        // `visibleOnly` wrote a file without it and said nothing (#2012).
         let allowedEntityIds = null;
         if (options.visibleOnly && this.dataStore.source) {
-            const { roots, hiddenProductIds } = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null);
-            allowedEntityIds = collectReferencedEntityIds(roots, this.dataStore.source, completeIndex, hiddenProductIds);
+            const { roots, hiddenProductIds } = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, effective);
+            allowedEntityIds = collectReferencedEntityIds(roots, this.dataStore.source, effective, hiddenProductIds);
             // Second pass: collect IFCSTYLEDITEM entities that reference included
             // geometry. Styled items reference geometry items but nothing references
             // them back, so the forward closure misses them.
-            collectStyleEntities(allowedEntityIds, this.dataStore.source, { byId: completeIndex, byType: this.dataStore.entityIndex.byType });
+            collectStyleEntities(allowedEntityIds, this.dataStore.source, { byId: effective, byType: effective.byType });
         }
+        /**
+         * Will this id have a defining STEP line in the output at all?
+         *
+         * The predicate is #2030's, and it is the right one: the pset, quantity and
+         * type-owned passes below are built from unfiltered mutation history, and
+         * what each of them needs to know before emitting an
+         * `IFCRELDEFINESBYPROPERTIES` is not "was this deleted" or "is this hidden"
+         * but the general question those are two answers to. A relation naming an
+         * expressId that never gets written is a dangling reference and an invalid
+         * file, whichever route dropped the line.
+         *
+         * #2030 had to reach for four things to answer it — a tombstone probe, a
+         * visibility set, a byte-range test on `completeIndex`, and a `getNewEntity`
+         * fallback whose stated purpose was that `deleteEntity` FORGOT an
+         * overlay-created entity instead of tombstoning it, so `isDeleted` could not
+         * answer for one. That fallback was documented on main as a workaround for
+         * exactly the model-level defect this branch fixes: `deleteEntity` now
+         * tombstones as well as forgets, so the effective index answers existence
+         * for source and overlay ids alike and the workaround collapses into it.
+         *
+         * The overlay branch does NOT disappear with it, and the distinction matters:
+         * `isOverlayCreated` is still load-bearing here, because a live
+         * overlay-created entity has no source bytes and would fail the byte-range
+         * test that a source record passes. What the tombstone fix removed is the
+         * need for that branch to double as a deletion detector.
+         *
+         * Deliberately unchanged from #2030 for source records under `deltaOnly` /
+         * `exportPropertiesOnly`: the source-iteration pass is skipped wholesale in
+         * those modes, yet a source entity still answers true here. A delta is a
+         * patch against a file that already has the line, not a standalone model.
+         */
+        const willBeEmitted = (entityId) => {
+            if (allowedEntityIds !== null && !allowedEntityIds.has(entityId))
+                return false;
+            // Undefined for a tombstoned id and for one neither the file nor the
+            // session ever had — a stale mutation must not conjure a relation either.
+            const ref = effective.get(entityId);
+            if (!ref)
+                return false;
+            // An overlay-created record carries the placeholder byte range and is
+            // written by the new-entities pass; a source record needs real bytes.
+            return effective.isOverlayCreated(entityId) || (ref.byteLength > 0 && ref.byteOffset >= 0);
+        };
         // A modified pset is replaced wholesale, which skips ALL of its member atoms.
         // But IFC exporters deduplicate identical Pset_*Common atoms (e.g. one
         // IsExternal IfcPropertySingleValue shared by dozens of psets), so skipping a
@@ -420,13 +551,10 @@ export class StepExporter {
         // Export original entities from source buffer, SKIPPING modified property sets
         if (!options.deltaOnly && this.dataStore.source) {
             const source = this.dataStore.source;
-            // Extract existing entities from source
-            const overlayActive = !!this.mutationView && (options.applyMutations !== false);
-            for (const [expressId, entityRef] of completeIndex) {
-                // Skip entities deleted via the overlay (only when mutations are applied)
-                if (overlayActive && typeof this.mutationView.isDeleted === 'function' && this.mutationView.isDeleted(expressId)) {
-                    continue;
-                }
+            // Extract existing entities from source. The effective index has already
+            // dropped everything the overlay tombstoned, so there is no separate
+            // deleted check to forget here.
+            for (const [expressId, entityRef] of effective) {
                 // Skip overlay-only entities — emitted by the new-entities pass below
                 if (entityRef.byteLength === 0 || entityRef.byteOffset < 0) {
                     continue;
@@ -504,30 +632,43 @@ export class StepExporter {
             }
         }
         // Generate new property entities for mutations (these REPLACE the skipped ones)
+        const generatedTypeOwnedPsetIds = new Map();
         for (const { entityId, psets } of newPropertySets) {
-            const newEntities = this.generatePropertySetEntities(entityId, psets, allowedEntityIds, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
+            // Nothing may be emitted FOR an entity that gets no defining line —
+            // see `willBeEmitted` (#1978, #2030, #2012).
+            if (!willBeEmitted(entityId))
+                continue;
+            const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
             entities.push(...newEntities.lines);
             newEntityCount += newEntities.count;
-            const typeOwnedPsetNames = typeOwnedPsetNamesByEntity.get(entityId);
-            if (typeOwnedPsetNames && typeOwnedPsetNames.size > 0) {
-                const rewritten = this.rewriteTypeEntityHasPropertySets(entityId, typeOwnedPsetIdsByEntity.get(entityId) ?? [], typeOwnedPsetNames, newEntities.generatedTypeOwnedPsetIds);
-                if (rewritten) {
-                    rewrittenEntityLines.set(entityId, rewritten);
-                }
-            }
+            generatedTypeOwnedPsetIds.set(entityId, newEntities.generatedTypeOwnedPsetIds);
         }
-        // Handle type-owned pset deletions with no replacement pset content
+        // Point every affected type object's HasPropertySets at the psets this
+        // export generated. One loop, because a type whose affected psets produced
+        // no replacement content (a deletion) needs exactly the same resolution
+        // with an empty replacement map.
         for (const [entityId, typeOwnedPsetNames] of typeOwnedPsetNamesByEntity) {
-            if (rewrittenEntityLines.has(entityId))
+            // `entityId` here is a TYPE object rather than an element; `willBeEmitted`
+            // resolves either the same way (#2030).
+            if (!willBeEmitted(entityId))
                 continue;
-            const rewritten = this.rewriteTypeEntityHasPropertySets(entityId, typeOwnedPsetIdsByEntity.get(entityId) ?? [], typeOwnedPsetNames, new Map());
+            const resolved = resolveTypeOwnedPsetIds(typeOwnedPsetIdsByEntity.get(entityId) ?? [], typeOwnedPsetNames, generatedTypeOwnedPsetIds.get(entityId) ?? new Map(), (psetId) => this.getPropertySetName(psetId));
+            if (effective.isOverlayCreated(entityId)) {
+                // No source line to rewrite: the new-entities pass writes this record
+                // from its authored payload, so the list rides in as a slot override.
+                overlayTypeOwnedPsets.set(entityId, resolved.length > 0 ? resolved.map((id) => `#${id}`) : null);
+                continue;
+            }
+            const rewritten = this.replaceEntityAttribute(entityId, HAS_PROPERTY_SETS_SLOT, hasPropertySetsToken(resolved));
             if (rewritten) {
                 rewrittenEntityLines.set(entityId, rewritten);
             }
         }
         // Generate new quantity entities for mutations
         for (const { entityId, qsets } of newQuantitySets) {
-            const newEntities = this.generateQuantitySetEntities(entityId, qsets, allowedEntityIds, options.guidRandom);
+            if (!willBeEmitted(entityId))
+                continue;
+            const newEntities = this.generateQuantitySetEntities(entityId, qsets, willBeEmitted, options.guidRandom);
             entities.push(...newEntities.lines);
             newEntityCount += newEntities.count;
         }
@@ -580,6 +721,32 @@ export class StepExporter {
                 else {
                     argsText = serializeEntityArgs(entity.type, entity.attributes, sourceSchema);
                 }
+                // Edits made AFTER the create live in the overlay, never in the
+                // authored payload (#2006). The source-iteration pass applies them to
+                // source records via applyAttributeMutations / applyPositionalMutations;
+                // an overlay-created entity has no source record, so without this it was
+                // written from its creation payload alone and every later
+                // `setAttribute` / `setPositionalAttribute` was silently dropped on
+                // save — data loss with no error and no warning.
+                //
+                // Order mirrors the source pass: retype (above) -> named attributes ->
+                // positional overrides, all resolved against the EFFECTIVE class.
+                const attributeOverrides = modifiedAttributes.get(entity.expressId) ?? null;
+                const queuedPositional = typeof this.mutationView.getPositionalMutationsForEntity === 'function'
+                    ? this.mutationView.getPositionalMutationsForEntity(entity.expressId)
+                    : null;
+                // A created TYPE object owns its psets through HasPropertySets, and the
+                // ids of the psets this export generated are only known now — so they
+                // arrive as one more slot override rather than through the overlay.
+                // `has`, not `??`, for the same reason `overlaySlotValue` gives: the
+                // stored value is deliberately null when the resolved list is empty.
+                const positionalOverrides = overlayTypeOwnedPsets.has(entity.expressId)
+                    ? new Map(queuedPositional).set(HAS_PROPERTY_SETS_SLOT, overlayTypeOwnedPsets.get(entity.expressId) ?? null)
+                    : queuedPositional;
+                if ((attributeOverrides && attributeOverrides.size > 0)
+                    || (positionalOverrides && positionalOverrides.size > 0)) {
+                    argsText = this.applyOverlayEntityOverrides(argsText, upperType, attributeOverrides, positionalOverrides, sourceSchema);
+                }
                 const line = `#${entity.expressId}=${upperType}(${argsText});`;
                 if (converting) {
                     const converted = convertStepLine(line, sourceSchema, schema, options.guidRandom);
@@ -647,28 +814,56 @@ export class StepExporter {
      * MANDATORY in IFC2X3 (IfcRoot.OwnerHistory), so emitting `$` yields an invalid
      * IFC2X3 file that strict readers (e.g. BIM Vision) reject.
      *
-     * Prefer the host element's OWN owner history: it is the semantically correct
-     * owner and — being reachable from an exported root — is guaranteed to survive a
-     * `visibleOnly` closure. Fall back to any owner history still inside the export
-     * (closure-aware) so we never reference one a `visibleOnly` / isolated export
-     * dropped, then to `$` only when the file has none.
+     * Prefer the host element's OWN owner history, then any owner history that
+     * survives this export, then `$` only when none does.
+     *
+     * "Survives" is `willBeEmitted`, the same predicate that decides whether the
+     * host itself may have psets generated for it. A reference is a reference: it
+     * is no more acceptable to point an emitted `IfcPropertySet` at an owner
+     * history the session deleted than at a host it deleted. This used to consult
+     * only the `visibleOnly` closure, so an overlay-created OwnerHistory that was
+     * later deleted still got referenced — a dangling `#N`, reached through the
+     * one attribute the generators fill in for themselves.
      */
-    resolveOwnerHistoryRef(hostEntityId, allowedEntityIds) {
+    resolveOwnerHistoryRef(hostEntityId, willBeEmitted) {
         const own = this.getOwnerHistoryRefOfEntity(hostEntityId);
         if (own !== null) {
             const ownId = parseInt(own.slice(1), 10);
-            if (allowedEntityIds === null || allowedEntityIds.has(ownId))
+            if (willBeEmitted(ownId))
                 return own;
         }
         if (this.ownerHistoryFallbackRef === undefined) {
+            // Source-only: the fallback is a best-effort "some owner history the file
+            // still has", and the host's OWN history above is the path that resolves
+            // an overlay-created one.
             const ids = this.dataStore.entityIndex.byType.get('IFCOWNERHISTORY') ?? [];
-            const surviving = allowedEntityIds === null
-                ? ids[0]
-                : ids.find((id) => allowedEntityIds.has(id));
+            const surviving = ids.find((id) => willBeEmitted(id));
             this.ownerHistoryFallbackRef = surviving !== undefined ? `#${surviving}` : '$';
         }
         return this.ownerHistoryFallbackRef;
     }
+    /**
+     * The overlay's answer for one positional slot of an overlay-created entity,
+     * falling back to the creation payload only when the overlay has NOTHING to
+     * say about that slot.
+     *
+     * **Ask `Map.has`, never `??`.** `setPositionalAttribute(id, slot, null)` is
+     * an explicit "clear this slot", and its value is `null`, so `??` reads the
+     * overlay's answer as an absence and reinstates the authored one. That is the
+     * same overlay-versus-buffer confusion this whole change is about, one
+     * attribute wide: an explicit null IS the overlay's answer, and the overlay is
+     * the authority. Cleared OwnerHistory came back as the authored reference, and
+     * a cleared `HasPropertySets` resurrected the list the user had removed.
+     */
+    overlaySlotValue(entityId, slot, authored) {
+        const overrides = this.mutationView?.getPositionalMutationsForEntity(entityId);
+        if (!overrides?.has(slot))
+            return authored;
+        const value = overrides.get(slot);
+        // `Map.get` widens to `| undefined`, which `has` has already ruled out. A
+        // slot explicitly set to nothing serializes as `$`, i.e. null.
+        return value === undefined ? null : value;
+    }
     /**
      * Read an element's own OwnerHistory reference (`#id`), or null when the
      * element omits one (`$`) or cannot be parsed. OwnerHistory is the second
@@ -679,6 +874,17 @@ export class StepExporter {
         if (cached !== undefined)
             return cached;
         let result = null;
+        // An overlay-created host has no source line to read, but it does have an
+        // authored OwnerHistory in slot 1 — reading only the buffer sent every
+        // generated pset on a created entity to the file's first owner history
+        // instead of the one the caller named (#2012).
+        const overlay = this.mutationView?.getNewEntity(entityId);
+        if (overlay) {
+            const refs = authoredEntityRefs(this.overlaySlotValue(entityId, OWNER_HISTORY_SLOT, overlay.attributes[OWNER_HISTORY_SLOT]));
+            result = refs.length > 0 ? `#${refs[0]}` : null;
+            this.ownerHistoryByEntity.set(entityId, result);
+            return result;
+        }
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (entityRef && this.dataStore.source && entityRef.byteLength > 0) {
             const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
@@ -694,7 +900,7 @@ export class StepExporter {
     /**
      * Generate STEP entities for property sets
      */
-    generatePropertySetEntities(entityId, psets, allowedEntityIds, typeOwnedPsetNames, random) {
+    generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNames, random) {
         const lines = [];
         let count = 0;
         const generatedTypeOwnedPsetIds = new Map();
@@ -718,7 +924,7 @@ export class StepExporter {
             const propRefs = propertyIds.map(id => `#${id}`).join(',');
             const globalId = this.generateGlobalId(random);
             // #ID=IFCPROPERTYSET('GlobalId',#ownerHistory,'Name',$,(#props));
-            const psetLine = `#${psetId}=IFCPROPERTYSET('${globalId}',${this.resolveOwnerHistoryRef(entityId, allowedEntityIds)},'${escapeStepString(pset.name)}',$,(${propRefs}));`;
+            const psetLine = `#${psetId}=IFCPROPERTYSET('${globalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},'${escapeStepString(pset.name)}',$,(${propRefs}));`;
             lines.push(psetLine);
             if (typeOwnedPsetNames?.has(pset.name)) {
                 generatedTypeOwnedPsetIds.set(pset.name, psetId);
@@ -729,7 +935,7 @@ export class StepExporter {
                 count++;
                 const relGlobalId = this.generateGlobalId(random);
                 // #ID=IFCRELDEFINESBYPROPERTIES('GlobalId',#ownerHistory,$,$,(#entity),#pset);
-                const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, allowedEntityIds)},$,$,(#${entityId}),#${psetId});`;
+                const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},$,$,(#${entityId}),#${psetId});`;
                 lines.push(relLine);
             }
         }
@@ -738,7 +944,7 @@ export class StepExporter {
     /**
      * Generate STEP entities for quantity sets (IfcElementQuantity)
      */
-    generateQuantitySetEntities(entityId, qsets, allowedEntityIds, random) {
+    generateQuantitySetEntities(entityId, qsets, willBeEmitted, random) {
         const lines = [];
         let count = 0;
         for (const qset of qsets) {
@@ -759,13 +965,13 @@ export class StepExporter {
             const quantRefs = quantityIds.map(id => `#${id}`).join(',');
             const globalId = this.generateGlobalId(random);
             // #ID=IFCELEMENTQUANTITY('GlobalId',#ownerHistory,'Name',$,$,(#quants));
-            const qsetLine = `#${qsetId}=IFCELEMENTQUANTITY('${globalId}',${this.resolveOwnerHistoryRef(entityId, allowedEntityIds)},'${escapeStepString(qset.name)}',$,$,(${quantRefs}));`;
+            const qsetLine = `#${qsetId}=IFCELEMENTQUANTITY('${globalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},'${escapeStepString(qset.name)}',$,$,(${quantRefs}));`;
             lines.push(qsetLine);
             // Create IfcRelDefinesByProperties to link qset to entity
             const relId = this.nextExpressId++;
             count++;
             const relGlobalId = this.generateGlobalId(random);
-            const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, allowedEntityIds)},$,$,(#${entityId}),#${qsetId});`;
+            const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},$,$,(#${entityId}),#${qsetId});`;
             lines.push(relLine);
         }
         return { lines, count };
@@ -779,17 +985,28 @@ export class StepExporter {
         if (openParen < 0 || closeParen < openParen) {
             return entityText;
         }
-        const attrNames = getAttributeNames(entityType);
+        // Cross-schema, not the IFC4 pin: an IFC4X3-only class (IfcCourse, IfcRoad,
+        // IfcBridge, …) resolves no slots under the pin, so every named edit on one
+        // was silently discarded here too. Identical for the 755 pinned classes
+        // that declare attributes — `attribute-slot-types.test.ts` measures that —
+        // so no IFC4 export changes; this only stops dropping edits it used to drop.
+        const attrNames = getAttributeNamesAcrossSchemas(entityType);
         if (attrNames.length === 0) {
             return entityText;
         }
         const args = splitTopLevelArgs(entityText.slice(openParen + 1, closeParen));
+        // A source line NEVER pads (unlike the overlay-created path): a short
+        // argument list here means the file speaks a different schema, and growing
+        // a record we did not author would corrupt it.
         let changed = false;
         for (const [attrName, value] of attributeMutations) {
             const index = attrNames.indexOf(attrName);
             if (index < 0 || index >= args.length)
                 continue;
-            args[index] = serializeAttributeValue(value, args[index]);
+            // The source path shares every `$`-slot hole with the overlay-created
+            // path, because a source record has plenty of `$` slots of its own. Both
+            // go through the one helper below.
+            args[index] = this.serializeNamedAttribute(entityType, index, value, args[index]);
             changed = true;
         }
         if (!changed) {
@@ -797,6 +1014,92 @@ export class StepExporter {
         }
         return `${entityText.slice(0, openParen + 1)}${args.join(',')}${entityText.slice(closeParen)}`;
     }
+    /**
+     * Serialize one NAMED attribute override into its slot — the single point
+     * both the source-buffer rewrite and the overlay-created rewrite go through.
+     *
+     * `serializeAttributeValue` decides the STEP form by reading the token being
+     * replaced, which is sound only while that token carries type information. A
+     * `$` slot carries none, and both paths have plenty: a source record's
+     * optional attributes are `$`, and overlay-created records pad missing slots
+     * with `$`. So the declared type decides first, and inference is the fallback
+     * for slots the schema does not classify (references, SELECTs, numerics),
+     * where reading the old token is exactly the right heuristic.
+     */
+    serializeNamedAttribute(entityType, index, value, currentToken) {
+        if (getEnumTypedSlots(entityType).has(index))
+            return serializeEnumToken(value);
+        if (getStringTypedSlots(entityType).has(index))
+            return serializeStringSlot(value);
+        return serializeAttributeValue(value, currentToken);
+    }
+    /**
+     * Apply overlay attribute + positional overrides to an OVERLAY-CREATED
+     * entity's argument list (#2006).
+     *
+     * Distinct from {@link applyAttributeMutations} / {@link applyPositionalMutations},
+     * which rewrite a line read out of the source buffer. Here the whole line is
+     * ours: it was serialized moments ago from the creation payload, so the
+     * argument list is the authoring payload's, not the file's. That difference
+     * is why this PADS — `entity_create` takes whatever positional list the
+     * caller passes, so a wall authored with three arguments still has a real
+     * `Tag` slot at index 7, and dropping the edit because the payload was short
+     * would be the very data loss this fixes. The source-buffer path must not
+     * pad: there a short line means a different schema, and growing a record we
+     * did not author would corrupt it.
+     *
+     * Named and positional overrides resolve to a slot index up front and share
+     * ONE padding rule. Two padding rules on one record is how the next bug
+     * starts, and the argument for padding — the class is fixed at creation time,
+     * so a short payload is partial authoring — never depended on which of the
+     * two APIs queued the edit.
+     */
+    applyOverlayEntityOverrides(argsText, entityType, attributeOverrides, positionalOverrides, schemaVersion) {
+        const args = argsText.length > 0 ? splitTopLevelArgs(argsText) : [];
+        const attrNames = getAttributeNamesAcrossSchemas(entityType);
+        const named = [];
+        for (const [attrName, value] of attributeOverrides ?? []) {
+            const index = attrNames.indexOf(attrName);
+            if (index >= 0)
+                named.push([index, value]);
+        }
+        // Grow to the class's FULL declared arity as soon as any override names a
+        // declared slot the creation payload never reached. Growing only as far as
+        // the edited slot would emit eight arguments for an IfcWall that declares
+        // nine: this parser tolerates the truncated record, a schema-validating
+        // consumer rejects the file.
+        //
+        // An index PAST the declared layout is not a slot at all, so it cannot
+        // justify growing the record and stays dropped — as does any override on a
+        // class neither schema source knows, where there is no arity to grow to.
+        let needsPad = named.some(([index]) => index >= args.length);
+        if (!needsPad && positionalOverrides) {
+            for (const [index] of positionalOverrides) {
+                if (index >= args.length && index < attrNames.length) {
+                    needsPad = true;
+                    break;
+                }
+            }
+        }
+        if (needsPad) {
+            while (args.length < attrNames.length)
+                args.push('$');
+        }
+        // Every `named` index is < attrNames.length by construction, and padding
+        // has taken args.length to at least that, so each one lands.
+        for (const [index, value] of named) {
+            args[index] = this.serializeNamedAttribute(entityType, index, value, args[index]);
+        }
+        if (positionalOverrides && positionalOverrides.size > 0) {
+            const realSlots = getRealTypedSlots(entityType, schemaVersion);
+            for (const [index, value] of positionalOverrides) {
+                if (index < 0 || index >= args.length)
+                    continue;
+                args[index] = this.serializePositionalOverride(entityType, index, value, args[index], realSlots, schemaVersion);
+            }
+        }
+        return args.join(',');
+    }
     /**
      * Apply positional STEP argument overrides to an entity line.
      * Used for non-IfcRoot edits (e.g. profile dimensions) where attributes
@@ -1007,25 +1310,31 @@ export class StepExporter {
      * the source: for each related entity, list the rels and property/quantity
      * sets that reference it. Used by the export pre-pass so the per-entity
      * "find owning rels" step is O(K) rather than O(N) per modified entity.
+     *
+     * `relatedByRel` is the same walk read the other way round, so the deleted-host
+     * sweep costs nothing extra.
      */
     buildRelDefinesByPropertiesIndex() {
-        const out = new Map();
+        const byEntity = new Map();
+        const relatedByRel = new Map();
         for (const [relId, relRef] of this.dataStore.entityIndex.byId) {
             if (relRef.type.toUpperCase() !== 'IFCRELDEFINESBYPROPERTIES')
                 continue;
             const psetId = this.getRelatedPropertySet(relId);
             if (!psetId)
                 continue;
-            for (const entityId of this.getRelatedEntities(relId)) {
-                let bucket = out.get(entityId);
+            const related = this.getRelatedEntities(relId);
+            relatedByRel.set(relId, related);
+            for (const entityId of related) {
+                let bucket = byEntity.get(entityId);
                 if (!bucket) {
                     bucket = [];
-                    out.set(entityId, bucket);
+                    byEntity.set(entityId, bucket);
                 }
                 bucket.push({ relId, psetId });
             }
         }
-        return out;
+        return { byEntity, relatedByRel };
     }
     /**
      * Get entity IDs related by IfcRelDefinesByProperties (the related objects)
@@ -1145,56 +1454,32 @@ export class StepExporter {
         return ids;
     }
     /**
-     * Check whether an entity is an IFC type object (e.g. IfcWallType).
-     */
-    isTypeEntity(entityId) {
-        const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        return entityRef?.type.toUpperCase().endsWith('TYPE') ?? false;
-    }
-    /**
-     * Get the full HasPropertySets ID list from a type entity.
-     * This preserves both property and quantity definitions already assigned there.
+     * The full HasPropertySets id list of a type object, from whichever authority
+     * owns the record.
+     *
+     * Slot 5 is `HasPropertySets` on every `IfcTypeObject` subtype. For a source
+     * record the list is parsed out of the file; for an overlay-created type it is
+     * read off the authored payload, where a reference is the documented `'#42'`
+     * string form. Reading only the source made every pset on a created
+     * `IfcWallType` look unowned, which is how it ended up on an occurrence
+     * relation instead (#2012).
      */
-    getTypeOwnedHasPropertySetIds(entityId) {
+    getTypeOwnedHasPropertySetIds(entityId, effective) {
+        if (effective.isOverlayCreated(entityId)) {
+            const authored = this.mutationView?.getNewEntity(entityId)?.attributes?.[HAS_PROPERTY_SETS_SLOT];
+            return authoredEntityRefs(this.overlaySlotValue(entityId, HAS_PROPERTY_SETS_SLOT, authored));
+        }
         if (!this.entityExtractor)
             return [];
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (!entityRef)
             return [];
         const entity = this.entityExtractor.extractEntity(entityRef);
-        const hasPropertySets = entity?.attributes?.[5];
+        const hasPropertySets = entity?.attributes?.[HAS_PROPERTY_SETS_SLOT];
         if (!Array.isArray(hasPropertySets))
             return [];
         return hasPropertySets.filter((value) => typeof value === 'number');
     }
-    /**
-     * Rewrite a type entity so its HasPropertySets attribute points to replacement psets.
-     */
-    rewriteTypeEntityHasPropertySets(entityId, originalPsetIds, affectedPsetNames, replacementPsetIds) {
-        const rewrittenIds = [];
-        const usedReplacementNames = new Set();
-        for (const psetId of originalPsetIds) {
-            const psetName = this.getPropertySetName(psetId);
-            if (psetName && affectedPsetNames.has(psetName)) {
-                const replacementId = replacementPsetIds.get(psetName);
-                if (replacementId !== undefined) {
-                    rewrittenIds.push(replacementId);
-                    usedReplacementNames.add(psetName);
-                }
-                continue;
-            }
-            rewrittenIds.push(psetId);
-        }
-        for (const [psetName, psetId] of replacementPsetIds) {
-            if (!usedReplacementNames.has(psetName)) {
-                rewrittenIds.push(psetId);
-            }
-        }
-        const attrValue = rewrittenIds.length > 0
-            ? `(${rewrittenIds.map(id => `#${id}`).join(',')})`
-            : '$';
-        return this.replaceEntityAttribute(entityId, 5, attrValue);
-    }
     /**
      * Replace a single top-level STEP attribute in an entity line.
      */