@ifc-lite/export 2.8.1 → 2.8.4

package/dist/step-exporter.js

@@ -1,21 +1,65 @@
 /* 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, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
-import { safeUtf8Decode } from '@ifc-lite/data';
+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
+ * `safeUtf8Decode(source, …)` calls this file used to make: `decodeUtf8` is
+ * SAB-safe in exactly the same way, and routing through the accessor is what
+ * lets `IfcDataStore.source` change shape without touching these eight reads.
+ */
+function decodeRange(src, start, end) {
+    return asSourceBytes(src).decodeUtf8(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.
+ */
+const MAP_CONVERSION_WITHOUT_CONTEXT_WARNING = 'Cannot create IfcMapConversion: no IfcGeometricRepresentationContext is available to reference as SourceCRS. The IfcProjectedCRS is unaffected.';
+/**
+ * Message for the refusal `export()` reports when a map conversion is
+ * requested but there is no IfcProjectedCRS to attach it to — none was
+ * requested and none exists in the file — distinct from
+ * {@link MAP_CONVERSION_WITHOUT_CONTEXT_WARNING}, which is worded for the
+ * case where an IfcProjectedCRS exists (or was written) but no context is
+ * available to reference.
+ */
+const MAP_CONVERSION_WITHOUT_CRS_WARNING = 'Cannot create IfcMapConversion: no IfcProjectedCRS was requested and none exists in the file to reference as TargetCRS. Nothing was written.';
 /**
  * IFC STEP file exporter
  */
@@ -45,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
@@ -69,7 +112,9 @@ export class StepExporter {
         // `sourceHeader`; fall back to parsing the (always-present) source bytes so
         // cache-restored stores — which don't carry `sourceHeader` — still work.
         const sourceHeader = this.dataStore.sourceHeader
-            ?? (this.dataStore.source ? parseSourceHeader(this.dataStore.source) : undefined);
+            ?? (this.dataStore.source.byteLength > 0
+                ? parseSourceHeader(this.dataStore.source)
+                : undefined);
         // Preserve the exact FILE_SCHEMA identifier (e.g. IFC4X3_ADD2) only when we
         // are NOT converting schemas; conversion must emit the coarse target token.
         const schemaToken = !converting && sourceHeader?.schemaIdentifiers?.[0]
@@ -115,9 +160,88 @@ 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
+        // 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).
+        //
+        // Computed here, ahead of the modification-count passes below, because
+        // `hasEmittableHostBytes` needs it: a source-backed host EXCLUDED by
+        // `visibleOnly` never gets its line written by the source-iteration pass
+        // either, so counting it as "modified" would make the header claim a
+        // change the DATA section does not contain (CodeRabbit finding on #2414).
+        let allowedEntityIds = null;
+        if (options.visibleOnly && this.dataStore.source) {
+            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: effective, byType: effective.byType });
+        }
+        // Will THIS entity's own line ever land in the file? The same byte-range
+        // test `willBeEmitted` uses (defined further below) and the source-
+        // iteration pass's own skip at `entityRef.byteLength === 0` — a source
+        // entity with no bytes (a point-cloud / GLB "entity" from
+        // `createSyntheticDataStore`, not an overlay-created one) never gets a
+        // defining line written, source-iteration or otherwise, so a pset/attribute
+        // edit against it must not count as a modification either: the header
+        // would describe a change the file does not contain (out-of-scope finding
+        // in #2398). Also excludes a source-backed host the visible-only closure
+        // above drops — same reasoning, different reason the line never lands.
+        //
+        // And, like `willBeEmitted` below, excludes a geometry-classified SOURCE
+        // host under `includeGeometry: false`: the source-iteration pass's own
+        // `isGeometryEntity` skip (further below) drops that line too, so this
+        // predicate must agree or a geometry entity's attribute edit inflates the
+        // count over an omitted line (CodeRabbit finding on #2414). Guarded by
+        // `!deltaOnly` for the same reason `willBeEmitted` is: under `deltaOnly`
+        // the source-iteration pass — and its geometry skip — never runs at all,
+        // so a source entity's line is assumed to already exist in the file being
+        // patched, geometry or not.
+        const isGeometryExcluded = (entityId, recordType) => options.includeGeometry === false
+            && this.isGeometryEntity(effective.effectiveType(entityId, recordType));
+        const hasEmittableHostBytes = (entityId) => {
+            if (allowedEntityIds !== null && !allowedEntityIds.has(entityId))
+                return false;
+            const ref = effective.get(entityId);
+            // 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 = [];
@@ -210,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))
-                    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));
@@ -243,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');
                         }
                     }
                 }
