@ifc-lite/export 2.8.3 → 2.8.5

package/dist/step-exporter.js

@@ -1,18 +1,24 @@
 /* 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 { asSourceBytes, EntityExtractor, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
+import { asSourceBytes, EntityExtractor, extractQuantitiesOnDemand, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
 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 { createModificationLedger, recordSourceLineDelivery, } from './delta-modification-ledger.js';
+import { nominateDeliveredInPlaceEdits } from './in-place-nomination.js';
+import { createSourceRefReader } from './source-ref-bounds.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 { HAS_PROPERTY_SETS_SLOT, isTypeClass, resolveTypeOwnedPsetIds, rewriteTypeOwnedPsetLine, typeOwnedPsetRewriteWarning, } from './type-owned-psets.js';
+import { escapeStepString, toStepReal, quantityTypeToIfcType, serializeAttributeValue, serializeStepValue, tokenIsRealLiteral, } from './step-serialization.js';
+import { splitTopLevelArgs } from './step-argument-parser.js';
+import { assembleStepBytes } from './step-file-assembly.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';
+import { serializeNominalValue } from './declared-property-type.js';
 /**
  * UTF-8 decode of `[start, end)` of the source, accepting either the raw bytes
  * or the {@link IfcSourceBytes} accessor (#2183). Replaces the direct
@@ -25,6 +31,21 @@ function decodeRange(src, start, end) {
 }
 /** `OwnerHistory` is slot 1 on every `IfcRoot` subtype, all schemas. */
 const OWNER_HISTORY_SLOT = 1;
+/**
+ * The store the extractor THIS class installed on a view currently reads
+ * (#2487). The extractor is installed once per view and closes over this box
+ * rather than over a store directly, so a later export of the same view against
+ * a different store re-points it instead of answering from the first file.
+ *
+ * A box, and not a `WeakSet` of views, because ownership has to reflect the
+ * CURRENT state and not the historical fact that an export once installed
+ * something. `setQuantityExtractor` is public: a caller may install its own
+ * afterwards, and a marker saying "the exporter owns this view" would then keep
+ * overwriting a caller-supplied base forever. With a box, the second export
+ * writes to a box nothing reads any more and never calls the setter again, so
+ * the caller's extractor stands. Weak, so it never keeps a session alive.
+ */
+const exporterQuantityBase = new WeakMap();
 /**
  * Message for the one refusal `export()` can report, shared by the returned
  * `stats.warnings` entry and the console line so the two cannot drift.
@@ -68,7 +89,6 @@ export class StepExporter {
     export(options) {
         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
@@ -140,6 +160,11 @@ export class StepExporter {
         // 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);
+        // Does this record describe a line this export can actually READ out of the
+        // source? One predicate for every byte-range gate below, so they cannot
+        // disagree — see `source-ref-bounds.ts` for the corrupt file the weaker
+        // "is there a source / does the ref claim bytes" pair let through (#2491).
+        const isReadableSourceRef = createSourceRefReader(this.dataStore.source);
         // 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
@@ -188,15 +213,35 @@ export class StepExporter {
             if (allowedEntityIds !== null && !allowedEntityIds.has(entityId))
                 return false;
             const ref = effective.get(entityId);
-            if (!ref || ref.byteLength <= 0 || ref.byteOffset < 0)
+            // The ref must be READABLE, not merely non-empty: a range this source
+            // cannot address decodes to the empty string, which used to be pushed
+            // into the file as a blank line while everything generated FOR the host
+            // still named it (#2491).
+            if (!ref || !isReadableSourceRef(ref))
                 return false;
             if (options.deltaOnly !== true && isGeometryExcluded(entityId, ref.type))
                 return false;
             return true;
         };
+        // Under `deltaOnly` a nomination only becomes a count once some pass has
+        // actually written content that delivers THAT KIND of edit for the host —
+        // see `delta-modification-ledger.ts` for why the two are not the same event
+        // in that mode, and why the pair is (entity, kind) rather than the entity
+        // (#2462).
+        const modifications = createModificationLedger(options.deltaOnly === true);
+        /**
+         * Hosts whose in-place named-attribute edits a FULL export may count, per
+         * kind. Filled by the collection passes below and read by the two passes
+         * that write a rewritten source line — see `in-place-nomination.ts` for why
+         * the nomination waits for the rewrite in this mode and not under
+         * `deltaOnly` (#2483).
+         */
+        const inPlaceNominees = {
+            attribute: new Set(),
+            georeferencing: new Set(),
+        };
         // Collect entities that need to be modified or created
         const modifiedEntities = new Set();
-        const modifiedPsets = new Map(); // entityId -> psetNames being modified
         const modifiedAttributes = new Map();
         const newPropertySets = [];
         const newQuantitySets = [];
