@ifc-lite/export 2.9.3 → 2.9.4

package/dist/step-exporter.js

@@ -1,65 +1,42 @@
 /* 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, extractQuantitiesOnDemand, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
-import { generateIfcGuid } from '@ifc-lite/encoding';
+import { EntityExtractor, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, } from '@ifc-lite/parser';
 import { collectReferencedEntityIds, getVisibleEntityIds, collectStyleEntities, filterHiddenRefsFromRelationshipLine, } 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 { createModificationLedger, } 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, isTypeClass, resolveTypeOwnedPsetIds, rewriteTypeOwnedPsetLine, typeOwnedPsetRewriteWarning, } from './type-owned-psets.js';
-import { escapeStepString, toStepReal, quantityTypeToIfcType, serializeAttributeValue, serializeStepValue, tokenIsRealLiteral, } from './step-serialization.js';
+import { createSourceRefReader, decodeRange } from './source-ref-bounds.js';
+import { buildRelDefinesByPropertiesIndex, collectPropertyAndQuantitySetMutations, generatePropertyAndQuantitySetEntities, getPropertyIdsInSet, } from './step-property-sets.js';
+import { applyGeoreferencingMutations } from './step-georeferencing.js';
+import { getEffectiveEntityIndex } from './effective-index.js';
+import { HAS_PROPERTY_SETS_SLOT } from './type-owned-psets.js';
+import { toStepReal, 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 four 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.
+ * Message for a relationship this export DROPPED rather than rewrote.
  *
- * 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.
+ * `filterHiddenRefsFromRelationshipLine` removes an omitted `#N` from a
+ * SET/LIST attribute, but a single-valued attribute has no STEP spelling for
+ * "omitted" and an empty SET is not the same statement as the original — so in
+ * both of those cases it withholds the whole line and the relationship simply
+ * is not in the output. Withholding beats shipping a dangling `#N`, but it is
+ * not free: every OTHER entity that relationship named loses the association.
+ * A visible element can therefore come out of a plain full export with one
+ * fewer pset than it went in with, and before this warning existed nothing in
+ * the result said so (adversarial review of #2668).
+ *
+ * Deliberately reports the relationship rather than the omitted target: the
+ * target's own omission is already the caller's own doing in every reason but
+ * the unreadable-ref one, whereas the lost association is the surprise.
  */
-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.';
+const relationshipWithheldWarning = (expressId, type) => `Relationship #${expressId} (${type}) was withheld from the export: it names at least one entity that has no line in this export, in a slot with no spelling for an omitted reference (a single-valued attribute, or a set whose every member is omitted). Anything else that relationship associated is no longer associated in the output.`;
 /**
  * IFC STEP file exporter
  */