@@ -259,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)) {
@@ -275,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))
-                    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');
                         }
                     }
                 }
@@ -313,17 +558,51 @@ export class StepExporter {
                 // one created-then-renamed wall.
                 if (isOverlayCreated(entityId))
                     continue;
-                if (!entityPropMutations.has(entityId) && !entityQuantMutations.has(entityId)) {
-                    modifiedEntityCount++;
-                }
+                // A source entity with no bytes never gets its line rewritten (the
+                // source-iteration pass skips it), so an attribute edit against it
+                // must not inflate the count either.
+                if (!hasEmittableHostBytes(entityId))
+                    continue;
+                // 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)
         const newGeorefLines = [];
+        const warnings = [];
         if (options.applyMutations !== false && options.georefMutations) {
             const gm = options.georefMutations;
-            const existingCrsIds = this.dataStore.entityIndex.byType.get('IFCPROJECTEDCRS');
-            const existingMcIds = this.dataStore.entityIndex.byType.get('IFCMAPCONVERSION');
+            // `effective.byType`, not the raw index: a source IfcProjectedCRS the
+            // session tombstoned is still in `dataStore.entityIndex`, so the modify
+            // branch below would queue attribute edits against an id the
+            // source-iteration pass then skips — the replacement georeferencing
+            // vanishes from the file with no error. `effective.byType` drops
+            // tombstones and adds overlay-created records, which the new-entities
+            // pass applies `modifiedAttributes` to, so both branches agree on which
+            // georeferencing entities exist (#2048).
+            const existingCrsIds = effective.byType.get('IFCPROJECTEDCRS');
+            const existingMcIds = effective.byType.get('IFCMAPCONVERSION');
             // Modify existing IfcProjectedCRS
             if (gm.projectedCRS && existingCrsIds?.length) {
                 const entityId = existingCrsIds[0];
@@ -358,13 +637,29 @@ export class StepExporter {
                     changed = true;
                 }
                 if (crs.mapUnit !== undefined) {
-                    const mapUnitRef = this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines);
+                    const mapUnitRef = this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines, effective);
                     attrMap.set('MapUnit', `#${mapUnitRef}`);
                     changed = true;
                 }
-                if (changed && !modifiedEntities.has(entityId)) {
+                if (changed) {
                     modifiedEntities.add(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
@@ -400,9 +695,14 @@ export class StepExporter {
                     attrMap.set('Scale', String(mc.scale));
                     changed = true;
                 }
-                if (changed && !modifiedEntities.has(entityId)) {
+                if (changed) {
                     modifiedEntities.add(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
@@ -417,12 +717,12 @@ export class StepExporter {
                 const proj = crs.mapProjection ? `'${escapeStepString(String(crs.mapProjection))}'` : '$';
                 const zone = crs.mapZone ? `'${escapeStepString(String(crs.mapZone))}'` : '$';
                 const mapUnitRef = crs.mapUnit
-                    ? `#${this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines)}`
+                    ? `#${this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines, effective)}`
                     : '$';
                 newGeorefLines.push(`#${crsId}=IFCPROJECTEDCRS(${name},${desc},${datum},${vDatum},${proj},${zone},${mapUnitRef});`);
                 newEntityCount++;
                 // Find IfcGeometricRepresentationContext as SourceCRS for MapConversion
-                const contextId = this.findPreferredGeometricRepresentationContextId();
+                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
                 if (contextId) {
                     const mc = gm.mapConversion || {};
                     const mcId = this.nextExpressId++;
@@ -437,12 +737,12 @@ export class StepExporter {
                     newEntityCount++;
                 }
                 else {
-                    console.warn('[StepExporter] Cannot create IfcMapConversion: no IfcGeometricRepresentationContext found in source file');
+                    this.reportMapConversionRefused(warnings);
                 }
             }
             else if (gm.mapConversion && !existingMcIds?.length && existingCrsIds?.length) {
                 // CRS exists but no MapConversion — create just the conversion
-                const contextId = this.findPreferredGeometricRepresentationContextId();
+                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
                 if (contextId) {
                     const mc = gm.mapConversion;
                     const mcId = this.nextExpressId++;
@@ -456,9 +756,17 @@ export class StepExporter {
                     newEntityCount++;
                 }
                 else {
-                    console.warn('[StepExporter] Cannot create IfcMapConversion: no IfcGeometricRepresentationContext found in source file');
+                    this.reportMapConversionRefused(warnings);
                 }
             }
+            else if (gm.mapConversion && !existingMcIds?.length && !existingCrsIds?.length) {
+                // A map conversion was requested, but there is no IfcProjectedCRS to
+                // reference as TargetCRS: none was requested (the first branch above
+                // didn't fire) and none exists in the file. Both CREATE branches are
+                // skipped, so nothing is attempted — report the refusal so the
+                // caller isn't left with an empty stats.warnings and no hint (#2105).
+                this.reportMapConversionRefusedNoCrs(warnings);
+            }
         }
         // If delta only, only export modified entities. Overlay-created entities
         // also count — without this, `createEntity()`-only edits would silently
@@ -480,25 +788,10 @@ export class StepExporter {
                     newEntityCount: 0,
                     modifiedEntityCount: 0,
                     fileSize: emptyContent.byteLength,
+                    warnings,
                 },
             };
         }
-        // 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, 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: effective, byType: effective.byType });
-        }
         /**
          * Will this id have a defining STEP line in the output at all?
          *
@@ -540,7 +833,24 @@ export class StepExporter {
                 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);
+            if (effective.isOverlayCreated(entityId)) {
+                // The overlay new-entities pass applies its OWN `isGeometryEntity`
+                // filter unconditionally — deltaOnly or not (see the comment at that
+                // loop, further below) — so this branch mirrors it without the
+                // deltaOnly carve-out the source branch gets.
+                return !isGeometryExcluded(entityId, ref.type);
+            }
+            // 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
+            // entity's line is assumed to already exist in the file being patched.
+            if (options.deltaOnly === true)
+                return true;
+            return !isGeometryExcluded(entityId, ref.type);
         };
         // A modified pset is replaced wholesale, which skips ALL of its member atoms.
         // But IFC exporters deduplicate identical Pset_*Common atoms (e.g. one
@@ -555,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
@@ -577,47 +891,34 @@ export class StepExporter {
                 if (options.includeGeometry === false && this.isGeometryEntity(entityType)) {
                     continue;
                 }
-                // Get original entity text — safeUtf8Decode handles SAB-backed
+                // Get original entity text — decodeRange handles SAB-backed
                 // sources (Firefox/Chrome reject `TextDecoder.decode()` on a
                 // SharedArrayBuffer-backed view; the parser deliberately keeps
                 // `source` zero-copy SAB-backed for worker sharing).
-                const entityText = safeUtf8Decode(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++;
-                    }
-                }
+                const entityText = decodeRange(source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+                // 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);
@@ -638,9 +939,13 @@ export class StepExporter {
             // see `willBeEmitted` (#1978, #2030, #2012).
             if (!willBeEmitted(entityId))
                 continue;
-            const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
+            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
@@ -659,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
@@ -671,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);
@@ -761,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);
@@ -772,6 +1185,7 @@ export class StepExporter {
                 newEntityCount,
                 modifiedEntityCount,
                 fileSize: content.byteLength,
+                warnings,
             },
         };
     }
@@ -886,8 +1300,11 @@ export class StepExporter {
             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);
+        // 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.
             const match = entityText.match(/=\s*IFC\w+\s*\(\s*'(?:[^']|'')*'\s*,\s*#(\d+)/i);
@@ -900,7 +1317,7 @@ export class StepExporter {
     /**
      * Generate STEP entities for property sets
      */
-    generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNames, random) {
+    generatePropertySetEntities(entityId, psets, willBeEmitted, effective, typeOwnedPsetNames, random) {
         const lines = [];
         let count = 0;
         const generatedTypeOwnedPsetIds = new Map();
@@ -910,8 +1327,13 @@ export class StepExporter {
             for (const prop of pset.properties) {
                 const propId = this.nextExpressId++;
                 count++;
-                const valueStr = serializePropertyValue(prop.value, prop.type);
-                const unitId = prop.unit ? this.findUnitId(prop.unit) : null;
+                // `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);
                 const line = `#${propId}=IFCPROPERTYSINGLEVALUE('${escapeStepString(prop.name)}',$,${valueStr},${unitStr ? serializeValue(unitStr) : '$'});`;
@@ -976,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.
      */
@@ -1141,9 +1643,9 @@ export class StepExporter {
         const forceReal = realSlots.has(index) || tokenIsRealLiteral(currentToken);
         return serializeStepValue(value, forceReal);
     }
-    resolveMapUnitReference(unitName, newGeorefLines) {
+    resolveMapUnitReference(unitName, newGeorefLines, effective) {
         const normalized = this.normalizeMapUnitName(unitName);
-        const existing = this.findLengthUnitReference(normalized);
+        const existing = this.findLengthUnitReference(normalized, effective);
         if (existing !== null) {
             return existing;
         }
@@ -1179,14 +1681,22 @@ export class StepExporter {
             return 'FOOT';
         return normalized;
     }
-    findLengthUnitReference(preferredUnitName) {
+    /**
+     * `effective` filters the candidates the same way the georef reads above do:
+     * returning a tombstoned unit id hands the caller a `#id` for a line the
+     * export never writes. Returning null instead makes `resolveMapUnitReference`
+     * synthesise a fresh unit, which is the outcome a deleted unit deserves.
+     */
+    findLengthUnitReference(preferredUnitName, effective) {
         if (!this.entityExtractor)
             return null;
-        const projectIds = this.dataStore.entityIndex.byType.get('IFCPROJECT') ?? [];
-        const projectRef = projectIds[0] ? this.dataStore.entityIndex.byId.get(projectIds[0]) : undefined;
+        // Only source records carry the bytes `extractEntity` reads, so an
+        // overlay-created project is skipped rather than shadowing the file's own.
+        const projectId = (effective.byType.get('IFCPROJECT') ?? []).find((id) => this.dataStore.entityIndex.byId.has(id));
+        const projectRef = projectId !== undefined ? this.dataStore.entityIndex.byId.get(projectId) : undefined;
         const project = projectRef ? this.entityExtractor.extractEntity(projectRef) : null;
         const unitAssignmentId = project?.attributes?.[8];
-        if (typeof unitAssignmentId !== 'number')
+        if (typeof unitAssignmentId !== 'number' || effective.isDeleted(unitAssignmentId))
             return null;
         const unitAssignmentRef = this.dataStore.entityIndex.byId.get(unitAssignmentId);
         const unitAssignment = unitAssignmentRef ? this.entityExtractor.extractEntity(unitAssignmentRef) : null;
@@ -1194,7 +1704,7 @@ export class StepExporter {
         if (!Array.isArray(units))
             return null;
         for (const unitId of units) {
-            if (typeof unitId !== 'number')
+            if (typeof unitId !== 'number' || effective.isDeleted(unitId))
                 continue;
             const unitRef = this.dataStore.entityIndex.byId.get(unitId);
             const unit = unitRef ? this.entityExtractor.extractEntity(unitRef) : null;
@@ -1222,10 +1732,36 @@ export class StepExporter {
         }
         return null;
     }
-    findPreferredGeometricRepresentationContextId() {
+    /**
+     * Record that a requested IfcMapConversion could not be written. Emitting it
+     * anyway would leave `SourceCRS` pointing at nothing, so the refusal is the
+     * correct output — but the file alone cannot express it, which is why it goes
+     * back to the caller in `stats.warnings` as well as to the console (#2067).
+     */
+    reportMapConversionRefused(warnings) {
+        warnings.push(MAP_CONVERSION_WITHOUT_CONTEXT_WARNING);
+        console.warn(`[StepExporter] ${MAP_CONVERSION_WITHOUT_CONTEXT_WARNING}`);
+    }
+    /**
+     * Record that a requested IfcMapConversion could not be written because
+     * there is no IfcProjectedCRS to attach it to — a different refusal from
+     * {@link reportMapConversionRefused}: "no CRS to attach it to" rather than
+     * "no context to reference" (#2105).
+     */
+    reportMapConversionRefusedNoCrs(warnings) {
+        warnings.push(MAP_CONVERSION_WITHOUT_CRS_WARNING);
+        console.warn(`[StepExporter] ${MAP_CONVERSION_WITHOUT_CRS_WARNING}`);
+    }
+    /**
+     * `effective` again: the id returned here becomes the new IfcMapConversion's
+     * SourceCRS, so a tombstoned context would leave the created line pointing at
+     * a record the export skips — a dangling reference and an invalid file.
+     */
+    findPreferredGeometricRepresentationContextId(effective) {
         if (!this.entityExtractor)
             return null;
-        const contextIds = this.dataStore.entityIndex.byType.get('IFCGEOMETRICREPRESENTATIONCONTEXT') ?? [];
+        const contextIds = (effective.byType.get('IFCGEOMETRICREPRESENTATIONCONTEXT') ?? [])
+            .filter((id) => this.dataStore.entityIndex.byId.has(id));
         let first3dContext = null;
         for (const contextId of contextIds) {
             const contextRef = this.dataStore.entityIndex.byId.get(contextId);
@@ -1263,8 +1799,8 @@ export class StepExporter {
     /**
      * Find a unit entity ID by name (simplified - returns null for now)
      */
-    findUnitId(unitName) {
-        return this.findLengthUnitReference(this.normalizeMapUnitName(unitName));
+    findUnitId(unitName, effective) {
+        return this.findLengthUnitReference(this.normalizeMapUnitName(unitName), effective);
     }
     /**
      * Check if an entity type is a geometry-related type
@@ -1343,7 +1879,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(relId);
         if (!entityRef || !this.dataStore.source)
             return [];
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse IfcRelDefinesByProperties: #ID=IFCRELDEFINESBYPROPERTIES('guid',$,$,$,(#objects),#pset);
         // The 5th argument (index 4) is the list of related objects
         const match = entityText.match(/\(([^)]+)\)\s*,\s*#(\d+)\s*\)\s*;/);
@@ -1364,7 +1900,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(relId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Last #ID before the closing );
         const match = entityText.match(/,\s*#(\d+)\s*\)\s*;$/);
         if (!match)
@@ -1378,7 +1914,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(psetId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCPROPERTYSET('guid',$,'Name',$,...) - Name is 3rd argument
         const match = entityText.match(/IFCPROPERTYSET\s*\([^,]*,[^,]*,'([^']*)'/i);
         if (!match)
@@ -1392,7 +1928,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCELEMENTQUANTITY('guid',$,'Name',...) - Name is 3rd argument
         const match = entityText.match(/IFCELEMENTQUANTITY\s*\([^,]*,[^,]*,'([^']*)'/i);
         if (!match)
@@ -1440,7 +1976,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(psetId);
         if (!entityRef || !this.dataStore.source)
             return [];
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCPROPERTYSET(...,(#prop1,#prop2,...)); - Last argument is properties list
         const match = entityText.match(/\(\s*(#[^)]+)\s*\)\s*\)\s*;$/);
         if (!match)
@@ -1480,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 = safeUtf8Decode(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.