@@ -289,14 +334,22 @@ export class StepExporter {
                 if (effective.isDeleted(entityId))
                     continue;
                 modifiedEntities.add(entityId);
-                modifiedPsets.set(entityId, psetNames);
                 // 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) && hasEmittableHostBytes(entityId))
-                    modifiedEntityCount++;
+                //
+                // A NOMINATION, in both modes, never a count on its own: this site sees
+                // a pset NAME the session touched, not whether that name resolves to
+                // anything. `deletePropertySet(id, 'AName')` on a host that owns no such
+                // set reaches here and changes nothing at all, and used to put "1
+                // modification" in the header of a byte-identical file (#2474). What
+                // settles it is the generator's `recordEmitted` and the skip branches'
+                // `recordWithheld` below.
+                if (!isOverlayCreated(entityId) && hasEmittableHostBytes(entityId)) {
+                    modifications.nominate(entityId, 'property-set');
+                }
                 // 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));
@@ -322,6 +375,12 @@ export class StepExporter {
                             for (const propId of propIds) {
                                 skipPropertySetIds.add(propId);
                             }
+                            // The other half of "did this edit change the file": a full export
+                            // applies a set DELETION by leaving these lines out, and produces
+                            // no replacement content to record an emission for. Without this
+                            // the count would settle from the generator alone and a real
+                            // deletion would stop counting along with the no-op one (#2474).
+                            modifications.recordWithheld(entityId, 'property-set');
                         }
                     }
                 }