@@ -68,11 +45,16 @@ export class StepExporter {
     mutationView;
     nextExpressId;
     entityExtractor;
-    /** Lazily-resolved fallback `#id` of an IfcOwnerHistory that survives the
-     *  current export closure (or `$` when the file has none). */
-    ownerHistoryFallbackRef;
-    /** Per-host cache of an element's own OwnerHistory ref (`#id` or null). */
-    ownerHistoryByEntity = new Map();
+    /**
+     * The owner-history memos the property-set and quantity-set generators read.
+     *
+     * Owned here and handed to `step-property-sets.ts` BY REFERENCE rather than
+     * stored on its context: the reset below is an `export()`-level statement,
+     * and the comment there is where "per export, not per exporter" is argued.
+     * Moving the storage into a per-export context would make that reset
+     * implicit — the same invariant, in a place nothing says it (#2475 step 2b).
+     */
+    ownerHistory = { fallbackRef: undefined, byEntity: new Map() };
     /**
      * "Can this record's line actually be read out of this store's source?"
      * (`source-ref-bounds.ts`, #2491). Built once — `dataStore` is assigned in
@@ -95,20 +77,33 @@ export class StepExporter {
      * Export to STEP format
      */
     export(options) {
-        const entities = [];
-        let newEntityCount = 0;
         // Both owner-history caches are per-EXPORT, not per-exporter: they now
         // depend on `willBeEmitted`, which depends on this call's options. Reusing
         // one exporter for a `visibleOnly` export and then a full one would
         // otherwise answer the second from the first one's closure.
-        this.ownerHistoryFallbackRef = undefined;
-        this.ownerHistoryByEntity.clear();
+        this.ownerHistory.fallbackRef = undefined;
+        this.ownerHistory.byEntity.clear();
         // Determine target schema from options, source schema from data store
         const schema = options.schema || this.dataStore.schemaVersion || 'IFC4';
         const sourceSchema = this.dataStore.schemaVersion || 'IFC4';
         const converting = needsConversion(sourceSchema, schema);
+        // Read ONCE, here, and consumed everywhere below instead of re-spelling
+        // `options.applyMutations !== false` per site. `options` is the caller's
+        // object and this export re-enters it dozens of times; an accessor that
+        // answered differently on the second read would have let the effective
+        // index be built WITH the overlay while a later guard — including the
+        // relationship-filter precondition — decided there was none. Reading each
+        // option that feeds that precondition exactly once makes the two agree by
+        // construction rather than by every site happening to spell it the same
+        // way (adversarial review of #2668's replacement gate).
+        const applyMutations = options.applyMutations !== false;
+        // Same, for the other option the precondition reads. `isGeometryExcluded`
+        // below and both output passes' own geometry skips consume this one const,
+        // so "the gate thinks geometry is included while the predicate thinks it is
+        // excluded" is not a state this export can reach.
+        const excludeGeometry = options.includeGeometry === false;
         if (schema === 'IFC2X3' &&
-            options.applyMutations !== false &&
+            applyMutations &&
             options.georefMutations &&
             (Object.keys(options.georefMutations.projectedCRS ?? {}).length > 0 ||
                 Object.keys(options.georefMutations.mapConversion ?? {}).length > 0)) {
@@ -128,184 +123,345 @@ export class StepExporter {
         const schemaToken = !converting && sourceHeader?.schemaIdentifiers?.[0]
             ? sourceHeader.schemaIdentifiers[0]
             : schema;
-        // Built once entity counts are known, so the provenance item can report the
-        // actual modification count. See the two call sites (empty delta + final).
-        const buildHeader = (modifications) => {
-            // FILE_DESCRIPTION items: an explicit option wins, else the source items
-            // verbatim, else the generic default.
-            const description = options.description !== undefined
-                ? [options.description]
-                : sourceHeader && sourceHeader.description.length > 0
-                    ? [...sourceHeader.description]
-                    : ['Exported from ifc-lite'];
-            // Honest provenance: never claim untouched source output. Append (never
-            // overwrite) one item when ifc-lite actually changed the file.
-            if (modifications > 0) {
-                description.push(`Re-exported by ifc-lite, ${modifications} modification${modifications === 1 ? '' : 's'}`);
-            }
-            return generateHeader({
-                schema: schemaToken,
-                description,
-                implementationLevel: sourceHeader?.implementationLevel,
-                author: options.author ?? sourceHeader?.author,
-                organization: options.organization ?? sourceHeader?.organization,
-                // preprocessor_version = the tool that WROTE this file (ifc-lite);
-                // originating_system keeps the source authoring tool so it isn't erased.
-                preprocessorVersion: options.application ?? 'ifc-lite',
-                originatingSystem: sourceHeader?.originatingSystem,
-                authorization: sourceHeader?.authorization,
-                application: options.application ?? 'ifc-lite',
-                filename: options.filename ?? 'export.ifc',
-                timeStamp: options.timeStamp,
-            });
+        // The one construction site for the state this export shares across its
+        // seven phases. See `ExportPass` above for what belongs here, what
+        // deliberately does not, and why every predicate reads `pass` rather than
+        // a value captured at construction time.
+        const pass = {
+            entities: [],
+            newEntityCount: 0,
+            schema,
+            sourceSchema,
+            converting,
+            sourceHeader,
+            schemaToken,
+            overlayActive: !!this.mutationView && applyMutations,
+            // Built once entity counts are known, so the provenance item can report the
+            // actual modification count. See the two call sites (empty delta + final).
+            buildHeader: (modifications) => {
+                // FILE_DESCRIPTION items: an explicit option wins, else the source items
+                // verbatim, else the generic default.
+                const description = options.description !== undefined
+                    ? [options.description]
+                    : sourceHeader && sourceHeader.description.length > 0
+                        ? [...sourceHeader.description]
+                        : ['Exported from ifc-lite'];
+                // Honest provenance: never claim untouched source output. Append (never
+                // overwrite) one item when ifc-lite actually changed the file.
+                if (modifications > 0) {
+                    description.push(`Re-exported by ifc-lite, ${modifications} modification${modifications === 1 ? '' : 's'}`);
+                }
+                return generateHeader({
+                    schema: schemaToken,
+                    description,
+                    implementationLevel: sourceHeader?.implementationLevel,
+                    author: options.author ?? sourceHeader?.author,
+                    organization: options.organization ?? sourceHeader?.organization,
+                    // preprocessor_version = the tool that WROTE this file (ifc-lite);
+                    // originating_system keeps the source authoring tool so it isn't erased.
+                    preprocessorVersion: options.application ?? 'ifc-lite',
+                    originatingSystem: sourceHeader?.originatingSystem,
+                    authorization: sourceHeader?.authorization,
+                    application: options.application ?? 'ifc-lite',
+                    filename: options.filename ?? 'export.ifc',
+                    timeStamp: options.timeStamp,
+                });
+            },
+            // The one authority for exists / class / deleted, overlay first and source
+            // buffer second. Every pass below asks this instead of `this.dataStore`,
+            // which answers only for the file as parsed (#2012).
+            effective: getEffectiveEntityIndex(this.dataStore, this.mutationView, applyMutations),
+            // Does this id belong to an entity the OVERLAY created (`createEntity` /
+            // `store.addEntity`) rather than to a record in the source buffer? Such an
+            // entity has no source bytes, so the source-iteration pass below never sees
+            // it and the new-entities pass at the end owns its line entirely (#2006).
+            isOverlayCreated: (entityId) => pass.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).
+            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).
+            allowedEntityIds: null,
+            // Populated alongside `allowedEntityIds` below. `getVisibleEntityIds`
+            // excludes a hidden PRODUCT's own line from the closure, but `IFCREL*` is
+            // an unconditional root a few lines down and its bytes are copied verbatim
+            // by the source-iteration pass — nothing there filters a `#N` the closure
+            // just excluded out of the relationship's own attribute list. Kept because
+            // the closure walk's `isRefExcludedDuringClosureWalk` needs a notion of
+            // "hidden" that does not read `allowedEntityIds` — the set that walk is
+            // producing (#2398). The two OUTPUT passes no longer read this directly:
+            // they filter on `isOmittedFromOutput`, which subsumes it via
+            // `allowedEntityIds`.
+            hiddenProductIds: null,
+            // A relationship can name an excluded entity two ways that have nothing
+            // to do with each other: a `visibleOnly` hidden PRODUCT (`hiddenProductIds`,
+            // below), and a TOMBSTONED one — `editor.removeEntity` on a related object
+            // named by a relationship the deletion sweep below does not reach (that
+            // sweep only withholds an `IfcRelDefinesByProperties` when EVERY related
+            // object is gone, and only for that one relationship class). Left alone, a
+            // relationship still naming a deleted entity ships the identical `#N` with
+            // no `#N=` line, on a path with no `visibleOnly` involved at all (#2398).
+            // `effective.isDeleted` answers for every id, not just a precomputed set,
+            // so this predicate covers both sources without a second exclusion set.
+            //
+            // Declared here, ahead of the closure walk below, and passed into
+            // `collectReferencedEntityIds` as its `isRefExcluded` — rather than the
+            // walk inventing its own `!entityIndex.has` proxy for "deleted" that could
+            // disagree on an id that never existed in the file at all
+            // (maintainer-found regression on #2637: such an id blocked the bridge but
+            // did not stop the relationship's own line from shipping, dropping a
+            // VISIBLE sibling's pset while adding a fresh dangling ref). A closure over
+            // `pass.hiddenProductIds`, not a value snapshot — correct because nothing
+            // reads it before the closure walk assigns it just below.
+            //
+            // ## Why this is NOT the predicate the OUTPUT-line filter uses
+            //
+            // The name says walk, and only walk. The two passes that write a
+            // relationship's line ask `isOmittedFromOutput` (further below, derived
+            // from `pass.willBeEmitted`), which is strictly stronger — it also answers
+            // for the closure, for an unreadable source ref and for a geometry
+            // exclusion.
+            //
+            // This one CANNOT be `willBeEmitted`, and the difference is structural
+            // rather than stylistic: `willBeEmitted`'s first act is to consult
+            // `allowedEntityIds`, and `allowedEntityIds` is precisely what the call
+            // below is computing. Wiring it in here is circular: it would answer "not
+            // in the closure" as `false` while the closure is still being built and
+            // `true` for the same id afterwards.
+            //
+            // That is a genuine departure from the contract #2637 was closed on —
+            // `reference-collector.ts` still documents the bridge as taking the
+            // caller's OWN output predicate, "not two expressions that happened to
+            // agree". It has an OBSERVABLE consequence, not just a naming one: for an
+            // unreadable source ref this admits, the walk bridges through a
+            // relationship the output then withholds, leaving the relationship's other
+            // target in the closure with nothing naming it — an orphan, pinned by
+            // `unreadable-ref-dangling.test.ts` ("walk and output predicates diverge").
+            // The reverse direction is closed: every id this excludes,
+            // `isOmittedFromOutput` excludes too, so the #2548 leak cannot return.
+            isRefExcludedDuringClosureWalk: (id) => (pass.hiddenProductIds !== null && pass.hiddenProductIds.has(id))
+                || pass.effective.isDeleted(id),
+            // 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.
+            isGeometryExcluded: (entityId, recordType) => excludeGeometry
+                && this.isGeometryEntity(pass.effective.effectiveType(entityId, recordType)),
+            hasEmittableHostBytes: (entityId) => {
+                if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                    return false;
+                const ref = pass.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 || !pass.isReadableSourceRef(ref))
+                    return false;
+                if (options.deltaOnly !== true && pass.isGeometryExcluded(entityId, ref.type))
+                    return false;
+                return true;
+            },
+            /**
+             * Will this id have a defining STEP line in the output at all?
+             *
+             * The predicate is #2030's, and it is the right one: the pset, quantity and
+             * type-owned passes below are built from unfiltered mutation history, and
+             * what each of them needs to know before emitting an
+             * `IFCRELDEFINESBYPROPERTIES` is not "was this deleted" or "is this hidden"
+             * but the general question those are two answers to. A relation naming an
+             * expressId that never gets written is a dangling reference and an invalid
+             * file, whichever route dropped the line.
+             *
+             * #2030 had to reach for four things to answer it — a tombstone probe, a
+             * visibility set, a byte-range test on `completeIndex`, and a `getNewEntity`
+             * fallback whose stated purpose was that `deleteEntity` FORGOT an
+             * overlay-created entity instead of tombstoning it, so `isDeleted` could not
+             * answer for one. That fallback was documented on main as a workaround for
+             * exactly the model-level defect this branch fixes: `deleteEntity` now
+             * tombstones as well as forgets, so the effective index answers existence
+             * for source and overlay ids alike and the workaround collapses into it.
+             *
+             * The overlay branch does NOT disappear with it, and the distinction matters:
+             * `isOverlayCreated` is still load-bearing here, because a live
+             * overlay-created entity has no source bytes and would fail the byte-range
+             * test that a source record passes. What the tombstone fix removed is the
+             * need for that branch to double as a deletion detector.
+             *
+             * Deliberately unchanged from #2030 for source records under `deltaOnly` /
+             * `exportPropertiesOnly`: the source-iteration pass is skipped wholesale in
+             * those modes, yet a source entity still answers true here. A delta is a
+             * patch against a file that already has the line, not a standalone model.
+             */
+            willBeEmitted: (entityId) => {
+                if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                    return false;
+                // Undefined for a tombstoned id and for one neither the file nor the
+                // session ever had — a stale mutation must not conjure a relation either.
+                const ref = pass.effective.get(entityId);
+                if (!ref)
+                    return false;
+                // An overlay-created record carries the placeholder byte range and is
+                // written by the new-entities pass; a source record needs real bytes.
+                if (pass.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 !pass.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 (!pass.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 !pass.isGeometryExcluded(entityId, ref.type);
+            },
+            // 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).
+            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).
+             */
+            inPlaceNominees: {
+                attribute: new Set(),
+                georeferencing: new Set(),
+            },
+            // Collect entities that need to be modified or created
+            modifiedEntities: new Set(),
+            modifiedAttributes: new Map(),
+            newPropertySets: [],
+            newQuantitySets: [],
+            typeOwnedPsetNamesByEntity: new Map(),
+            typeOwnedPsetIdsByEntity: new Map(),
+            rewrittenEntityIds: new Set(),
+            rewrittenEntityLines: new Map(),
+            /** HasPropertySets slot value for an OVERLAY-CREATED type object, applied
+             *  by the new-entities pass (there is no source line to rewrite). */
+            overlayTypeOwnedPsets: new Map(),
+            // Track property set IDs and relationship IDs to skip
+            skipPropertySetIds: new Set(),
+            skipRelationshipIds: new Set(),
+            // Written by the georeferencing pass and read again by the final
+            // assembly, which is why they are pass state and not phase locals.
+            newGeorefLines: [],
+            warnings: [],
         };
-        // The one authority for exists / class / deleted, overlay first and source
-        // buffer second. Every pass below asks this instead of `this.dataStore`,
-        // which answers only for the file as parsed (#2012).
-        const effective = getEffectiveEntityIndex(this.dataStore, this.mutationView, options.applyMutations !== false);
-        // Does this id belong to an entity the OVERLAY created (`createEntity` /
-        // `store.addEntity`) rather than to a record in the source buffer? Such an
-        // entity has no source bytes, so the source-iteration pass below never sees
-        // it and the new-entities pass at the end owns its line entirely (#2006).
-        const isOverlayCreated = (entityId) => effective.isOverlayCreated(entityId);
-        // 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;
-        // Populated alongside `allowedEntityIds` below. `getVisibleEntityIds`
-        // excludes a hidden PRODUCT's own line from the closure, but `IFCREL*` is
-        // an unconditional root a few lines down and its bytes are copied verbatim
-        // by the source-iteration pass — nothing there filters a `#N` the closure
-        // just excluded out of the relationship's own attribute list. Kept so the
-        // source-iteration and overlay new-entity passes can run
-        // `filterHiddenRefsFromRelationshipLine` against the SAME exclusion set
-        // `collectReferencedEntityIds` used, rather than a second, possibly
-        // divergent notion of "hidden" (#2398).
-        let hiddenProductIds = null;
-        // A relationship can name an excluded entity two ways that have nothing
-        // to do with each other: a `visibleOnly` hidden PRODUCT (`hiddenProductIds`,
-        // below), and a TOMBSTONED one — `editor.removeEntity` on a related object
-        // named by a relationship the deletion sweep below does not reach (that
-        // sweep only withholds an `IfcRelDefinesByProperties` when EVERY related
-        // object is gone, and only for that one relationship class). Left alone, a
-        // relationship still naming a deleted entity ships the identical `#N` with
-        // no `#N=` line, on a path with no `visibleOnly` involved at all (#2398).
-        // `effective.isDeleted` answers for every id, not just a precomputed set,
-        // so this predicate covers both sources without a second exclusion set.
-        //
-        // Declared here, ahead of the closure walk below, and passed into
-        // `collectReferencedEntityIds` as its `isRefExcluded` — the walk's bridge
-        // decision (whether an `IFCREL*` root may reach what it names) and the
-        // OUTPUT-line filtering further down now read the SAME predicate, rather
-        // than the walk inventing its own `!entityIndex.has` proxy for "deleted"
-        // that could disagree with this one on an id that never existed in the
-        // file at all (maintainer-found regression on #2637: such an id blocked
-        // the bridge but did not stop the relationship's own line from shipping,
-        // dropping a VISIBLE sibling's pset while adding a fresh dangling ref).
-        // A closure over the `let hiddenProductIds` above, not a value snapshot —
-        // correct because nothing reads it before `hiddenProductIds` is assigned
-        // just below.
-        const isExcludedFromRelationshipRefs = (id) => (hiddenProductIds !== null && hiddenProductIds.has(id)) || effective.isDeleted(id);
         if (options.visibleOnly && this.dataStore.source) {
-            const visible = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, effective);
-            hiddenProductIds = visible.hiddenProductIds;
-            allowedEntityIds = collectReferencedEntityIds(visible.roots, this.dataStore.source, effective, visible.hiddenProductIds, isExcludedFromRelationshipRefs);
+            const visible = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, pass.effective);
+            pass.hiddenProductIds = visible.hiddenProductIds;
+            pass.allowedEntityIds = collectReferencedEntityIds(visible.roots, this.dataStore.source, pass.effective, visible.hiddenProductIds, pass.isRefExcludedDuringClosureWalk);
             // 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 });
+            collectStyleEntities(pass.allowedEntityIds, this.dataStore.source, { byId: pass.effective, byType: pass.effective.byType });
         }
-        // `overlayActive` proper (used everywhere else) is declared further below,
-        // ahead of the mutation-processing block it gates; duplicated here as the
-        // same expression rather than reordering that declaration.
-        const mayNameExcludedRefs = (hiddenProductIds !== null && hiddenProductIds.size > 0)
-            || (!!this.mutationView && options.applyMutations !== false);
-        // 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).
+         * "Does this model hold a record whose bytes this export cannot read?" —
+         * the one disjunct of {@link mayNameOmittedRefs} that is not already a
+         * value in hand, so it is a function and called last, behind `||`.
+         *
+         * Scans the EFFECTIVE index, and that is a requirement rather than an
+         * implementation detail: it has to cover the id space
+         * `isOmittedFromOutput` answers over, and an unreadable record can live in
+         * `deferredEntityIndex` — the secondary index `getCompleteEntityIndex`
+         * exists to merge — and nowhere in `entityIndex.byId`. Scanning `byId`,
+         * the obvious cheaper source, was measured to leave the gate false and
+         * ship the dangling ref; `relationship-filter-gate.test.ts` pins the
+         * merged scan behaviourally so that shortcut cannot come back as an
+         * optimisation.
+         *
+         * Reads the ref ITERATION yields — what the source-iteration pass's own
+         * skip reads — rather than re-asking `effective.get(id)` per id as
+         * `willBeEmitted` does, which on the largest files would cost a binary
+         * search and an allocation per entity and defeat the point of the gate.
+         * Every index here keeps the two in step by construction:
+         * `CompactEntityIndex` serves `get`, `has` and iteration from one pair of
+         * `Uint32Array`s, a `Map` trivially agrees, the merged deferred view is
+         * `byId.get ?? deferred.get` over `yield* byId; yield* deferred`, and
+         * `OverlayIndex` filters both by one tombstone set. An index whose `has`
+         * accepted an id its iteration never yields would defeat this — and would
+         * equally defeat the source-iteration pass's skip, so that file is broken
+         * either way; nothing in the repo builds one.
+         *
+         * Not short-circuited on `overlayActive`: an overlay-created record carries
+         * `(OVERLAY_BYTE_OFFSET, 0)` and so counts as unreadable here, which would
+         * make this always answer true once an overlay exists. Harmless —
+         * `overlayActive` is an earlier disjunct, so this never runs then — and
+         * correct if it ever did.
+         *
+         * ## Why a standalone pass rather than a value off the index
+         *
+         * Measured: 12.0 ms of a 470 ms export at 714,485 entities (2.55%), one
+         * call, whole index walked because a well-formed model gives it nothing to
+         * short-circuit on. The cheaper shape was prototyped and is 13x faster —
+         * `min(byteLength)` and `max(byteOffset + byteLength)` over
+         * `CompactEntityIndex`'s own `Uint32Array`s answer "is every ref readable
+         * within `extent`" exactly and allocation-free in 0.74 ms — and was not
+         * taken, because 11 ms does not buy what it costs.
+         *
+         * It could only stand in FRONT of this loop, never replace it:
+         * `EntityByIdIndex` is a structural type and plain `Map`s satisfy it
+         * (`synthetic-data-store.ts` builds one), so the walk stays for those. That
+         * makes it a second implementation of one predicate across a package
+         * boundary — the defect class #2637, #2668 and this gate are all instances
+         * of. And storing it at construction is the invariant
+         * `source-ref-bounds.ts` exists to delete: `CompactEntityIndex` is built by
+         * its builder, by `compactEntityIndexFromColumns` in the transport, and by
+         * embedders, so a value one producer writes is a value the next can skip,
+         * whereas testing the ref where it is READ cannot be bypassed. If 2.5% ever
+         * has to go, the safe shape is a memoized derivation the index computes
+         * from its own arrays on demand — not a field set at build time.
          */
-        const inPlaceNominees = {
-            attribute: new Set(),
-            georeferencing: new Set(),
+        const hasAnyUnreadableSourceRef = () => {
+            for (const [, ref] of pass.effective) {
+                if (!pass.isReadableSourceRef(ref))
+                    return true;
+            }
+            return false;
         };
-        // Collect entities that need to be modified or created
-        const modifiedEntities = new Set();
-        const modifiedAttributes = new Map();
-        const newPropertySets = [];
-        const newQuantitySets = [];
-        const typeOwnedPsetNamesByEntity = new Map();
-        const typeOwnedPsetIdsByEntity = new Map();
-        const rewrittenEntityIds = new Set();
-        const rewrittenEntityLines = new Map();
-        /** HasPropertySets slot value for an OVERLAY-CREATED type object, applied
-         *  by the new-entities pass (there is no source line to rewrite). */
-        const overlayTypeOwnedPsets = new Map();
-        // Track property set IDs and relationship IDs to skip
-        const skipPropertySetIds = new Set();
-        const skipRelationshipIds = new Set();
-        const overlayActive = !!this.mutationView && (options.applyMutations !== false);
         // Process mutations if we have a mutation view
-        if (this.mutationView && (options.applyMutations !== false)) {
+        if (this.mutationView && applyMutations) {
             const mutations = this.mutationView.getMutations();
             // Attribute values come from the *overlay*, never from the mutation
             // history. The history is append-only and undo writes its reverse edit
@@ -315,11 +471,11 @@ export class StepExporter {
             // the source for psets, quantities, positional attributes and retypes
             // below, so attributes were the sole outlier.
             for (const [entityId, attrs] of this.mutationView.getAttributeMutationsByEntity()) {
-                modifiedEntities.add(entityId);
-                let target = modifiedAttributes.get(entityId);
+                pass.modifiedEntities.add(entityId);
+                let target = pass.modifiedAttributes.get(entityId);
                 if (!target) {
                     target = new Map();
-                    modifiedAttributes.set(entityId, target);
+                    pass.modifiedAttributes.set(entityId, target);
                 }
                 for (const [name, value] of attrs)
                     target.set(name, value);
@@ -349,274 +505,29 @@ export class StepExporter {
             // below previously walked every entity in `entityIndex.byId` per
             // modified entity (O(E·N)); the index keeps the per-entity step
             // O(K) where K is the number of rels referencing that entity.
-            const { byEntity: relDefinesByEntity, relatedByRel } = this.buildRelDefinesByPropertiesIndex();
+            const { byEntity: relDefinesByEntity, relatedByRel } = buildRelDefinesByPropertiesIndex(this.propertySetContext());
             // A source IfcRelDefinesByProperties whose EVERY related object the
             // session deleted has nothing left to relate, and emitting it leaves a
             // `#id` pointing at a record the export skipped. Dropped only when all of
             // them are gone: a rel that still names a live entity is that entity's
             // only link to its psets, and nothing here rewrites a RelatedObjects list.
             for (const [relId, related] of relatedByRel) {
-                if (related.length > 0 && related.every((id) => effective.isDeleted(id))) {
-                    skipRelationshipIds.add(relId);
-                }
-            }
-            // Collect modified property sets and find original psets to skip
-            for (const [entityId, psetNames] of entityPropMutations) {
-                // A deleted entity must not cause the exporter to REMOVE anything.
-                //
-                // This is the other half of the dangling-reference class, and the half
-                // `willBeEmitted` cannot reach: that predicate guards what gets ADDED,
-                // and this loop's real work is deciding what gets SKIPPED. An edited
-                // pset is replaced wholesale, so its original id goes into
-                // `skipPropertySetIds` — but IFC exporters share one IfcPropertySet
-                // between entities, and once the host is deleted there is no
-                // replacement to take its place. The surviving entity's relation then
-                // points at a container nobody wrote. Verified against main at
-                // e6516991 (#2030's own merge): edit `Pset_WallCommon` on one of two
-                // walls sharing it, delete that wall, and the export drops #11 while
-                // #12 still names it. `retainSharedAtoms` rescues a shared ATOM one
-                // level down; nothing rescues the shared container.
-                //
-                // Leaving the pset alone makes it an orphan when nothing else
-                // references it, which is valid IFC. Its relation is dropped by the
-                // sweep above, which handles a plain delete too — no pset edit needed.
-                if (effective.isDeleted(entityId))
-                    continue;
-                modifiedEntities.add(entityId);
-                // 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.
-                //
-                // 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));
-                const relDefinedPsetNames = new Set();
-                if (relevantPsets.length > 0) {
-                    newPropertySets.push({ entityId, psets: relevantPsets });
-                }
-                // Find original property set IDs and relationship IDs to skip — look
-                // up only the IfcRelDefinesByProperties rels that reference this entity.
-                const rels = relDefinesByEntity.get(entityId);
-                if (rels) {
-                    for (const { relId, psetId: relatedPsetId } of rels) {
-                        // Check if this pset is one we're modifying
-                        const psetName = this.getPropertySetName(relatedPsetId);
-                        if (psetName) {
-                            relDefinedPsetNames.add(psetName);
-                        }
-                        if (psetName && psetNames.has(psetName)) {
-                            skipRelationshipIds.add(relId);
-                            skipPropertySetIds.add(relatedPsetId);
-                            // Also skip the individual properties in this pset
-                            const propIds = this.getPropertyIdsInSet(relatedPsetId);
-                            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');
-                        }
-                    }
-                }
-                if (isTypeClass(effective.typeOf(entityId))) {
-                    const typeOwnedPsetIds = this.getTypeOwnedHasPropertySetIds(entityId, effective);
-                    const typeOwnedAffected = new Set();
-                    for (const psetId of typeOwnedPsetIds) {
-                        const psetName = this.getPropertySetName(psetId);
-                        if (!psetName || !psetNames.has(psetName))
-                            continue;
-                        typeOwnedAffected.add(psetName);
-                        skipPropertySetIds.add(psetId);
-                        const propIds = this.getPropertyIdsInSet(psetId);
-                        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)) {
-                            typeOwnedAffected.add(psetName);
-                        }
-                    }
-                    if (typeOwnedAffected.size > 0) {
-                        typeOwnedPsetNamesByEntity.set(entityId, typeOwnedAffected);
-                        typeOwnedPsetIdsByEntity.set(entityId, typeOwnedPsetIds);
-                        rewrittenEntityIds.add(entityId);
-                    }
+                if (related.length > 0 && related.every((id) => pass.effective.isDeleted(id))) {
+                    pass.skipRelationshipIds.add(relId);
                 }
             }
-            // 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. 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.
-                //
-                // A quantity-set REMOVAL is the one case where withholding WITHOUT a
-                // replacement is the intent rather than the bug. It had no public
-                // populator when #2487 wrote that rule, so the rule read "always the
-                // bug"; `MutablePropertyView.deleteQuantitySet` (#2508) gives it one,
-                // and the deleted set is now asked for by name below. Without that, the
-                // panel hid a base quantity set the exported file still carried.
-                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);
-                        const deleted = qsetName !== null
-                            && this.mutationView.isQuantitySetDeleted?.(entityId, qsetName) === true;
-                        if (qsetName && (regeneratedQsetNames.has(qsetName) || deleted)) {
-                            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');
-                        }
-                    }
-                }
-            }
-            for (const [entityId] of modifiedAttributes) {
+            collectPropertyAndQuantitySetMutations(pass, options, { entityPropMutations, entityQuantMutations, relDefinesByEntity }, this.propertySetContext());
+            for (const [entityId] of pass.modifiedAttributes) {
                 // An overlay-CREATED entity carrying attribute edits is emitted once,
                 // by the new-entities pass, and already counted in `newEntityCount`.
                 // Counting it here too made the header claim two affected entities for
                 // one created-then-renamed wall.
-                if (isOverlayCreated(entityId))
+                if (pass.isOverlayCreated(entityId))
                     continue;
                 // 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))
+                if (!pass.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
@@ -638,204 +549,28 @@ export class StepExporter {
                 // 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);
+                pass.inPlaceNominees.attribute.add(entityId);
                 if (options.deltaOnly === true)
-                    modifications.nominate(entityId, 'attribute');
+                    pass.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;
-            // `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];
-                if (!modifiedAttributes.has(entityId)) {
-                    modifiedAttributes.set(entityId, new Map());
-                }
-                const attrMap = modifiedAttributes.get(entityId);
-                const crs = gm.projectedCRS;
-                let changed = false;
-                if (crs.name !== undefined) {
-                    attrMap.set('Name', String(crs.name));
-                    changed = true;
-                }
-                if (crs.description !== undefined) {
-                    attrMap.set('Description', String(crs.description));
-                    changed = true;
-                }
-                if (crs.geodeticDatum !== undefined) {
-                    attrMap.set('GeodeticDatum', String(crs.geodeticDatum));
-                    changed = true;
-                }
-                if (crs.verticalDatum !== undefined) {
-                    attrMap.set('VerticalDatum', String(crs.verticalDatum));
-                    changed = true;
-                }
-                if (crs.mapProjection !== undefined) {
-                    attrMap.set('MapProjection', String(crs.mapProjection));
-                    changed = true;
-                }
-                if (crs.mapZone !== undefined) {
-                    attrMap.set('MapZone', String(crs.mapZone));
-                    changed = true;
-                }
-                if (crs.mapUnit !== undefined) {
-                    const mapUnitRef = this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines, effective);
-                    attrMap.set('MapUnit', `#${mapUnitRef}`);
-                    changed = true;
-                }
-                if (changed) {
-                    modifiedEntities.add(entityId);
-                    // 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
-            if (gm.mapConversion && existingMcIds?.length) {
-                const entityId = existingMcIds[0];
-                if (!modifiedAttributes.has(entityId)) {
-                    modifiedAttributes.set(entityId, new Map());
-                }
-                const attrMap = modifiedAttributes.get(entityId);
-                const mc = gm.mapConversion;
-                let changed = false;
-                if (mc.eastings !== undefined) {
-                    attrMap.set('Eastings', String(mc.eastings));
-                    changed = true;
-                }
-                if (mc.northings !== undefined) {
-                    attrMap.set('Northings', String(mc.northings));
-                    changed = true;
-                }
-                if (mc.orthogonalHeight !== undefined) {
-                    attrMap.set('OrthogonalHeight', String(mc.orthogonalHeight));
-                    changed = true;
-                }
-                if (mc.xAxisAbscissa !== undefined) {
-                    attrMap.set('XAxisAbscissa', String(mc.xAxisAbscissa));
-                    changed = true;
-                }
-                if (mc.xAxisOrdinate !== undefined) {
-                    attrMap.set('XAxisOrdinate', String(mc.xAxisOrdinate));
-                    changed = true;
-                }
-                if (mc.scale !== undefined) {
-                    attrMap.set('Scale', String(mc.scale));
-                    changed = true;
-                }
-                if (changed) {
-                    modifiedEntities.add(entityId);
-                    // 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
-            if (gm.projectedCRS && !existingCrsIds?.length) {
-                const crs = gm.projectedCRS;
-                const crsId = this.nextExpressId++;
-                // IfcProjectedCRS(Name, Description, GeodeticDatum, VerticalDatum, MapProjection, MapZone, MapUnit)
-                const name = crs.name ? `'${escapeStepString(String(crs.name))}'` : '$';
-                const desc = crs.description ? `'${escapeStepString(String(crs.description))}'` : '$';
-                const datum = crs.geodeticDatum ? `'${escapeStepString(String(crs.geodeticDatum))}'` : '$';
-                const vDatum = crs.verticalDatum ? `'${escapeStepString(String(crs.verticalDatum))}'` : '$';
-                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, effective)}`
-                    : '$';
-                newGeorefLines.push(`#${crsId}=IFCPROJECTEDCRS(${name},${desc},${datum},${vDatum},${proj},${zone},${mapUnitRef});`);
-                newEntityCount++;
-                // Find IfcGeometricRepresentationContext as SourceCRS for MapConversion
-                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
-                if (contextId) {
-                    const mc = gm.mapConversion || {};
-                    const mcId = this.nextExpressId++;
-                    const eastings = toStepReal(Number(mc.eastings) || 0);
-                    const northings = toStepReal(Number(mc.northings) || 0);
-                    const height = toStepReal(Number(mc.orthogonalHeight) || 0);
-                    const abscissa = mc.xAxisAbscissa !== undefined ? toStepReal(Number(mc.xAxisAbscissa)) : '$';
-                    const ordinate = mc.xAxisOrdinate !== undefined ? toStepReal(Number(mc.xAxisOrdinate)) : '$';
-                    const scale = mc.scale !== undefined ? toStepReal(Number(mc.scale)) : '$';
-                    // IfcMapConversion(SourceCRS, TargetCRS, Eastings, Northings, OrthogonalHeight, XAxisAbscissa, XAxisOrdinate, Scale)
-                    newGeorefLines.push(`#${mcId}=IFCMAPCONVERSION(#${contextId},#${crsId},${eastings},${northings},${height},${abscissa},${ordinate},${scale});`);
-                    newEntityCount++;
-                }
-                else {
-                    this.reportMapConversionRefused(warnings);
-                }
-            }
-            else if (gm.mapConversion && !existingMcIds?.length && existingCrsIds?.length) {
-                // CRS exists but no MapConversion — create just the conversion
-                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
-                if (contextId) {
-                    const mc = gm.mapConversion;
-                    const mcId = this.nextExpressId++;
-                    const eastings = toStepReal(Number(mc.eastings) || 0);
-                    const northings = toStepReal(Number(mc.northings) || 0);
-                    const height = toStepReal(Number(mc.orthogonalHeight) || 0);
-                    const abscissa = mc.xAxisAbscissa !== undefined ? toStepReal(Number(mc.xAxisAbscissa)) : '$';
-                    const ordinate = mc.xAxisOrdinate !== undefined ? toStepReal(Number(mc.xAxisOrdinate)) : '$';
-                    const scale = mc.scale !== undefined ? toStepReal(Number(mc.scale)) : '$';
-                    newGeorefLines.push(`#${mcId}=IFCMAPCONVERSION(#${contextId},#${existingCrsIds[0]},${eastings},${northings},${height},${abscissa},${ordinate},${scale});`);
-                    newEntityCount++;
-                }
-                else {
-                    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 (applyMutations && options.georefMutations) {
+            applyGeoreferencingMutations(pass, options.georefMutations, this.georefContext(options.deltaOnly === true));
         }
         // If delta only, only export modified entities. Overlay-created entities
         // also count — without this, `createEntity()`-only edits would silently
         // drop out of delta exports.
         const overlayNewEntityCount = (this.mutationView
-            && options.applyMutations !== false
+            && applyMutations
             && typeof this.mutationView.getNewEntities === 'function') ? this.mutationView.getNewEntities().length : 0;
         // Georef-only deltas (newGeorefLines populated but no entity changes) must
         // still produce a non-empty DATA section.
         if (options.deltaOnly
-            && modifiedEntities.size === 0
+            && pass.modifiedEntities.size === 0
             && overlayNewEntityCount === 0
-            && newGeorefLines.length === 0) {
-            const emptyContent = new TextEncoder().encode(buildHeader(0) + 'DATA;\nENDSEC;\nEND-ISO-10303-21;\n');
+            && pass.newGeorefLines.length === 0) {
+            const emptyContent = new TextEncoder().encode(pass.buildHeader(0) + 'DATA;\nENDSEC;\nEND-ISO-10303-21;\n');
             return {
                 content: emptyContent,
                 stats: {
@@ -843,107 +578,215 @@ export class StepExporter {
                     newEntityCount: 0,
                     modifiedEntityCount: 0,
                     fileSize: emptyContent.byteLength,
-                    warnings,
+                    warnings: pass.warnings,
                 },
             };
         }
         /**
-         * Will this id have a defining STEP line in the output at all?
+         * "May a line this export writes name `#id`?" — the single predicate both
+         * relationship-line filter sites consume, derived from `willBeEmitted`
+         * rather than from a second list kept in step with it by hand.
+         *
+         * DERIVED, not identical, and the gaps are named below rather than glossed:
+         * a scope qualifier for ids the file never had, and `deltaOnly`, where
+         * `willBeEmitted` answers `true` for a source record whose line this export
+         * does not write at all (the source-iteration pass is skipped wholesale in
+         * that mode). Nor does this make the CLOSURE WALK agree with either: the
+         * walk keeps `isRefExcludedDuringClosureWalk` and diverges from this
+         * predicate for an unreadable source ref — see the note on that predicate,
+         * and the "walk and output predicates diverge" test.
+         *
+         * The hand-kept second list is the bug this replaces. `willBeEmitted` recognises
+         * seven reasons a line never lands — outside the closure, hidden product,
+         * tombstoned, never existed, unreadable source ref (#2491), geometry
+         * excluded by options, and the `deltaOnly` carve-out — while the filter
+         * used to consume `(hiddenProductIds !== null && hiddenProductIds.has(id))
+         * || effective.isDeleted(id)`, which answered for two: hidden product, and
+         * tombstoned. Notably NOT "never existed" — that one is deliberately out of
+         * scope for the filter even now, for the reason under the qualifier heading
+         * below. The gap was live: on a PLAIN full export, with no `visibleOnly`,
+         * no deletions and no overlay, an unreadable ref made the source-iteration
+         * pass skip an entity's line while an `IFCREL*` naming it shipped verbatim,
+         * dangling.
+         *
+         * Deriving the filter from `willBeEmitted` is also what fixed the
+         * `mayNameExcludedRefs` gate that stands in front of both call sites. That
+         * gate used to be a SECOND, shorter enumeration of the same reasons
+         * (hidden products exist, or an overlay is active) and answered `false` for
+         * exactly the unreadable-ref export above, so the filter never ran at all.
+         * It is now {@link mayNameOmittedRefs} — see there for why a gate is kept
+         * at all (running the filter on every `IFCREL*` line costs +13% of a
+         * 714k-entity export) and for the enumeration it has to cover.
+         *
+         * ## The one qualifier on top of `willBeEmitted`
+         *
+         * `willBeEmitted` answers NO for an id neither the file nor the session
+         * ever had, which is right for its own job — nothing GENERATED may name an
+         * id that does not exist. It is the wrong answer for rewriting a SOURCE
+         * line, and the difference is whose bug it is. A `#999` already sitting in
+         * a relationship's `OwnerHistory` slot in the input file is a dangling ref
+         * this export did not create and cannot repair; `filterHiddenRefsFromRelationshipLine`
+         * withholds a whole relationship when an excluded id is in a bare scalar,
+         * so treating it as an exclusion would DELETE a visible element's pset over
+         * somebody else's corrupt file. That is the harm #2637 was about, and
+         * `step-exporter.test.ts` states the position out loud: a pre-existing
+         * dangling ref is out of scope and ships as it arrived.
+         *
+         * So the filter asks the narrower question: is `#id` an entity this model
+         * HAS, that this export is nonetheless not writing? `effective.has` is
+         * false for a tombstone, hence the explicit `isDeleted` arm — deleting an
+         * entity IS this session's doing and must be filtered.
+         *
+         * This is a scope qualifier, not a second enumeration of omission reasons:
+         * an eighth reason added to `willBeEmitted` still reaches the filter with
+         * no edit here.
+         *
+         * ## What the filter can and cannot reach
+         *
+         * Only `IFCREL*` lines. A `#N` named from a product's `Representation` or
+         * `ObjectPlacement` slot is not touched, so `includeGeometry:false` — a
+         * reason `willBeEmitted` does answer for — produces the same dangling refs
+         * with this predicate as without it. Measured on `tests/models/AB22.ifc`:
+         * 80 dangling refs before and after, output byte-identical but for the
+         * header timestamp.
+         *
+         * ## Withholding is not free
+         *
+         * When the omitted id sits in a single-valued slot, or is a set's only
+         * member, `filterHiddenRefsFromRelationshipLine` withholds the WHOLE
+         * relationship — so an entity that relationship also named loses the
+         * association, on a plain full export with no options set. That is why the
+         * call sites push {@link relationshipWithheldWarning}.
+         *
+         * See `unreadable-ref-dangling.test.ts` for the reproduction. #2637 is the
+         * prior instance of this class, which took seven rounds because the same
+         * decision was recomputed per call site.
+         */
+        const isOmittedFromOutput = (id) => (pass.effective.has(id) || pass.effective.isDeleted(id)) && !pass.willBeEmitted(id);
+        /**
+         * "Can ANY id be omitted from this export at all?" — the precondition both
+         * `IFCREL*` filter sites are gated on, so the common export pays nothing.
+         *
+         * ## Why a gate exists
+         *
+         * Running `filterHiddenRefsFromRelationshipLine` on every `IFCREL*` line
+         * costs a re-parse of that line's attribute list, and a large model is
+         * mostly relationships. Measured on `tests/models/ara3d/schependomlaan.ifc`
+         * (714,485 entities, 21 interleaved reps in randomised order): 463 ms
+         * median with this gate false versus 523 ms filtering unconditionally,
+         * **+13%**. That is a real price paid on every export to protect a state
+         * most exports are not in. With the gate, the same export is 475 ms, +2.7%,
+         * all of it the fourth disjunct's one pass.
          *
-         * The predicate is #2030's, and it is the right one: the pset, quantity and
-         * type-owned passes below are built from unfiltered mutation history, and
-         * what each of them needs to know before emitting an
-         * `IFCRELDEFINESBYPROPERTIES` is not "was this deleted" or "is this hidden"
-         * but the general question those are two answers to. A relation naming an
-         * expressId that never gets written is a dangling reference and an invalid
-         * file, whichever route dropped the line.
+         * ## Why THIS gate, and not the one that shipped before
          *
-         * #2030 had to reach for four things to answer it — a tombstone probe, a
-         * visibility set, a byte-range test on `completeIndex`, and a `getNewEntity`
-         * fallback whose stated purpose was that `deleteEntity` FORGOT an
-         * overlay-created entity instead of tombstoning it, so `isDeleted` could not
-         * answer for one. That fallback was documented on main as a workaround for
-         * exactly the model-level defect this branch fixes: `deleteEntity` now
-         * tombstones as well as forgets, so the effective index answers existence
-         * for source and overlay ids alike and the workaround collapses into it.
+         * The gate this replaces was a second, hand-kept enumeration of "reasons an
+         * entity might be excluded", and it went stale exactly as such lists do: it
+         * named hidden products and the overlay and knew nothing about an unreadable
+         * source ref, so the bug this branch fixes reached the output with the
+         * filter switched off. A cheap gate is safe only as an OVER-APPROXIMATION of
+         * `isOmittedFromOutput` that can be checked against `willBeEmitted` branch
+         * by branch — so every branch is listed, with the disjunct that covers it:
          *
-         * The overlay branch does NOT disappear with it, and the distinction matters:
-         * `isOverlayCreated` is still load-bearing here, because a live
-         * overlay-created entity has no source bytes and would fail the byte-range
-         * test that a source record passes. What the tombstone fix removed is the
-         * need for that branch to double as a deletion detector.
+         * | `willBeEmitted` answers NO at                | covered by                    |
+         * |----------------------------------------------|-------------------------------|
+         * | `allowedEntityIds !== null && !has(id)`      | `allowedEntityIds !== null`   |
+         * | `!ref`, because the overlay tombstoned `id`  | `overlayActive`               |
+         * | overlay-created, geometry excluded           | `overlayActive`               |
+         * | `!isReadableSourceRef(ref)`                  | `hasAnyUnreadableSourceRef()` |
+         * | source-backed, geometry excluded             | `excludeGeometry`             |
+         * | `!ref`, because `id` never existed           | out of scope (below)          |
+         * | `!ref` while `has(id)` is TRUE               | nothing (below)               |
          *
-         * Deliberately unchanged from #2030 for source records under `deltaOnly` /
-         * `exportPropertiesOnly`: the source-iteration pass is skipped wholesale in
-         * those modes, yet a source entity still answers true here. A delta is a
-         * patch against a file that already has the line, not a standalone model.
+         * "Never existed" needs no disjunct: `isOmittedFromOutput`'s own
+         * `(has || isDeleted)` qualifier already drops it, deliberately — a
+         * pre-existing dangling ref in somebody else's file is not this export's to
+         * repair (see that predicate's note).
+         *
+         * The last row is a real hole and is stated rather than hidden: an index
+         * that answers `has(id)` for an id its iteration never yields makes
+         * `isOmittedFromOutput` true with no disjunct true. It needs an index whose
+         * `has`, `get` and iteration disagree, which nothing in the repo builds and
+         * which would already break the source-iteration pass's own skip — see
+         * {@link hasAnyUnreadableSourceRef}, which rests on the same agreement.
+         *
+         * Three of the four disjuncts are reads of values this export already
+         * computed. Only the fourth costs anything, and it short-circuits: `||`
+         * evaluates it solely when the other three are false, i.e. only for an
+         * export that has nothing else to filter for.
+         *
+         * ## The two spellings that are deliberately NOT the obvious ones
+         *
+         * `allowedEntityIds !== null`, not `options.visibleOnly === true`. Not the
+         * same test: the closure is built under `if (options.visibleOnly &&
+         * this.dataStore.source)`, which is TRUTHY rather than `=== true`, and which
+         * is a SECOND read of the caller's object. A plain-JS caller of this
+         * published package passing `visibleOnly: 1` — or a `get visibleOnly()` that
+         * answers `true` once — built the closure while the gate read false and
+         * shipped a relationship naming an entity outside it. Executed, not
+         * reasoned: 192 of an 800-case sweep over `visibleOnly`/`hidden`/`isolated`
+         * combinations shipped a dangling ref against the `=== true` spelling, 0
+         * against this one. Reading the state the walk PRODUCED cannot disagree with
+         * the walk, whatever `options` says afterwards.
+         *
+         * It is also wider than the `hiddenProductIds.size > 0` the old gate used: a
+         * closure exists whenever `visibleOnly` was requested, even with nothing
+         * hidden, and can exclude an entity the roots simply never reach. No fixture
+         * has produced that case, so the widening is defensive — but a gate that is
+         * true too often costs speed on a rare path, while one that is false too
+         * rarely ships a corrupt file, and this one costs nothing.
+         *
+         * `overlayActive` and `excludeGeometry` are the SAME consts the effective
+         * index and `isGeometryExcluded` are built from — one read of `options` per
+         * question, shared — so those two cannot disagree with the predicate either.
          */
-        const willBeEmitted = (entityId) => {
-            if (allowedEntityIds !== null && !allowedEntityIds.has(entityId))
-                return false;
-            // Undefined for a tombstoned id and for one neither the file nor the
-            // session ever had — a stale mutation must not conjure a relation either.
-            const ref = effective.get(entityId);
-            if (!ref)
-                return false;
-            // An overlay-created record carries the placeholder byte range and is
-            // written by the new-entities pass; a source record needs real bytes.
-            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);
-        };
+        const mayNameOmittedRefs = pass.allowedEntityIds !== null
+            || pass.overlayActive
+            || excludeGeometry
+            || hasAnyUnreadableSourceRef();
         // A modified pset is replaced wholesale, which skips ALL of its member atoms.
         // But IFC exporters deduplicate identical Pset_*Common atoms (e.g. one
         // IsExternal IfcPropertySingleValue shared by dozens of psets), so skipping a
         // shared atom would orphan every OTHER pset that still references it, leaving
         // dangling refs and an invalid file. Keep any atom a surviving container needs.
-        this.retainSharedAtoms(skipPropertySetIds, allowedEntityIds);
+        this.retainSharedAtoms(pass.skipPropertySetIds, pass.allowedEntityIds);
         // Export original entities from source buffer, SKIPPING modified property sets
         if (!options.deltaOnly && this.dataStore.source) {
             const source = this.dataStore.source;
             // Extract existing entities from source. The effective index has already
             // dropped everything the overlay tombstoned, so there is no separate
             // deleted check to forget here.
-            for (const [expressId, entityRef] of effective) {
+            for (const [expressId, entityRef] of pass.effective) {
                 // 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)) {
+                if (!pass.isReadableSourceRef(entityRef)) {
                     continue;
                 }
                 // Skip entities outside the visible closure
-                if (allowedEntityIds !== null && !allowedEntityIds.has(expressId)) {
+                if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(expressId)) {
                     continue;
                 }
                 // Skip property sets/relationships that are being replaced
-                if (skipPropertySetIds.has(expressId) || skipRelationshipIds.has(expressId)) {
+                if (pass.skipPropertySetIds.has(expressId) || pass.skipRelationshipIds.has(expressId)) {
                     continue;
                 }
                 // Skip type entities whose HasPropertySets attribute will be rewritten
-                if (rewrittenEntityIds.has(expressId)) {
+                if (pass.rewrittenEntityIds.has(expressId)) {
                     continue;
                 }
-                // Skip if we're only doing geometry or specific types
-                const entityType = entityRef.type.toUpperCase();
-                // Skip geometry if not included
-                if (options.includeGeometry === false && this.isGeometryEntity(entityType)) {
+                // Skip geometry if not included. Classified via `isGeometryExcluded`
+                // (which reads the EFFECTIVE type, `effective.effectiveType`) rather
+                // than `entityRef.type` directly: a retype can move a record across
+                // the geometry boundary in either direction, and this check has to
+                // agree with `hasEmittableHostBytes`/`willBeEmitted`'s use of the
+                // same predicate — otherwise a wall retyped to `IfcCartesianPoint`
+                // still ships its (rewritten) geometry line under
+                // `includeGeometry: false`, the exact "predicate must agree" failure
+                // this file already guards for the non-retyped case (#2414).
+                if (pass.isGeometryExcluded(expressId, entityRef.type)) {
                     continue;
                 }
                 // Get original entity text — decodeRange handles SAB-backed
@@ -954,7 +797,8 @@ export class StepExporter {
                 // 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 mutated = this.applySourceLineMutations(expressId, entityText, entityRef.type, pass.modifiedAttributes.get(expressId), pass.sourceSchema, pass.overlayActive, (attr, value) => pass.warnings.push(`entity #${expressId}: attribute ${attr} not written - ` +
+                    `${JSON.stringify(value)} is not a number and the slot is REAL-typed`));
                 let nextEntityText = mutated.text;
                 // A hidden PRODUCT's own line is already out of the export via
                 // `allowedEntityIds`, and a TOMBSTONED entity's via `effective` — this
@@ -967,16 +811,18 @@ export class StepExporter {
                 // withholds must not also be counted as a delivered modification.
                 //
                 // Classified by the EFFECTIVE type (`effective.effectiveType`), not
-                // the authored `entityType` above: a retype can move a record across
+                // the source's authored type: a retype can move a record across
                 // the `IFCREL*` boundary in either direction (`applySourceLineMutations`
                 // already rewrote `nextEntityText` to the new class), and this check
                 // has to agree with what actually got written, the same way
                 // `getVisibleEntityIds` already does for the visibility walk itself.
-                const effectiveRelType = effective.effectiveType(expressId, entityRef.type).toUpperCase();
-                if (mayNameExcludedRefs && effectiveRelType.startsWith('IFCREL')) {
-                    const filtered = filterHiddenRefsFromRelationshipLine(nextEntityText, isExcludedFromRelationshipRefs);
-                    if (filtered === null)
+                const effectiveRelType = pass.effective.effectiveType(expressId, entityRef.type).toUpperCase();
+                if (mayNameOmittedRefs && effectiveRelType.startsWith('IFCREL')) {
+                    const filtered = filterHiddenRefsFromRelationshipLine(nextEntityText, isOmittedFromOutput);
+                    if (filtered === null) {
+                        pass.warnings.push(relationshipWithheldWarning(expressId, effectiveRelType));
                         continue;
+                    }
                     nextEntityText = filtered;
                 }
                 // A retype or a positional edit that CHANGED the line is what makes
@@ -988,180 +834,39 @@ export class StepExporter {
                 // 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);
+                    pass.modifiedEntities.add(expressId);
                 if (mutated.retyped)
-                    modifications.nominate(expressId, 'retype');
+                    pass.modifications.nominate(expressId, 'retype');
                 if (mutated.positional)
-                    modifications.nominate(expressId, 'positional');
+                    pass.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);
+                nominateDeliveredInPlaceEdits(pass.modifications, expressId, mutated, pass.inPlaceNominees);
                 // Apply schema conversion if exporting to a different schema version
-                if (converting) {
-                    const converted = convertStepLine(nextEntityText, sourceSchema, schema, options.guidRandom);
+                if (pass.converting) {
+                    const converted = convertStepLine(nextEntityText, pass.sourceSchema, pass.schema, options.guidRandom);
                     if (converted !== null) {
-                        entities.push(converted);
+                        pass.entities.push(converted);
                     }
                     // null means entity should be skipped (no valid representation in target schema)
                 }
                 else {
-                    entities.push(nextEntityText);
+                    pass.entities.push(nextEntityText);
                 }
             }
         }
-        // Generate new property entities for mutations (these REPLACE the skipped ones)
-        const generatedTypeOwnedPsetIds = new Map();
-        for (const { entityId, psets } of newPropertySets) {
-            // Nothing may be emitted FOR an entity that gets no defining line —
-            // see `willBeEmitted` (#1978, #2030, #2012).
-            if (!willBeEmitted(entityId))
-                continue;
-            const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, 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
-        // export generated. One loop, because a type whose affected psets produced
-        // no replacement content (a deletion) needs exactly the same resolution
-        // with an empty replacement map.
-        for (const [entityId, typeOwnedPsetNames] of typeOwnedPsetNamesByEntity) {
-            // `entityId` here is a TYPE object rather than an element; `willBeEmitted`
-            // resolves either the same way (#2030).
-            if (!willBeEmitted(entityId))
-                continue;
-            const resolved = resolveTypeOwnedPsetIds(typeOwnedPsetIdsByEntity.get(entityId) ?? [], typeOwnedPsetNames, generatedTypeOwnedPsetIds.get(entityId) ?? new Map(), (psetId) => this.getPropertySetName(psetId));
-            if (effective.isOverlayCreated(entityId)) {
-                // No source line to rewrite: the new-entities pass writes this record
-                // from its authored payload, so the list rides in as a slot override.
-                overlayTypeOwnedPsets.set(entityId, resolved.length > 0 ? resolved.map((id) => `#${id}`) : null);
-                continue;
-            }
-            // 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
-        for (const { entityId, qsets } of newQuantitySets) {
-            if (!willBeEmitted(entityId))
-                continue;
-            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);
+        // Generated property/quantity sets and the type-object `HasPropertySets`
+        // rewrite that resolves against them, in that one order (#2475 steps 2b
+        // and 2c). `pass.rewrittenEntityLines`, this call's output, is flushed
+        // just below — after the quantity-set loop inside it, as it always was.
+        generatePropertyAndQuantitySetEntities(pass, options, this.propertySetContext());
+        for (const rewrittenLine of pass.rewrittenEntityLines.values()) {
+            pass.entities.push(rewrittenLine);
         }
         // Add new georeferencing entities (IfcProjectedCRS, IfcMapConversion)
-        for (const line of newGeorefLines) {
-            entities.push(line);
+        for (const line of pass.newGeorefLines) {
+            pass.entities.push(line);
         }
         // Add overlay-created entities (store.addEntity / mutationView.createEntity).
         // Apply the same filters as the source-iteration pass so newly-created
@@ -1169,7 +874,7 @@ export class StepExporter {
         // IfcExtrudedAreaSolid, etc.) past `includeGeometry:false` /
         // `exportPropertiesOnly()` modes.
         if (this.mutationView
-            && (options.applyMutations !== false)
+            && applyMutations
             && typeof this.mutationView.getNewEntities === 'function') {
             const getTypeMut = typeof this.mutationView.getEntityTypeMutation === 'function'
                 ? this.mutationView.getEntityTypeMutation.bind(this.mutationView)
@@ -1184,10 +889,10 @@ export class StepExporter {
                 // STEP requires UPPERCASE entity type tokens; the upper-case happens
                 // here at the file-format boundary.
                 const upperType = effectiveType.toUpperCase();
-                if (options.includeGeometry === false && this.isGeometryEntity(upperType)) {
+                if (excludeGeometry && this.isGeometryEntity(upperType)) {
                     continue;
                 }
-                if (allowedEntityIds !== null && !allowedEntityIds.has(entity.expressId)) {
+                if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entity.expressId)) {
                     continue;
                 }
                 // Re-lay-out by name against the effective class (identity for
@@ -1198,12 +903,12 @@ export class StepExporter {
                 if (typeMut) {
                     // Serialize against the AUTHORED layout (`entity.type`); retypeArgTokens
                     // then re-lays the tokens out by name up to the effective class.
-                    const srcTokens = entity.attributes.map((value, i) => serializeAttributeSlot(entity.type, i, value, sourceSchema));
-                    const { tokens } = retypeArgTokens(srcTokens, entity.type, effectiveType, typeMut.predefinedType ?? null, sourceSchema);
+                    const srcTokens = entity.attributes.map((value, i) => serializeAttributeSlot(entity.type, i, value, pass.sourceSchema));
+                    const { tokens } = retypeArgTokens(srcTokens, entity.type, effectiveType, typeMut.predefinedType ?? null, pass.sourceSchema);
                     argsText = tokens.join(',');
                 }
                 else {
-                    argsText = serializeEntityArgs(entity.type, entity.attributes, sourceSchema);
+                    argsText = serializeEntityArgs(entity.type, entity.attributes, pass.sourceSchema);
                 }
                 // Edits made AFTER the create live in the overlay, never in the
                 // authored payload (#2006). The source-iteration pass applies them to
@@ -1215,7 +920,7 @@ export class StepExporter {
                 //
                 // Order mirrors the source pass: retype (above) -> named attributes ->
                 // positional overrides, all resolved against the EFFECTIVE class.
-                const attributeOverrides = modifiedAttributes.get(entity.expressId) ?? null;
+                const attributeOverrides = pass.modifiedAttributes.get(entity.expressId) ?? null;
                 const queuedPositional = typeof this.mutationView.getPositionalMutationsForEntity === 'function'
                     ? this.mutationView.getPositionalMutationsForEntity(entity.expressId)
                     : null;
@@ -1224,31 +929,47 @@ export class StepExporter {
                 // arrive as one more slot override rather than through the overlay.
                 // `has`, not `??`, for the same reason `overlaySlotValue` gives: the
                 // stored value is deliberately null when the resolved list is empty.
-                const positionalOverrides = overlayTypeOwnedPsets.has(entity.expressId)
-                    ? new Map(queuedPositional).set(HAS_PROPERTY_SETS_SLOT, overlayTypeOwnedPsets.get(entity.expressId) ?? null)
+                const positionalOverrides = pass.overlayTypeOwnedPsets.has(entity.expressId)
+                    ? new Map(queuedPositional).set(HAS_PROPERTY_SETS_SLOT, pass.overlayTypeOwnedPsets.get(entity.expressId) ?? null)
                     : queuedPositional;
                 if ((attributeOverrides && attributeOverrides.size > 0)
                     || (positionalOverrides && positionalOverrides.size > 0)) {
-                    argsText = this.applyOverlayEntityOverrides(argsText, upperType, attributeOverrides, positionalOverrides, sourceSchema);
+                    argsText = this.applyOverlayEntityOverrides(argsText, upperType, attributeOverrides, positionalOverrides, pass.sourceSchema, 
+                    // Overlay-created entities report a rejected REAL edit exactly as
+                    // source-backed ones do. Without this the slot was kept and NOTHING
+                    // was said - the silent discard this whole change exists to
+                    // prevent, surviving in the one path that had no test.
+                    (attr, value) => pass.warnings.push(`entity #${entity.expressId}: attribute ${attr} not written - ` +
+                        `${JSON.stringify(value)} is not a number and the slot is REAL-typed`));
                 }
                 let line = `#${entity.expressId}=${upperType}(${argsText});`;
                 // Same gap as the source-iteration pass, for an overlay-authored
                 // relationship instead of a parsed one (#2398).
-                if (mayNameExcludedRefs && upperType.startsWith('IFCREL')) {
-                    line = filterHiddenRefsFromRelationshipLine(line, isExcludedFromRelationshipRefs);
-                    if (line === null)
+                //
+                // `mayNameOmittedRefs` is provably TRUE wherever this line executes:
+                // the block enclosing this pass requires `this.mutationView` and
+                // `applyMutations`, which is `pass.overlayActive`, which is one of the
+                // gate's own disjuncts. Spelled out anyway so both filter sites read the
+                // same — the previous gate's failure was one site's condition drifting
+                // from what the filter needed, and a pass reachable without an overlay
+                // would otherwise silently need the gate re-derived here.
+                if (mayNameOmittedRefs && upperType.startsWith('IFCREL')) {
+                    line = filterHiddenRefsFromRelationshipLine(line, isOmittedFromOutput);
+                    if (line === null) {
+                        pass.warnings.push(relationshipWithheldWarning(entity.expressId, upperType));
                         continue;
+                    }
                 }
-                if (converting) {
-                    const converted = convertStepLine(line, sourceSchema, schema, options.guidRandom);
+                if (pass.converting) {
+                    const converted = convertStepLine(line, pass.sourceSchema, pass.schema, options.guidRandom);
                     if (converted !== null) {
-                        entities.push(converted);
-                        newEntityCount++;
+                        pass.entities.push(converted);
+                        pass.newEntityCount++;
                     }
                 }
                 else {
-                    entities.push(line);
-                    newEntityCount++;
+                    pass.entities.push(line);
+                    pass.newEntityCount++;
                 }
             }
         }
@@ -1257,20 +978,20 @@ export class StepExporter {
         // 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);
+        const { modifiedEntityCount, warnings: deltaWarnings } = pass.modifications.settle();
+        pass.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);
-        const content = assembleStepBytes(header, entities);
+        const header = pass.buildHeader(pass.newEntityCount + modifiedEntityCount);
+        const content = assembleStepBytes(header, pass.entities);
         return {
             content,
             stats: {
-                entityCount: entities.length,
-                newEntityCount,
+                entityCount: pass.entities.length,
+                newEntityCount: pass.newEntityCount,
                 modifiedEntityCount,
                 fileSize: content.byteLength,
-                warnings,
+                warnings: pass.warnings,
             },
         };
     }
@@ -1306,183 +1027,6 @@ export class StepExporter {
             deltaOnly: true,
         });
     }
-    /**
-     * Resolve a STEP reference to an existing IfcOwnerHistory for the
-     * IfcPropertySet / IfcRelDefinesByProperties / IfcElementQuantity entities we
-     * generate for `hostEntityId`'s mutations. OwnerHistory is optional in IFC4 but
-     * MANDATORY in IFC2X3 (IfcRoot.OwnerHistory), so emitting `$` yields an invalid
-     * IFC2X3 file that strict readers (e.g. BIM Vision) reject.
-     *
-     * Prefer the host element's OWN owner history, then any owner history that
-     * survives this export, then `$` only when none does.
-     *
-     * "Survives" is `willBeEmitted`, the same predicate that decides whether the
-     * host itself may have psets generated for it. A reference is a reference: it
-     * is no more acceptable to point an emitted `IfcPropertySet` at an owner
-     * history the session deleted than at a host it deleted. This used to consult
-     * only the `visibleOnly` closure, so an overlay-created OwnerHistory that was
-     * later deleted still got referenced — a dangling `#N`, reached through the
-     * one attribute the generators fill in for themselves.
-     */
-    resolveOwnerHistoryRef(hostEntityId, willBeEmitted) {
-        const own = this.getOwnerHistoryRefOfEntity(hostEntityId);
-        if (own !== null) {
-            const ownId = parseInt(own.slice(1), 10);
-            if (willBeEmitted(ownId))
-                return own;
-        }
-        if (this.ownerHistoryFallbackRef === undefined) {
-            // Source-only: the fallback is a best-effort "some owner history the file
-            // still has", and the host's OWN history above is the path that resolves
-            // an overlay-created one.
-            const ids = this.dataStore.entityIndex.byType.get('IFCOWNERHISTORY') ?? [];
-            const surviving = ids.find((id) => willBeEmitted(id));
-            this.ownerHistoryFallbackRef = surviving !== undefined ? `#${surviving}` : '$';
-        }
-        return this.ownerHistoryFallbackRef;
-    }
-    /**
-     * The overlay's answer for one positional slot of an overlay-created entity,
-     * falling back to the creation payload only when the overlay has NOTHING to
-     * say about that slot.
-     *
-     * **Ask `Map.has`, never `??`.** `setPositionalAttribute(id, slot, null)` is
-     * an explicit "clear this slot", and its value is `null`, so `??` reads the
-     * overlay's answer as an absence and reinstates the authored one. That is the
-     * same overlay-versus-buffer confusion this whole change is about, one
-     * attribute wide: an explicit null IS the overlay's answer, and the overlay is
-     * the authority. Cleared OwnerHistory came back as the authored reference, and
-     * a cleared `HasPropertySets` resurrected the list the user had removed.
-     */
-    overlaySlotValue(entityId, slot, authored) {
-        const overrides = this.mutationView?.getPositionalMutationsForEntity(entityId);
-        if (!overrides?.has(slot))
-            return authored;
-        const value = overrides.get(slot);
-        // `Map.get` widens to `| undefined`, which `has` has already ruled out. A
-        // slot explicitly set to nothing serializes as `$`, i.e. null.
-        return value === undefined ? null : value;
-    }
-    /**
-     * Read an element's own OwnerHistory reference (`#id`), or null when the
-     * element omits one (`$`) or cannot be parsed. OwnerHistory is the second
-     * attribute of every IfcRoot subtype, immediately after the GlobalId string.
-     */
-    getOwnerHistoryRefOfEntity(entityId) {
-        const cached = this.ownerHistoryByEntity.get(entityId);
-        if (cached !== undefined)
-            return cached;
-        let result = null;
-        // An overlay-created host has no source line to read, but it does have an
-        // authored OwnerHistory in slot 1 — reading only the buffer sent every
-        // generated pset on a created entity to the file's first owner history
-        // instead of the one the caller named (#2012).
-        const overlay = this.mutationView?.getNewEntity(entityId);
-        if (overlay) {
-            const refs = authoredEntityRefs(this.overlaySlotValue(entityId, OWNER_HISTORY_SLOT, overlay.attributes[OWNER_HISTORY_SLOT]));
-            result = refs.length > 0 ? `#${refs[0]}` : null;
-            this.ownerHistoryByEntity.set(entityId, result);
-            return result;
-        }
-        const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        // 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 && this.isReadableSourceRef(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);
-            if (match)
-                result = `#${match[1]}`;
-        }
-        this.ownerHistoryByEntity.set(entityId, result);
-        return result;
-    }
-    /**
-     * Generate STEP entities for property sets
-     */
-    generatePropertySetEntities(entityId, psets, willBeEmitted, effective, typeOwnedPsetNames, random) {
-        const lines = [];
-        let count = 0;
-        const generatedTypeOwnedPsetIds = new Map();
-        for (const pset of psets) {
-            const propertyIds = [];
-            // Create IfcPropertySingleValue for each property
-            for (const prop of pset.properties) {
-                const propId = this.nextExpressId++;
-                count++;
-                // `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) : '$'});`;
-                lines.push(line);
-                propertyIds.push(propId);
-            }
-            // Create IfcPropertySet
-            const psetId = this.nextExpressId++;
-            count++;
-            const propRefs = propertyIds.map(id => `#${id}`).join(',');
-            const globalId = this.generateGlobalId(random);
-            // #ID=IFCPROPERTYSET('GlobalId',#ownerHistory,'Name',$,(#props));
-            const psetLine = `#${psetId}=IFCPROPERTYSET('${globalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},'${escapeStepString(pset.name)}',$,(${propRefs}));`;
-            lines.push(psetLine);
-            if (typeOwnedPsetNames?.has(pset.name)) {
-                generatedTypeOwnedPsetIds.set(pset.name, psetId);
-            }
-            else {
-                // Create IfcRelDefinesByProperties to link pset to entity
-                const relId = this.nextExpressId++;
-                count++;
-                const relGlobalId = this.generateGlobalId(random);
-                // #ID=IFCRELDEFINESBYPROPERTIES('GlobalId',#ownerHistory,$,$,(#entity),#pset);
-                const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},$,$,(#${entityId}),#${psetId});`;
-                lines.push(relLine);
-            }
-        }
-        return { lines, count, generatedTypeOwnedPsetIds };
-    }
-    /**
-     * Generate STEP entities for quantity sets (IfcElementQuantity)
-     */
-    generateQuantitySetEntities(entityId, qsets, willBeEmitted, random) {
-        const lines = [];
-        let count = 0;
-        for (const qset of qsets) {
-            const quantityIds = [];
-            for (const q of qset.quantities) {
-                const qId = this.nextExpressId++;
-                count++;
-                const ifcType = quantityTypeToIfcType(q.type);
-                // #ID=IFCQUANTITYLENGTH('Name',$,$,Value,$);
-                const val = toStepReal(q.value);
-                const line = `#${qId}=${ifcType}('${escapeStepString(q.name)}',$,$,${val},$);`;
-                lines.push(line);
-                quantityIds.push(qId);
-            }
-            // Create IfcElementQuantity
-            const qsetId = this.nextExpressId++;
-            count++;
-            const quantRefs = quantityIds.map(id => `#${id}`).join(',');
-            const globalId = this.generateGlobalId(random);
-            // #ID=IFCELEMENTQUANTITY('GlobalId',#ownerHistory,'Name',$,$,(#quants));
-            const qsetLine = `#${qsetId}=IFCELEMENTQUANTITY('${globalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},'${escapeStepString(qset.name)}',$,$,(${quantRefs}));`;
-            lines.push(qsetLine);
-            // Create IfcRelDefinesByProperties to link qset to entity
-            const relId = this.nextExpressId++;
-            count++;
-            const relGlobalId = this.generateGlobalId(random);
-            const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${this.resolveOwnerHistoryRef(entityId, willBeEmitted)},$,$,(#${entityId}),#${qsetId});`;
-            lines.push(relLine);
-        }
-        return { lines, count };
-    }
     /**
      * THE mutation pipeline for a line read out of the source buffer: retype,
      * then named attribute edits, then positional edits.
@@ -1527,7 +1071,7 @@ export class StepExporter {
      * attribute edits are nominated by the collection pass and `attributed` only
      * settles their delivery.
      */
-    applySourceLineMutations(expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive) {
+    applySourceLineMutations(expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected) {
         let text = entityText;
         let workingType = recordType.toUpperCase();
         const typeMutation = overlayActive && typeof this.mutationView.getEntityTypeMutation === 'function'
@@ -1549,7 +1093,7 @@ export class StepExporter {
         let attributed = false;
         if (attributeMutations && attributeMutations.size > 0) {
             const beforeAttributes = text;
-            text = this.applyAttributeMutations(text, workingType, attributeMutations);
+            text = this.applyAttributeMutations(text, workingType, attributeMutations, sourceSchema, onRejected);
             attributed = text !== beforeAttributes;
         }
         const positionals = overlayActive && typeof this.mutationView.getPositionalMutationsForEntity === 'function'
@@ -1566,7 +1110,7 @@ export class StepExporter {
     /**
      * Rewrite root IFC attributes directly on the original STEP entity line.
      */
-    applyAttributeMutations(entityText, entityType, attributeMutations) {
+    applyAttributeMutations(entityText, entityType, attributeMutations, schemaVersion, onRejected) {
         const openParen = entityText.indexOf('(');
         const closeParen = entityText.lastIndexOf(');');
         if (openParen < 0 || closeParen < openParen) {
@@ -1586,6 +1130,7 @@ export class StepExporter {
         // argument list here means the file speaks a different schema, and growing
         // a record we did not author would corrupt it.
         let changed = false;
+        const realSlots = getRealTypedSlots(entityType, schemaVersion);
         for (const [attrName, value] of attributeMutations) {
             const index = attrNames.indexOf(attrName);
             if (index < 0 || index >= args.length)
@@ -1593,7 +1138,14 @@ export class StepExporter {
             // The source path shares every `$`-slot hole with the overlay-created
             // path, because a source record has plenty of `$` slots of its own. Both
             // go through the one helper below.
-            args[index] = this.serializeNamedAttribute(entityType, index, value, args[index]);
+            const serialized = this.serializeNamedAttribute(entityType, index, value, args[index], realSlots);
+            if (serialized === null) {
+                // Slot untouched AND reported. Not counted as a change: claiming a
+                // modification we did not make is the failure this avoids.
+                onRejected?.(attrName, value);
+                continue;
+            }
+            args[index] = serialized;
             changed = true;
         }
         if (!changed) {
@@ -1612,12 +1164,42 @@ export class StepExporter {
      * with `$`. So the declared type decides first, and inference is the fallback
      * for slots the schema does not classify (references, SELECTs, numerics),
      * where reading the old token is exactly the right heuristic.
+     *
+     * Before this REAL check existed, "the declared type decides first" was true
+     * for enum/string slots only — a REAL-backed slot (`IfcMapConversion.
+     * OrthogonalHeight`, any other `IfcLengthMeasure`/`IfcReal`-typed attribute)
+     * fell straight to `serializeAttributeValue`'s token inference, which quotes
+     * anything it cannot recognize as numeric. A schema-legal `$` placeholder
+     * carries no digits to recognize, so setting such a field for the first time
+     * wrote `'12345'` in a slot ISO 10303-21 requires to be an unquoted REAL —
+     * silently invalid output (#2724, LTplus-AG/ifc-lite#2475).
      */
-    serializeNamedAttribute(entityType, index, value, currentToken) {
+    serializeNamedAttribute(entityType, index, value, currentToken, realSlots) {
         if (getEnumTypedSlots(entityType).has(index))
             return serializeEnumToken(value);
         if (getStringTypedSlots(entityType).has(index))
             return serializeStringSlot(value);
+        if (realSlots.has(index)) {
+            const trimmed = value.trim();
+            if (trimmed === '')
+                return '$';
+            const numberValue = Number(trimmed);
+            if (Number.isFinite(numberValue))
+                return toStepReal(numberValue);
+            // A non-numeric value in a REAL slot used to fall through and be QUOTED,
+            // producing the same ISO 10303-21 violation #2725 exists to prevent
+            // (#2741). `StoreEditor.setAttribute` takes a string, so any UI text
+            // field bound to a georeferencing REAL can deliver one; it does not need
+            // a corrupt file.
+            //
+            // `null` means "leave the slot as the file had it". Simply returning
+            // `currentToken` here would stop the invalid output but SILENTLY DISCARD
+            // the edit - the exporter would then claim a modification it did not
+            // carry, which is the exact misreport #2723/#2724/#2726 were written to
+            // pin. The caller turns this into a warning, so a dropped edit is visible
+            // rather than inferred from absence.
+            return null;
+        }
         return serializeAttributeValue(value, currentToken);
     }
     /**
@@ -1641,7 +1223,7 @@ export class StepExporter {
      * so a short payload is partial authoring — never depended on which of the
      * two APIs queued the edit.
      */
-    applyOverlayEntityOverrides(argsText, entityType, attributeOverrides, positionalOverrides, schemaVersion) {
+    applyOverlayEntityOverrides(argsText, entityType, attributeOverrides, positionalOverrides, schemaVersion, onRejected) {
         const args = argsText.length > 0 ? splitTopLevelArgs(argsText) : [];
         const attrNames = getAttributeNamesAcrossSchemas(entityType);
         const named = [];
@@ -1674,11 +1256,19 @@ export class StepExporter {
         }
         // Every `named` index is < attrNames.length by construction, and padding
         // has taken args.length to at least that, so each one lands.
+        const realSlots = getRealTypedSlots(entityType, schemaVersion);
         for (const [index, value] of named) {
-            args[index] = this.serializeNamedAttribute(entityType, index, value, args[index]);
+            const serialized = this.serializeNamedAttribute(entityType, index, value, args[index], realSlots);
+            // Overlay-created entities take the same rejection: a non-numeric REAL is
+            // invalid STEP whoever authored the record. The slot keeps the `$` this
+            // path padded it with, rather than gaining a quoted string.
+            if (serialized === null) {
+                onRejected?.(attrNames[index] ?? `#${index}`, value);
+                continue;
+            }
+            args[index] = serialized;
         }
         if (positionalOverrides && positionalOverrides.size > 0) {
-            const realSlots = getRealTypedSlots(entityType, schemaVersion);
             for (const [index, value] of positionalOverrides) {
                 if (index < 0 || index >= args.length)
                     continue;
@@ -1728,151 +1318,6 @@ export class StepExporter {
         const forceReal = realSlots.has(index) || tokenIsRealLiteral(currentToken);
         return serializeStepValue(value, forceReal);
     }
-    resolveMapUnitReference(unitName, newGeorefLines, effective) {
-        const normalized = this.normalizeMapUnitName(unitName);
-        const existing = this.findLengthUnitReference(normalized, effective);
-        if (existing !== null) {
-            return existing;
-        }
-        if (normalized === 'METRE') {
-            const unitId = this.nextExpressId++;
-            newGeorefLines.push(`#${unitId}=IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);`);
-            return unitId;
-        }
-        if (normalized === 'FOOT' || normalized === 'US SURVEY FOOT') {
-            const dimId = this.nextExpressId++;
-            const siUnitId = this.nextExpressId++;
-            const measureId = this.nextExpressId++;
-            const convUnitId = this.nextExpressId++;
-            const factor = normalized === 'US SURVEY FOOT' ? 1200 / 3937 : 0.3048;
-            const name = normalized === 'US SURVEY FOOT' ? 'US SURVEY FOOT' : 'FOOT';
-            newGeorefLines.push(`#${dimId}=IFCDIMENSIONALEXPONENTS(1,0,0,0,0,0,0);`);
-            newGeorefLines.push(`#${siUnitId}=IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);`);
-            newGeorefLines.push(`#${measureId}=IFCMEASUREWITHUNIT(IFCLENGTHMEASURE(${toStepReal(factor)}),#${siUnitId});`);
-            newGeorefLines.push(`#${convUnitId}=IFCCONVERSIONBASEDUNIT(#${dimId},.LENGTHUNIT.,'${name}',#${measureId});`);
-            return convUnitId;
-        }
-        const fallbackId = this.nextExpressId++;
-        newGeorefLines.push(`#${fallbackId}=IFCSIUNIT(*,.LENGTHUNIT.,$,.METRE.);`);
-        return fallbackId;
-    }
-    normalizeMapUnitName(unitName) {
-        const normalized = unitName.trim().toUpperCase().replace(/\s+/g, ' ');
-        if (normalized.includes('US SURVEY FOOT'))
-            return 'US SURVEY FOOT';
-        if (normalized.includes('METER') || normalized.includes('METRE'))
-            return 'METRE';
-        if (normalized.includes('FOOT') || normalized.includes('FEET'))
-            return 'FOOT';
-        return normalized;
-    }
-    /**
-     * `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;
-        // 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' || effective.isDeleted(unitAssignmentId))
-            return null;
-        const unitAssignmentRef = this.dataStore.entityIndex.byId.get(unitAssignmentId);
-        const unitAssignment = unitAssignmentRef ? this.entityExtractor.extractEntity(unitAssignmentRef) : null;
-        const units = unitAssignment?.attributes?.[0];
-        if (!Array.isArray(units))
-            return null;
-        for (const unitId of units) {
-            if (typeof unitId !== 'number' || effective.isDeleted(unitId))
-                continue;
-            const unitRef = this.dataStore.entityIndex.byId.get(unitId);
-            const unit = unitRef ? this.entityExtractor.extractEntity(unitRef) : null;
-            if (!unit)
-                continue;
-            const typeName = unit.type.toUpperCase();
-            const attrs = unit.attributes ?? [];
-            const unitType = typeof attrs[1] === 'string' ? attrs[1].replace(/\./g, '').toUpperCase() : '';
-            if (unitType !== 'LENGTHUNIT')
-                continue;
-            if (typeName === 'IFCSIUNIT') {
-                const prefix = typeof attrs[2] === 'string' ? attrs[2].replace(/\./g, '').toUpperCase() : '';
-                const name = typeof attrs[3] === 'string' ? attrs[3].replace(/\./g, '').toUpperCase() : '';
-                const combined = prefix ? `${prefix}${name}` : name;
-                if (preferredUnitName === 'METRE' && (combined === 'METRE' || combined === 'METER')) {
-                    return unitId;
-                }
-            }
-            if (typeName === 'IFCCONVERSIONBASEDUNIT') {
-                const name = typeof attrs[2] === 'string' ? this.normalizeMapUnitName(attrs[2]) : '';
-                if (name === preferredUnitName) {
-                    return unitId;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * 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 = (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);
-            const context = contextRef ? this.entityExtractor.extractEntity(contextRef) : null;
-            if (!context)
-                continue;
-            const attrs = context.attributes ?? [];
-            const contextType = typeof attrs[1] === 'string' ? attrs[1].trim().toUpperCase() : '';
-            const dimension = typeof attrs[2] === 'number' ? attrs[2] : null;
-            if (dimension === 3 && first3dContext === null) {
-                first3dContext = contextId;
-            }
-            if (contextType === 'MODEL' && dimension === 3) {
-                return contextId;
-            }
-        }
-        return first3dContext ?? contextIds[0] ?? null;
-    }
-    /**
-     * Generate a new IFC GlobalId (22 character base64). `random` is the
-     * export's optional seeded source (`StepExportOptions.guidRandom`);
-     * undefined keeps the default random path.
-     */
-    generateGlobalId(random) {
-        return generateIfcGuid(random);
-    }
     /**
      * Find the maximum EXPRESS ID in the data store
      */
@@ -1882,10 +1327,47 @@ export class StepExporter {
         return getMaxExpressId(getCompleteEntityIndex(this.dataStore));
     }
     /**
-     * Find a unit entity ID by name (simplified - returns null for now)
+     * The exporter state `step-georeferencing.ts` cannot read off the pass.
+     *
+     * `allocateExpressId` hands out ids from THIS exporter's `nextExpressId`,
+     * which the property-set and quantity-set generators in
+     * `step-property-sets.ts` increment at six further sites through the same
+     * callback — hoisting the counter onto the pass would change what it
+     * computes, not merely where it is named, so both phases get a callback
+     * instead (#2475 step 2a).
+     */
+    georefContext(deltaOnly) {
+        return {
+            dataStore: this.dataStore,
+            entityExtractor: this.entityExtractor,
+            allocateExpressId: () => this.nextExpressId++,
+            deltaOnly,
+        };
+    }
+    /**
+     * The state `step-property-sets.ts` cannot read off the pass (#2475 2b/2c).
+     *
+     * `allocateExpressId` is the same callback `georefContext` hands out, over
+     * the same counter, so the ids the two phases allocate stay in one sequence.
+     * `ownerHistory` is passed by reference — the object is this exporter's, and
+     * `export()` resets it. `isReadableSourceRef` is the instance predicate, not
+     * `pass.isReadableSourceRef`, because two consumers of that module
+     * (`buildRelDefinesByPropertiesIndex`, `retainSharedAtoms`) run with no pass
+     * in hand; both readers are built over the same source.
+     *
+     * Rebuilt per call, as `georefContext` is: every call site runs once per
+     * export bar `retainSharedAtoms`, which hoists it out of its loop.
      */
-    findUnitId(unitName, effective) {
-        return this.findLengthUnitReference(this.normalizeMapUnitName(unitName), effective);
+    propertySetContext() {
+        return {
+            dataStore: this.dataStore,
+            entityExtractor: this.entityExtractor,
+            mutationView: this.mutationView,
+            isReadableSourceRef: this.isReadableSourceRef,
+            allocateExpressId: () => this.nextExpressId++,
+            ownerHistory: this.ownerHistory,
+            applySourceLineMutations: (expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected) => this.applySourceLineMutations(expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected),
+        };
     }
     /**
      * Check if an entity type is a geometry-related type
@@ -1926,153 +1408,6 @@ export class StepExporter {
         ]);
         return geometryTypes.has(type);
     }
-    /**
-     * Build a one-shot reverse index of every IfcRelDefinesByProperties in
-     * the source: for each related entity, list the rels and property/quantity
-     * sets that reference it. Used by the export pre-pass so the per-entity
-     * "find owning rels" step is O(K) rather than O(N) per modified entity.
-     *
-     * `relatedByRel` is the same walk read the other way round, so the deleted-host
-     * sweep costs nothing extra.
-     */
-    buildRelDefinesByPropertiesIndex() {
-        const byEntity = new Map();
-        const relatedByRel = new Map();
-        for (const [relId, relRef] of this.dataStore.entityIndex.byId) {
-            if (relRef.type.toUpperCase() !== 'IFCRELDEFINESBYPROPERTIES')
-                continue;
-            const psetId = this.getRelatedPropertySet(relId);
-            if (!psetId)
-                continue;
-            const related = this.getRelatedEntities(relId);
-            relatedByRel.set(relId, related);
-            for (const entityId of related) {
-                let bucket = byEntity.get(entityId);
-                if (!bucket) {
-                    bucket = [];
-                    byEntity.set(entityId, bucket);
-                }
-                bucket.push({ relId, psetId });
-            }
-        }
-        return { byEntity, relatedByRel };
-    }
-    /**
-     * The source STEP text of an entity's line, or `null` when there are no bytes
-     * to read.
-     *
-     * The byte check is on the RANGE, not on `dataStore.source`. `source` is a
-     * MANDATORY accessor — `EMPTY_SOURCE_BYTES` is how "this model kept no bytes"
-     * is spelled (server-parsed, synthetic, GLB and point-cloud stores all have
-     * one) — so the `!this.dataStore.source` guard the five readers below used to
-     * carry never fired. It was also redundant: a zero-length range decodes to
-     * `''`, which fails every regex those readers run, so they already answered
-     * "nothing" for a sourceless store. Scoping the check to the range is what
-     * makes the guard live without changing a single answer, the same shape and
-     * for the same reason as `reference-collector.ts` (#2339).
-     *
-     * An OVERLAY-created entity never reaches here: every caller resolves its id
-     * through `dataStore.entityIndex.byId`, which holds source records only
-     * (`effective-index.ts` synthesises the overlay refs on its own side and
-     * writes nothing back), so an overlay id is already `undefined` at the
-     * lookup and is served by the callers' documented "not a source record"
-     * path. That is why an early return is safe HERE and is NOT safe at the
-     * visible-only closure in `export` — see the comment there.
-     *
-     * ## Why `isReadableSourceRef` and not `byteLength === 0`
-     *
-     * An out-of-range ref does NOT degrade to "no match" here. `decodeUtf8`
-     * clamps the range it cannot address, and the clamped window is still a
-     * window over real file bytes — so these readers answer from somebody
-     * ELSE's record. `source-ref-bounds.ts` (#2491) carries the measured
-     * account of both shapes and of why "a clamped, empty decode already yields
-     * no match" is false; it is not restated here, because an argument kept in
-     * two files is an argument that has to stay true in two files.
-     *
-     * The consequence specific to THIS site is that the wrong answer is acted
-     * on. `retainSharedAtoms` un-skips every id `getPropertyIdsInSet` returns,
-     * so a member list read out of the wrong record un-skips the wrong atoms;
-     * and the source-iteration pass already refuses to emit a record whose ref
-     * fails `isReadableSourceRef` (see the `continue` in `export`), so before
-     * this gate these readers were making decisions on behalf of a container
-     * that the same export had decided not to write. Gating them on the same
-     * predicate is what makes the two passes agree.
-     *
-     * The degradation is the one the exporter already handles: a record with no
-     * emittable bytes, generating nothing and named by nothing. It costs one
-     * answer that used to be right by luck — an overrunning ref on the file's
-     * LAST record clamps back to exactly that record's text — but that record
-     * is one the emission pass drops anyway, so keeping the answer only kept
-     * the disagreement.
-     */
-    entityLineText(entityId) {
-        const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        if (!entityRef || !this.isReadableSourceRef(entityRef))
-            return null;
-        return decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
-    }
-    /**
-     * Get entity IDs related by IfcRelDefinesByProperties (the related objects)
-     */
-    getRelatedEntities(relId) {
-        const entityText = this.entityLineText(relId);
-        if (entityText === null)
-            return [];
-        // 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*;/);
-        if (!match)
-            return [];
-        const objectsList = match[1];
-        const refs = [];
-        const refMatches = objectsList.matchAll(/#(\d+)/g);
-        for (const m of refMatches) {
-            refs.push(parseInt(m[1], 10));
-        }
-        return refs;
-    }
-    /**
-     * Get the property set ID from IfcRelDefinesByProperties
-     */
-    getRelatedPropertySet(relId) {
-        const entityText = this.entityLineText(relId);
-        if (entityText === null)
-            return null;
-        // Last #ID before the closing );
-        const match = entityText.match(/,\s*#(\d+)\s*\)\s*;$/);
-        if (!match)
-            return null;
-        return parseInt(match[1], 10);
-    }
-    /**
-     * Get the name of a property set by parsing the entity
-     */
-    getPropertySetName(psetId) {
-        const entityText = this.entityLineText(psetId);
-        if (entityText === null)
-            return null;
-        // Parse: IFCPROPERTYSET('guid',$,'Name',$,...) - Name is 3rd argument
-        const match = entityText.match(/IFCPROPERTYSET\s*\([^,]*,[^,]*,'([^']*)'/i);
-        if (!match)
-            return null;
-        return match[1];
-    }
-    /**
-     * Get the name of an element quantity set by parsing the entity
-     */
-    getElementQuantityName(entityId) {
-        const entityText = this.entityLineText(entityId);
-        if (entityText === null)
-            return null;
-        // Parse: IFCELEMENTQUANTITY('guid',$,'Name',...) - Name is 3rd argument
-        const match = entityText.match(/IFCELEMENTQUANTITY\s*\([^,]*,[^,]*,'([^']*)'/i);
-        if (!match)
-            return null;
-        return match[1];
-    }
-    /**
-     * Get IDs of properties in a property set
-     */
     /**
      * Un-skip property/quantity atoms that a surviving (non-skipped, and — under
      * visible-only export — still-included) IfcPropertySet / IfcElementQuantity
@@ -2089,6 +1424,10 @@ export class StepExporter {
     retainSharedAtoms(skipIds, allowedEntityIds) {
         if (skipIds.size === 0)
             return;
+        // Built once for the whole sweep rather than per container: the readers in
+        // `step-property-sets.ts` take the context, and this loop calls one of them
+        // once per IfcPropertySet / IfcElementQuantity in the file.
+        const ctx = this.propertySetContext();
         const byType = this.dataStore.entityIndex.byType;
         const containerIds = [
             ...(byType.get('IFCPROPERTYSET') ?? []),
@@ -2102,54 +1441,11 @@ export class StepExporter {
             // so it cannot keep an atom alive.
             if (allowedEntityIds !== null && !allowedEntityIds.has(containerId))
                 continue;
-            for (const atomId of this.getPropertyIdsInSet(containerId)) {
+            for (const atomId of getPropertyIdsInSet(ctx, containerId)) {
                 skipIds.delete(atomId);
             }
         }
     }
-    getPropertyIdsInSet(psetId) {
-        const entityText = this.entityLineText(psetId);
-        if (entityText === null)
-            return [];
-        // Parse: IFCPROPERTYSET(...,(#prop1,#prop2,...)); - Last argument is properties list
-        const match = entityText.match(/\(\s*(#[^)]+)\s*\)\s*\)\s*;$/);
-        if (!match)
-            return [];
-        const propsList = match[1];
-        const ids = [];
-        const refMatches = propsList.matchAll(/#(\d+)/g);
-        for (const m of refMatches) {
-            ids.push(parseInt(m[1], 10));
-        }
-        return ids;
-    }
-    /**
-     * The full HasPropertySets id list of a type object, from whichever authority
-     * owns the record.
-     *
-     * Slot 5 is `HasPropertySets` on every `IfcTypeObject` subtype. For a source
-     * record the list is parsed out of the file; for an overlay-created type it is
-     * read off the authored payload, where a reference is the documented `'#42'`
-     * string form. Reading only the source made every pset on a created
-     * `IfcWallType` look unowned, which is how it ended up on an occurrence
-     * relation instead (#2012).
-     */
-    getTypeOwnedHasPropertySetIds(entityId, effective) {
-        if (effective.isOverlayCreated(entityId)) {
-            const authored = this.mutationView?.getNewEntity(entityId)?.attributes?.[HAS_PROPERTY_SETS_SLOT];
-            return authoredEntityRefs(this.overlaySlotValue(entityId, HAS_PROPERTY_SETS_SLOT, authored));
-        }
-        if (!this.entityExtractor)
-            return [];
-        const entityRef = this.dataStore.entityIndex.byId.get(entityId);
-        if (!entityRef)
-            return [];
-        const entity = this.entityExtractor.extractEntity(entityRef);
-        const hasPropertySets = entity?.attributes?.[HAS_PROPERTY_SETS_SLOT];
-        if (!Array.isArray(hasPropertySets))
-            return [];
-        return hasPropertySets.filter((value) => typeof value === 'number');
-    }
 }
 /**
  * Quick export function for simple use cases.