@@ -338,6 +397,12 @@ export class StepExporter {
                         for (const propId of propIds) {
                             skipPropertySetIds.add(propId);
                         }
+                        // No `recordWithheld` twin of the rel-defined branch above, and
+                        // deliberately: a name that matches an OWNED pset is either dropped
+                        // from the resolved list or swapped for the replacement this export
+                        // generated, so slot 5 always comes back different and the repoint
+                        // below records the emission for it. A second record here would be
+                        // one no mutation can kill.
                     }
                     for (const psetName of psetNames) {
                         if (!relDefinedPsetNames.has(psetName)) {
@@ -354,33 +419,134 @@ export class StepExporter {
             // Collect modified quantity sets (only if quantities are included)
             if (options.includeQuantities === false)
                 entityQuantMutations.clear();
+            // A quantity overlay with nothing under it regenerates a source quantity
+            // set from the edited quantity ALONE, and the skip loop below then
+            // withholds the source lines that held its siblings (#2487). Unlike
+            // properties — whose base falls back to the `baseTable` the view was
+            // constructed with — quantities have only the opt-in
+            // `setQuantityExtractor`, so the default really is an empty base, and
+            // four in-tree callers plus every external embedder never set it.
+            //
+            // The exporter is the one place that always holds the missing half: it
+            // was handed the very store the view is an overlay ON. Supplying it here
+            // makes the loss impossible for every caller rather than for the callers
+            // we happened to find, and a view that resolves its own quantities (the
+            // viewer, MCP, the CLI headless backend) is never overwritten.
+            //
+            // The extractor closes over ONE store, and the view outlives this export.
+            // So it closes over a BOX this class owns instead: a second export of the
+            // same view against a DIFFERENT store re-points that box rather than
+            // reading the first store's quantities, which is the one way "install only
+            // when absent" could have answered from the wrong file. The setter is
+            // called at most once per view, so a caller that installs its own
+            // extractor at any point — before the first export or after it — keeps it.
+            //
+            // `hasQuantityBase` and `setQuantityExtractor` are probed, like every other
+            // optional view capability this class reaches for (`peekNextExpressId`,
+            // `getNewEntities`, `getEntityTypeMutation`): `MutablePropertyView` is
+            // published API arriving from a separately versioned package, and callers
+            // pass partial and duck-typed views. `hasQuantityBase` is newer than
+            // `setQuantityExtractor`, and without it there is no way to tell an empty
+            // base from a caller-supplied one — so an older view falls back to the
+            // pre-#2487 behaviour (no base supplied) rather than risk overwriting one.
+            const quantityView = this.mutationView;
+            if (entityQuantMutations.size > 0 &&
+                typeof quantityView.setQuantityExtractor === 'function' &&
+                typeof quantityView.hasQuantityBase === 'function') {
+                const installed = exporterQuantityBase.get(quantityView);
+                if (installed) {
+                    // Ours, or a caller's that replaced ours: re-pointing the box is a
+                    // no-op in the second case, and calling the setter again is what
+                    // would not be.
+                    installed.store = this.dataStore;
+                }
+                else if (!quantityView.hasQuantityBase()) {
+                    const box = { store: this.dataStore };
+                    exporterQuantityBase.set(quantityView, box);
+                    quantityView.setQuantityExtractor((id) => extractQuantitiesOnDemand(box.store, id));
+                }
+            }
             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);
                 // See the property loop above — an overlay-created entity is counted as
-                // new, not modified.
-                if (!isOverlayCreated(entityId) && !modifiedPsets.has(entityId) && hasEmittableHostBytes(entityId))
-                    modifiedEntityCount++;
+                // new, not modified. The pset loop's own nomination no longer has to be
+                // excluded to avoid a double count: the ledger settles per ENTITY, so a
+                // host with both a pset and a qset edit counts once whatever is
+                // nominated. Nominating both buys the opposite — an accurate warning
+                // when the qset half is the half a delta cannot carry.
+                //
+                // Settled from effect like its property-set twin (#2474). The reachable
+                // no-op here is an UNDONE quantity-set creation whose name matches NO
+                // source set: `getMutations()` is append-only, so the `CREATE_QUANTITY`
+                // record still names the qset after `removeQuantityMutation` has taken
+                // it out of the overlay, and the generator below then finds nothing to
+                // write. The same undo against a COLLIDING name is not a no-op — it
+                // withholds the source set's lines — which is what the skip loop's
+                // `recordWithheld` below settles.
+                if (!isOverlayCreated(entityId) && hasEmittableHostBytes(entityId)) {
+                    modifications.nominate(entityId, 'quantity-set');
+                }
                 const allQsets = this.mutationView.getQuantitiesForEntity(entityId);
                 const relevantQsets = allQsets.filter((qset) => qsetNames.has(qset.name));
                 if (relevantQsets.length > 0) {
                     newQuantitySets.push({ entityId, qsets: relevantQsets });
                 }
+                // The names this export is actually WRITING a replacement for. The
+                // affected-name set is not the same thing: it comes from the session's
+                // append-only mutation history, which keeps naming a quantity set after
+                // an undo has taken it back out of the overlay, so a Ctrl+Z used to
+                // withhold a source `IfcElementQuantity` that nothing regenerated. There
+                // is no quantity-set REMOVAL to preserve here — `deletedQsets` has no
+                // public populator, so withholding without a replacement is always the
+                // bug and never the intent (#2487).
+                const regeneratedQsetNames = new Set(relevantQsets.map((qset) => qset.name));
                 // Skip original quantity set entities (IfcElementQuantity).
                 // Same per-entity index lookup as the property branch above.
                 const rels = relDefinesByEntity.get(entityId);
                 if (rels) {
                     for (const { relId, psetId: relatedPsetId } of rels) {
                         const qsetName = this.getElementQuantityName(relatedPsetId);
-                        if (qsetName && qsetNames.has(qsetName)) {
+                        if (qsetName && regeneratedQsetNames.has(qsetName)) {
                             skipRelationshipIds.add(relId);
                             skipPropertySetIds.add(relatedPsetId);
                             const quantIds = this.getPropertyIdsInSet(relatedPsetId);
                             for (const quantId of quantIds) {
                                 skipPropertySetIds.add(quantId);
                             }
+                            // The withheld half, exactly as the rel-defined property branch
+                            // above. This loop has just decided that #`relatedPsetId`, its
+                            // quantity atoms and the relationship that attached them do NOT
+                            // go into the file; whether anything is generated to take their
+                            // place is decided elsewhere, and is not this branch's to assume.
+                            //
+                            // It IS assumable for the pset side and not here, and the
+                            // difference is where the two read their base from.
+                            // `getForEntity` merges the overlay over the base pset walk, so a
+                            // name the session touched but did not change still resolves to
+                            // source content and is regenerated.
+                            // `getQuantitiesForEntity` merges the overlay over
+                            // `quantityExtractor`, which is OPT-IN: it defaults to null, and
+                            // several in-tree callers wire the property extractor beside it
+                            // and not it (`cli/commands/mutate.ts`, `gym.ts`,
+                            // `generate-spaces.ts`, `export/demesh-session.ts`), as does any
+                            // external embedder of these two published packages. With no
+                            // extractor the base is empty and the overlay is the only source,
+                            // so a qset the overlay no longer holds resolves to nothing.
+                            //
+                            // Which makes this reachable through an UNDONE quantity-set
+                            // creation whose name COLLIDES with a source set:
+                            // `setQuantity(id, 'Qto_WallBaseQuantities', ...)` followed by the
+                            // `removeQuantityMutation` that mutationSlice runs on Ctrl+Z. The
+                            // append-only history still names the qset, so this branch
+                            // withholds the source lines; the overlay is empty again, so
+                            // nothing is regenerated. The export drops the source quantity set
+                            // — a real change to the file, and a data-loss bug of its own
+                            // (#2487) — and this call is what stops the count from calling it
+                            // nothing.
+                            modifications.recordWithheld(entityId, 'quantity-set');
                         }
                     }
                 }
@@ -397,9 +563,29 @@ export class StepExporter {
                 // must not inflate the count either.
                 if (!hasEmittableHostBytes(entityId))
                     continue;
-                if (!entityPropMutations.has(entityId) && !entityQuantMutations.has(entityId)) {
-                    modifiedEntityCount++;
-                }
+                // Under `deltaOnly` this only NOMINATES the host's ATTRIBUTE edits:
+                // nothing writes an in-place attribute edit into a delta except the
+                // type-object line rewrite, so the ledger drops it at settle time
+                // unless that pass reports having carried it (#2462). That nomination
+                // is deliberately made at INTENT: the per-kind warning exists to NAME
+                // an edit the delta could not carry, and an undeliverable edit is
+                // exactly the one that must still be named.
+                //
+                // A FULL export has no such warning, so an edit that resolved to
+                // nothing has nothing to say and nothing to claim — it waits for the
+                // rewrite instead. `setAttribute` to the value already in the slot, and
+                // `setAttribute` naming a slot the class does not declare, both leave
+                // the line byte-identical and used to count anyway (#2483).
+                //
+                // Recorded unconditionally. It used to be skipped for a host that also
+                // had a pset or qset edit, because the count was per entity and the
+                // other loop had already nominated it — which is exactly what let a
+                // pset emission mark the rename delivered and suppress its warning. The
+                // ledger de-duplicates the COUNT per entity now, so the two edits can
+                // and must be nominated separately.
+                inPlaceNominees.attribute.add(entityId);
+                if (options.deltaOnly === true)
+                    modifications.nominate(entityId, 'attribute');
             }
         }
         // Process georeferencing mutations (only when applyMutations is enabled)
@@ -455,10 +641,25 @@ export class StepExporter {
                     attrMap.set('MapUnit', `#${mapUnitRef}`);
                     changed = true;
                 }
-                if (changed && !modifiedEntities.has(entityId)) {
+                if (changed) {
                     modifiedEntities.add(entityId);
-                    if (hasEmittableHostBytes(entityId))
-                        modifiedEntityCount++;
+                    // Queued as attribute edits, which only the source-iteration pass
+                    // writes — so under `deltaOnly` this nominates and settle decides.
+                    // Recorded even when the host is already in `modifiedEntities`: that
+                    // guard existed to stop a second COUNT, which the ledger now handles
+                    // per entity, and suppressing the nomination would hide a dropped
+                    // georeferencing edit behind an unrelated edit to the same record.
+                    //
+                    // `changed` above is INTENT — a field was supplied, not a field that
+                    // differs from the one in the file. Writing `name: 'EPSG:2056'` over
+                    // an IfcProjectedCRS already named `EPSG:2056` leaves the line
+                    // byte-identical, so a full export waits for the rewrite exactly as
+                    // the plain attribute site does (#2483).
+                    if (hasEmittableHostBytes(entityId)) {
+                        inPlaceNominees.georeferencing.add(entityId);
+                        if (options.deltaOnly === true)
+                            modifications.nominate(entityId, 'georeferencing');
+                    }
                 }
             }
             // Modify existing IfcMapConversion
@@ -494,10 +695,14 @@ export class StepExporter {
                     attrMap.set('Scale', String(mc.scale));
                     changed = true;
                 }
-                if (changed && !modifiedEntities.has(entityId)) {
+                if (changed) {
                     modifiedEntities.add(entityId);
-                    if (hasEmittableHostBytes(entityId))
-                        modifiedEntityCount++;
+                    // Same as the IfcProjectedCRS branch above, effect gate included.
+                    if (hasEmittableHostBytes(entityId)) {
+                        inPlaceNominees.georeferencing.add(entityId);
+                        if (options.deltaOnly === true)
+                            modifications.nominate(entityId, 'georeferencing');
+                    }
                 }
             }
             // CREATE new georef entities when file has none
@@ -635,7 +840,10 @@ export class StepExporter {
                 // deltaOnly carve-out the source branch gets.
                 return !isGeometryExcluded(entityId, ref.type);
             }
-            if (!(ref.byteLength > 0 && ref.byteOffset >= 0))
+            // Same readability test as `hasEmittableHostBytes`, and for the reason
+            // that predicate names: a ref this source cannot address is not a line
+            // this export can write, so nothing may be generated naming it (#2491).
+            if (!isReadableSourceRef(ref))
                 return false;
             // Mirrors `hasEmittableHostBytes`: under `deltaOnly` the source-
             // iteration pass — and its geometry skip — never runs, so a source
@@ -657,8 +865,12 @@ export class StepExporter {
             // 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) {
+                // Skip overlay-only entities — emitted by the new-entities pass below.
+                // A ref this source cannot address is skipped by the same test rather
+                // than decoded: `decodeUtf8` clamps such a range and the empty string
+                // it returns used to be pushed into the file as a blank line, leaving
+                // every generated record that names the host dangling (#2491).
+                if (!isReadableSourceRef(entityRef)) {
                     continue;
                 }
                 // Skip entities outside the visible closure
@@ -684,42 +896,29 @@ export class StepExporter {
                 // SharedArrayBuffer-backed view; the parser deliberately keeps
                 // `source` zero-copy SAB-backed for worker sharing).
                 const entityText = decodeRange(source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
-                let nextEntityText = entityText;
-                // Entity retype (reassign class) runs FIRST so attribute mutations
-                // below resolve against the TARGET class's attribute names. The
-                // expressId is unchanged, so geometry / placement / representation and
-                // every IfcRel* reference (keyed by #id) carry over untouched.
-                //
-                // This materializes inside the source-iteration loop, which `deltaOnly`
-                // skips — so, like in-place attribute/positional edits to existing
-                // entities, an existing-entity retype is only emitted by a full export
-                // (the common `applyMutations` path). Retyped OVERLAY-created entities
-                // are emitted under `deltaOnly` via the new-entities pass below.
-                const typeMutation = overlayActive && typeof this.mutationView.getEntityTypeMutation === 'function'
-                    ? this.mutationView.getEntityTypeMutation(expressId)
-                    : null;
-                let workingType = entityType;
-                if (typeMutation) {
-                    nextEntityText = retypeStepLine(nextEntityText, entityRef.type, typeMutation.newType, typeMutation.predefinedType ?? null, sourceSchema);
-                    workingType = typeMutation.newType.toUpperCase();
-                    if (!modifiedEntities.has(expressId)) {
-                        modifiedEntities.add(expressId);
-                        modifiedEntityCount++;
-                    }
-                }
-                if (modifiedAttributes.has(expressId)) {
-                    nextEntityText = this.applyAttributeMutations(nextEntityText, workingType, modifiedAttributes.get(expressId));
-                }
-                const positional = overlayActive && typeof this.mutationView.getPositionalMutationsForEntity === 'function'
-                    ? this.mutationView.getPositionalMutationsForEntity(expressId)
-                    : null;
-                if (positional && positional.size > 0) {
-                    nextEntityText = this.applyPositionalMutations(nextEntityText, positional, workingType, sourceSchema);
-                    if (!modifiedEntities.has(expressId)) {
-                        modifiedEntities.add(expressId);
-                        modifiedEntityCount++;
-                    }
-                }
+                // Retype, named attribute edits and positional edits, in that order.
+                // Shared verbatim with the type-object `HasPropertySets` rewrite below,
+                // which writes the line this pass would otherwise have written.
+                const mutated = this.applySourceLineMutations(expressId, entityText, entityRef.type, modifiedAttributes.get(expressId), sourceSchema, overlayActive);
+                const nextEntityText = mutated.text;
+                // A retype or a positional edit that CHANGED the line is what makes
+                // this entity count; a named attribute edit was already nominated by
+                // the collection pass. Both flags report effect, so retyping an entity
+                // to the class it already is — or writing a slot the token it already
+                // holds — no longer claims a modification over a line the export left
+                // byte-identical. This pass is full-export-only (`deltaOnly` skips it
+                // wholesale), so nomination IS emission here and the kinds only have to
+                // be right for the entity count — which is per entity, hence unchanged.
+                if (mutated.retyped || mutated.positional)
+                    modifiedEntities.add(expressId);
+                if (mutated.retyped)
+                    modifications.nominate(expressId, 'retype');
+                if (mutated.positional)
+                    modifications.nominate(expressId, 'positional');
+                // The named-attribute kinds join them here rather than at their
+                // collection sites, for the same reason and on the same signal (#2483).
+                // This pass is full-export-only, so there is nothing to gate.
+                nominateDeliveredInPlaceEdits(modifications, expressId, mutated, inPlaceNominees);
                 // Apply schema conversion if exporting to a different schema version
                 if (converting) {
                     const converted = convertStepLine(nextEntityText, sourceSchema, schema, options.guidRandom);
@@ -743,6 +942,10 @@ export class StepExporter {
             const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, effective, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
             entities.push(...newEntities.lines);
             newEntityCount += newEntities.count;
+            // Replacement content for this host actually landed, so a delta really
+            // does carry its PROPERTY-SET modification — and only that one (#2462).
+            if (newEntities.lines.length > 0)
+                modifications.recordEmitted(entityId, 'property-set');
             generatedTypeOwnedPsetIds.set(entityId, newEntities.generatedTypeOwnedPsetIds);
         }
         // Point every affected type object's HasPropertySets at the psets this
@@ -761,9 +964,108 @@ export class StepExporter {
                 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);
+            // This line REPLACES the one the source-iteration pass would have
+            // written — `rewrittenEntityIds` makes that pass skip the entity — so it
+            // has to carry the entity's other edits too, and it has to apply them
+            // the way that pass does. It used to replace slot 5 and nothing else,
+            // which dropped the rename in `setAttribute(id,'Name',…)` +
+            // `addPropertySet(id,…)`, and then, once renames were special-cased
+            // here, still dropped retypes and positional edits — same line, same
+            // silence. So run the ONE pipeline both passes share and replace
+            // `HasPropertySets` on its output. Order matters: see
+            // {@link applySourceLineMutations}.
+            const record = effective.get(entityId);
+            let sourceLine = null;
+            let mutated = null;
+            // One narrowed block for both calls: `record` is in scope for the decode
+            // AND for the record type below, with no non-null assertion to keep true
+            // by hand. `byteOffset >= 0` is the same "are there real source bytes"
+            // test the source-iteration pass makes — an overlay-authored record
+            // carries `-1` there, and decoding from it would read another entity's
+            // bytes rather than fall through to the no-source-bytes branch.
+            // `isReadableSourceRef` folds in the `byteOffset >= 0 && byteLength > 0`
+            // test this used to make by hand, and adds the bound the invariant used
+            // to supply (#2491).
+            if (record && isReadableSourceRef(record)) {
+                sourceLine = decodeRange(this.dataStore.source, record.byteOffset, record.byteOffset + record.byteLength);
+                // The RECORD's class is the from-type: the bytes are still the source
+                // class, whatever `typeOf` now says the entity effectively is.
+                mutated = this.applySourceLineMutations(entityId, sourceLine, record.type, modifiedAttributes.get(entityId), sourceSchema, overlayActive);
+            }
+            if (mutated === null) {
+                // `willBeEmitted` already required real source bytes for a non-overlay
+                // record, so this is only reachable with no source buffer at all —
+                // in which case the source-iteration pass never ran either and there is
+                // nothing to lose. Say it anyway; the pset edit is still going nowhere.
+                warnings.push(typeOwnedPsetRewriteWarning(entityId, 'no-source-bytes'));
+                // The line above IS the report, so the ledger must not add a second,
+                // vaguer one blaming the delta format for a drop the format did not
+                // cause.
+                modifications.acknowledgeUndelivered(entityId, 'property-set');
+                continue;
+            }
+            const { line, repointed } = rewriteTypeOwnedPsetLine(mutated.text, resolved);
+            if (repointed) {
+                // A repoint that resolves to the list the line ALREADY names changes
+                // nothing, and it is reachable: deleting a pset name the type object
+                // does not own leaves every original id in place (it is "affected" but
+                // matches none of them) and generates no replacement, so slot 5 comes
+                // back byte-identical. Same rule as the fallback branch below — an
+                // unchanged line has no place in a delta, and claiming it delivered the
+                // edit would put a modification in the header over a line that carries
+                // none. A FULL export still emits it: `rewrittenEntityIds` made the
+                // source-iteration pass skip this entity, so withholding the line there
+                // would delete the record from the file (#2469).
+                const changed = line !== sourceLine;
+                if (options.deltaOnly !== true || changed) {
+                    rewrittenEntityLines.set(entityId, line);
+                }
+                // A rewritten source line IS in the delta — the one in-place change a
+                // delta does carry today (#2462). The repoint itself delivers the
+                // property-set edit that put this host in the loop; the rest of the
+                // line delivers whichever in-place edits the pipeline applied to it.
+                if (changed) {
+                    modifications.recordEmitted(entityId, 'property-set');
+                    recordSourceLineDelivery(modifications, entityId, mutated);
+                    // `rewrittenEntityIds` made the source-iteration pass skip this
+                    // host, so this line is the ONLY place a full export can see its
+                    // named-attribute edits land — per site, not per feature (#2483).
+                    nominateDeliveredInPlaceEdits(modifications, entityId, mutated, inPlaceNominees);
+                }
+                continue;
+            }
+            // A malformed source line — too few arguments to have a slot 5, or not
+            // parseable as a STEP record at all. The entity must still come out:
+            // `rewrittenEntityIds` made the source-iteration pass skip it, so
+            // dropping the line here deletes the whole record from the file (#2469).
+            warnings.push(typeOwnedPsetRewriteWarning(entityId, 'unparseable-line'));
+            // Same as the `no-source-bytes` branch: the property-set edit is
+            // genuinely undelivered — the repoint is what would have delivered it and
+            // it did not happen — but this warning already says so, precisely, so the
+            // ledger stays quiet about that pair rather than duplicating it. (When
+            // the affected psets produced replacement content, the property-set pass
+            // above has already recorded the emission, and an emission outranks an
+            // acknowledgement.)
+            modifications.acknowledgeUndelivered(entityId, 'property-set');
+            // `line` is byte-for-byte what the source-iteration pass would have
+            // written, so emit it wherever that pass would have run. Under
+            // `deltaOnly` it does not run, and a line the mutation pipeline left
+            // identical to its source is not a change — it has no place in a delta.
+            const changed = line !== sourceLine;
+            if (options.deltaOnly !== true || changed) {
+                rewrittenEntityLines.set(entityId, line);
+            }
+            // The ledger stays honest about WHICH modification landed: the
+            // property-set edit that nominated this host is the thing that just
+            // failed, so only the entity's OTHER edits are in this line. Under the
+            // per-kind keying that comes out as `attribute/retype/positional:
+            // delivered, property-set: undelivered` — the host still counts once,
+            // because a real change of its did land.
+            if (changed) {
+                recordSourceLineDelivery(modifications, entityId, mutated);
+                // Same site rule as the repoint branch above: the failed repoint is
+                // what did not land, and the line still carries the host's OTHER edits.
+                nominateDeliveredInPlaceEdits(modifications, entityId, mutated, inPlaceNominees);
             }
         }
         // Generate new quantity entities for mutations
@@ -773,6 +1075,8 @@ export class StepExporter {
             const newEntities = this.generateQuantitySetEntities(entityId, qsets, willBeEmitted, options.guidRandom);
             entities.push(...newEntities.lines);
             newEntityCount += newEntities.count;
+            if (newEntities.lines.length > 0)
+                modifications.recordEmitted(entityId, 'quantity-set');
         }
         for (const rewrittenLine of rewrittenEntityLines.values()) {
             entities.push(rewrittenLine);
@@ -863,6 +1167,13 @@ export class StepExporter {
                 }
             }
         }
+        // Settle the count against what the passes above actually wrote, and say
+        // out loud every KIND of edit a delta could not carry, per host. Silence
+        // was the other half of #2462: `deltaOnly` skips the source-iteration pass,
+        // so an in-place edit to a source entity is not in the file and never was —
+        // the header merely used to claim otherwise.
+        const { modifiedEntityCount, warnings: deltaWarnings } = modifications.settle();
+        warnings.push(...deltaWarnings);
         // Assemble final file as Uint8Array chunks to avoid V8 string length limit.
         // The header is built last so its provenance item reflects the real count.
         const header = buildHeader(newEntityCount + modifiedEntityCount);
@@ -989,7 +1300,10 @@ export class StepExporter {
             return result;
         }
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        if (entityRef && this.dataStore.source && entityRef.byteLength > 0) {
+        // Readability rather than presence, as everywhere else (#2491). A clamped
+        // decode would match nothing here, so this is tidiness rather than a bug —
+        // but the gates in this file agree on one predicate now.
+        if (entityRef && createSourceRefReader(this.dataStore.source)(entityRef)) {
             const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
             // #ID=IFCWALL('GlobalId',#owner,...): GlobalId is a quoted STEP string
             // (doubled '' escapes); OwnerHistory is the ref/`$` right after it.
@@ -1013,7 +1327,12 @@ export class StepExporter {
             for (const prop of pset.properties) {
                 const propId = this.nextExpressId++;
                 count++;
-                const valueStr = serializePropertyValue(prop.value, prop.type);
+                // `prop.dataType`, not `prop.type` alone: regenerating the set rewrites
+                // every property in it, and the shape-derived primitive would re-declare
+                // the ones nobody edited (`IFCTEXT` → `IFCLABEL`, `IFCLENGTHMEASURE` →
+                // `IFCREAL`). See `declared-property-type.ts` for when the source token
+                // is trusted (#2482).
+                const valueStr = serializeNominalValue(prop.value, prop.type, prop.dataType);
                 const unitId = prop.unit ? this.findUnitId(prop.unit, effective) : null;
                 const unitStr = unitId !== null ? ref(unitId) : null;
                 // #ID=IFCPROPERTYSINGLEVALUE('Name',$,Value,Unit);
@@ -1079,6 +1398,86 @@ export class StepExporter {
         }
         return { lines, count };
     }
+    /**
+     * THE mutation pipeline for a line read out of the source buffer: retype,
+     * then named attribute edits, then positional edits.
+     *
+     * **One implementation, two call sites**, and that is the whole point. Two
+     * passes can write the defining line of a source entity — the
+     * source-iteration pass, and the type-object `HasPropertySets` rewrite that
+     * REPLACES it (`rewrittenEntityIds` makes the source pass skip those ids).
+     * The rewrite used to do its own thing (replace slot 5, nothing else), so
+     * every other edit to a type object with a type-owned pset edit was dropped
+     * in silence: first the renames (#2462 follow-up), and after those were
+     * special-cased here, still the retypes and the positional edits. Whatever
+     * the source pass applies, the rewrite has to apply too, or the next edit
+     * kind added to one site goes missing at the other.
+     *
+     * The order is load-bearing:
+     *
+     *   - the retype runs FIRST so named attribute edits resolve against the
+     *     TARGET class's attribute names, and so positional slots are indexed
+     *     into the retyped argument list;
+     *   - the `HasPropertySets` replacement (rewrite path only) runs LAST, on
+     *     the text this returns. Run it first and a positional edit to slot 5 —
+     *     or a retype's argument-list rebuild — overwrites the resolved pset
+     *     list with the stale one, which is the same silent drop one slot over.
+     *
+     * The expressId is unchanged by all of this, so geometry / placement /
+     * representation and every IfcRel* reference (keyed by #id) carry over.
+     *
+     * All three flags report EFFECT, not intent — each is the answer to "did this
+     * operation change the line", measured across that operation alone. The count
+     * and the ledger are claims about the FILE, so an edit that resolves to the
+     * text already there has delivered nothing and must not be reported: retyping
+     * an entity to the class it already is, or writing a positional slot the token
+     * it already holds, used to count as a modification and reach the ledger as a
+     * landed edit, over a byte-identical line. Discarded edits read the same way:
+     * `applyAttributeMutations` drops a name its class has no slot for and
+     * `retypeStepLine` returns an unparseable line untouched, and neither is a
+     * modification of anything.
+     *
+     * `retyped` / `positional` matter most in a FULL export, which is where the
+     * two are nominated (their edits have no earlier nomination site); named
+     * attribute edits are nominated by the collection pass and `attributed` only
+     * settles their delivery.
+     */
+    applySourceLineMutations(expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive) {
+        let text = entityText;
+        let workingType = recordType.toUpperCase();
+        const typeMutation = overlayActive && typeof this.mutationView.getEntityTypeMutation === 'function'
+            ? this.mutationView.getEntityTypeMutation(expressId)
+            : null;
+        let retyped = false;
+        if (typeMutation) {
+            const beforeRetype = text;
+            text = retypeStepLine(text, recordType, typeMutation.newType, typeMutation.predefinedType ?? null, sourceSchema);
+            retyped = text !== beforeRetype;
+            // Set even for a no-op retype: the entity IS the target class from here
+            // on, so the named and positional edits below must resolve against it.
+            workingType = typeMutation.newType.toUpperCase();
+        }
+        // `applyAttributeMutations` returns its input UNCHANGED when it wrote
+        // nothing — no slot resolved for any of the names, or the line does not
+        // parse — so comparing is what tells the ledger whether a named attribute
+        // edit was really carried, rather than merely attempted.
+        let attributed = false;
+        if (attributeMutations && attributeMutations.size > 0) {
+            const beforeAttributes = text;
+            text = this.applyAttributeMutations(text, workingType, attributeMutations);
+            attributed = text !== beforeAttributes;
+        }
+        const positionals = overlayActive && typeof this.mutationView.getPositionalMutationsForEntity === 'function'
+            ? this.mutationView.getPositionalMutationsForEntity(expressId)
+            : null;
+        let positional = false;
+        if (positionals && positionals.size > 0) {
+            const beforePositionals = text;
+            text = this.applyPositionalMutations(text, positionals, workingType, sourceSchema);
+            positional = text !== beforePositionals;
+        }
+        return { text, attributed, retyped, positional };
+    }
     /**
      * Rewrite root IFC attributes directly on the original STEP entity line.
      */
@@ -1617,24 +2016,6 @@ export class StepExporter {
             return [];
         return hasPropertySets.filter((value) => typeof value === 'number');
     }
-    /**
-     * Replace a single top-level STEP attribute in an entity line.
-     */
-    replaceEntityAttribute(entityId, attrIndex, replacement) {
-        const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        if (!entityRef || !this.dataStore.source)
-            return null;
-        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
-        const match = entityText.match(/^(#\d+\s*=\s*\w+\()([\s\S]*)(\)\s*;)\s*$/);
-        if (!match)
-            return null;
-        const [, prefix, attrsText, suffix] = match;
-        const attrs = splitTopLevelStepArguments(attrsText);
-        if (attrIndex >= attrs.length)
-            return null;
-        attrs[attrIndex] = replacement;
-        return `${prefix}${attrs.join(',')}${suffix}`;
-    }
 }
 /**
  * Quick export function for simple use cases.