@ifc-lite/export 3.0.1 → 4.0.0

package/dist/merged-exporter.js

@@ -1,14 +1,21 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-import { generateHeader, deterministicGlobalId, IfcParser, asSourceBytes, getInheritanceChainAcrossSchemas, } from '@ifc-lite/parser';
+import { generateHeader, IfcParser, asSourceBytes, } from '@ifc-lite/parser';
 import { decodeIfcString } from '@ifc-lite/encoding';
-import { collectReferencedEntityIds, getVisibleEntityIds, collectStyleEntities, filterHiddenRefsFromRelationshipLine, } from './reference-collector.js';
+import { collectReferencedEntityIds, getVisibleEntityIds, filterHiddenRefsFromRelationshipLine, } from './reference-collector.js';
+import { collectStyleEntities, STYLE_RESCUE_TYPES } from './style-closure.js';
+import { collectGeoreferencingEntities } from './georef-closure.js';
 import { convertStepLine, needsConversion } from './schema-converter.js';
 import { assembleStepBytes, assembleStepBlob } from './step-file-assembly.js';
 import { getCompleteEntityIndex, getMaxExpressId } from './entity-iteration.js';
 import { StepExporter } from './step-exporter.js';
 import { rescaleEntityLengths, computeNormalizeFactor } from './unit-normalize.js';
+import { planInfrastructureUnify, resolvePrimaryContextState } from './merged-context.js';
+import { remapEntityText } from './merged-remap.js';
+import { extractGlobalIdFast, mintUniqueGuid, readLeadingGuid, replaceGlobalId, } from './merged-guid.js';
+import { planEmptyContainerDrops, EMPTY_MODEL_VIEW, } from './merged-empty-containers.js';
+import { skipRedundantRelAggregates, applyRelAggregateStrip, collectRelAggregatePairs } from './merged-rel-aggregates.js';
 /**
  * UTF-8 decode of `[start, end)` of a model's source, accepting either the raw
  * bytes or the {@link IfcSourceBytes} accessor (#2183). Replaces the direct
@@ -25,38 +32,6 @@ const SHARED_INFRASTRUCTURE_TYPES = new Set([
     'IFCGEOMETRICREPRESENTATIONCONTEXT',
     'IFCGEOMETRICREPRESENTATIONSUBCONTEXT',
 ]);
-/**
- * An IfcGloballyUniqueId is exactly 22 characters of the buildingSMART base64
- * alphabet. We use this to recognise a rooted entity (IfcRoot subtype) by its
- * first attribute. Geometry/list entities never carry a string there, but some
- * non-rooted RESOURCE entities lead with a Name/Identifier string that can
- * legitimately be 22 charset chars (e.g. a coded property key). Those are
- * excluded with a schema-derived rootedness check ({@link isRootedType}) so
- * their Name is never mistaken for a GlobalId — otherwise the GlobalId
- * reconciliation could drop or rename them.
- */
-const GLOBAL_ID_RE = /^[0-9A-Za-z_$]{22}$/;
-/**
- * Whether `type` is an IfcRoot subtype — a schema-derived replacement for a
- * hand-maintained denylist of "non-rooted types whose first attribute happens
- * to be a string". A denylist has to be told about every such type by hand and
- * silently under-covers as the schema grows — `IfcMaterialProfileWithOffsets`
- * and several other resource types were missing and got their leading Name
- * treated as a GlobalId, corrupting ordinary model data on a collision.
- *
- * `getInheritanceChainAcrossSchemas` walks the bundled IFC2X3/IFC4/IFC4X3
- * schema union to the entity's root ancestor; a rooted entity's chain always
- * ends in `IfcRoot`. This mirrors the Rust side's `IfcType::is_subtype_of`
- * schema check, so the two implementations of "is this rooted" agree instead
- * of drifting apart as separate hand-maintained lists.
- *
- * A type unknown to every bundled schema (typo, vendor extension) yields an
- * empty chain and is treated as non-rooted — the same safe-miss direction the
- * old denylist documented: it just skips one GlobalId reconciliation.
- */
-export function isRootedType(type) {
-    return getInheritanceChainAcrossSchemas(type).includes('IfcRoot');
-}
 /** True for IfcRelationship subtypes (objectified relationships). */
 function isRelationshipType(typeUpper) {
     return typeUpper.startsWith('IFCREL');
@@ -163,6 +138,7 @@ export class MergedExporter {
         }
         const models = withUsableSource(this.models);
         const setup = this.buildMergeSetup(options, models);
+        const containerDrops = this.planContainerDrops(options, models, setup);
         const allEntityLines = [];
         // Tracks every GlobalId already emitted → its final express id + unit scale,
         // so later models can unify against (shared unit) or stay unique from
@@ -189,13 +165,14 @@ export class MergedExporter {
                 this.collectNormalizeCaveats(model, normalizeWarnings);
             }
             const plan = this.planModel(model, completeIndex, isFirstModel, mode.compatible, mode.lengthFactor, setup, guidToFinalId);
+            this.applyContainerDrops(plan, containerDrops?.byModel.get(model.id));
             const sourceSchema = model.dataStore.schemaVersion || 'IFC4';
             for (const [expressId, entityRef] of completeIndex) {
                 if (visibility !== null && !visibility.included.has(expressId))
                     continue;
                 if (plan.skipEntityIds.has(expressId))
                     continue;
-                const line = this.renderEntity(expressId, entityRef, source, offset, plan, sourceSchema, schema, guidToFinalId, mode, visibility?.hiddenProductIds ?? null, completeIndex);
+                const line = this.renderEntity(expressId, entityRef, source, offset, plan, sourceSchema, schema, guidToFinalId, mode, visibility?.hiddenProductIds ?? null, completeIndex, visibility?.included ?? null);
                 if (line !== null)
                     allEntityLines.push(line);
             }
@@ -207,7 +184,7 @@ export class MergedExporter {
         const content = assembleStepBytes(header, allEntityLines);
         return {
             content,
-            stats: this.buildStats(allEntityLines.length, content.byteLength, federatedModelCount, normalizedModelCount, normalizeWarnings),
+            stats: this.buildStats(allEntityLines.length, content.byteLength, federatedModelCount, normalizedModelCount, normalizeWarnings, containerDrops?.count ?? 0),
         };
     }
     /**
@@ -223,7 +200,7 @@ export class MergedExporter {
         }
         return {
             content,
-            stats: this.buildStats(doc.allEntityLines.length, content.byteLength, doc.federatedModelCount, doc.normalizedModelCount, doc.normalizeWarnings),
+            stats: this.buildStats(doc.allEntityLines.length, content.byteLength, doc.federatedModelCount, doc.normalizedModelCount, doc.normalizeWarnings, doc.droppedContainerCount),
         };
     }
     /**
@@ -244,7 +221,7 @@ export class MergedExporter {
         }
         return {
             content,
-            stats: this.buildStats(doc.allEntityLines.length, content.size, doc.federatedModelCount, doc.normalizedModelCount, doc.normalizeWarnings),
+            stats: this.buildStats(doc.allEntityLines.length, content.size, doc.federatedModelCount, doc.normalizedModelCount, doc.normalizeWarnings, doc.droppedContainerCount),
         };
     }
     /**
@@ -267,6 +244,7 @@ export class MergedExporter {
         // without edits pass through unchanged (no export/parse cost).
         const models = withUsableSource(await this.bakeMutatedModels());
         const setup = this.buildMergeSetup(options, models);
+        const containerDrops = this.planContainerDrops(options, models, setup);
         const allEntityLines = [];
         const guidToFinalId = new Map();
         // First pass: count total entities for progress
@@ -306,6 +284,7 @@ export class MergedExporter {
                 this.collectNormalizeCaveats(model, normalizeWarnings);
             }
             const plan = this.planModel(model, completeIndex, isFirstModel, mode.compatible, mode.lengthFactor, setup, guidToFinalId);
+            this.applyContainerDrops(plan, containerDrops?.byModel.get(model.id));
             const sourceSchema = model.dataStore.schemaVersion || 'IFC4';
             let entityCount = 0;
             for (const [expressId, entityRef] of completeIndex) {
@@ -313,7 +292,7 @@ export class MergedExporter {
                     continue;
                 if (plan.skipEntityIds.has(expressId))
                     continue;
-                const line = this.renderEntity(expressId, entityRef, source, offset, plan, sourceSchema, schema, guidToFinalId, mode, visibility?.hiddenProductIds ?? null, completeIndex);
+                const line = this.renderEntity(expressId, entityRef, source, offset, plan, sourceSchema, schema, guidToFinalId, mode, visibility?.hiddenProductIds ?? null, completeIndex, visibility?.included ?? null);
                 if (line !== null)
                     allEntityLines.push(line);
                 entityCount++;
@@ -339,7 +318,7 @@ export class MergedExporter {
             onProgress({ phase: 'assembling', percent: 0.9, entitiesProcessed: totalEntities, entitiesTotal: totalEntities });
         }
         await new Promise(r => setTimeout(r, 0));
-        return { header, allEntityLines, federatedModelCount, normalizedModelCount, normalizeWarnings, totalEntities };
+        return { header, allEntityLines, federatedModelCount, normalizedModelCount, normalizeWarnings, droppedContainerCount: containerDrops?.count ?? 0, totalEntities };
     }
     /**
      * Bake each model's pending edits into its source bytes before merging.
@@ -387,7 +366,7 @@ export class MergedExporter {
     /**
      * Assemble the result stats, including any federation conformance warnings.
      */
-    buildStats(totalEntityCount, fileSize, federatedModelCount, normalizedModelCount, normalizeWarnings) {
+    buildStats(totalEntityCount, fileSize, federatedModelCount, normalizedModelCount, normalizeWarnings, droppedContainerCount) {
         const warnings = [];
         if (federatedModelCount > 0) {
             warnings.push(`${federatedModelCount} model(s) had a length unit differing from the first model and were ` +
@@ -398,7 +377,50 @@ export class MergedExporter {
                 `single-unit project, or 'assume-shared' when units are already normalised.`);
         }
         warnings.push(...normalizeWarnings);
-        return { modelCount: this.models.length, totalEntityCount, fileSize, federatedModelCount, normalizedModelCount, warnings };
+        return { modelCount: this.models.length, totalEntityCount, fileSize, federatedModelCount, normalizedModelCount, droppedContainerCount, warnings };
+    }
+    /**
+     * Plan the empty spatial containers of the whole merge (#3643), or `null` when
+     * the caller did not ask for the drop. Reproduces the same spatial unification
+     * {@link planModel} will, so emptiness is judged on the containers the merge
+     * actually keeps rather than on each file in isolation.
+     */
+    planContainerDrops(options, models, setup) {
+        if (!options.dropEmptyContainers)
+            return null;
+        const views = models.map((model, index) => {
+            const source = model.dataStore.source;
+            if (!source || source.length === 0)
+                return EMPTY_MODEL_VIEW;
+            const entities = getCompleteEntityIndex(model.dataStore);
+            const mode = this.resolveModelMode(model, index === 0, setup);
+            const sharedRemap = new Map();
+            if (index > 0 && mode.compatible) {
+                this.unifySpatialEntities(model.dataStore, setup.spatialLookup, setup.firstModelOffset, mode.lengthFactor, sharedRemap, new Set(), setup);
+            }
+            return {
+                entities,
+                source: asSourceBytes(source),
+                included: this.computeIncludedEntityIds(model, options, entities, source)?.included ?? null,
+                sharedRemap,
+                offset: setup.modelOffsets.get(model.id),
+                compatible: mode.compatible,
+            };
+        });
+        const plan = planEmptyContainerDrops(views);
+        return {
+            byModel: new Map(models.map((model, index) => [model.id, plan.droppedByModel[index]])),
+            count: plan.droppedCount,
+        };
+    }
+    /** Fold a model's dropped containers into its plan: the container lines are
+     *  skipped outright, and {@link renderEntity} narrows every line naming one. */
+    applyContainerDrops(plan, dropped) {
+        if (dropped === undefined || dropped.size === 0)
+            return;
+        plan.droppedContainerIds = dropped;
+        for (const id of dropped)
+            plan.skipEntityIds.add(id);
     }
     /**
      * Record advisories for a model being normalized. The rescaler derives its
@@ -451,12 +473,16 @@ export class MergedExporter {
         }
         const firstModel = models[0];
         const primaryScale = this.resolveUnitScale(firstModel);
+        const firstModelOffset = modelOffsets.get(firstModel.id);
+        const firstModelInfraMap = this.findInfrastructureEntities(firstModel.dataStore);
         return {
             modelOffsets,
-            firstModelOffset: modelOffsets.get(firstModel.id),
-            firstModelInfraMap: this.findInfrastructureEntities(firstModel.dataStore),
+            firstModelOffset,
+            firstModelInfraMap,
+            firstModelContext: resolvePrimaryContextState(firstModel.dataStore, firstModelInfraMap.get('IFCGEOMETRICREPRESENTATIONSUBCONTEXT') ?? [], primaryScale),
             firstProjectIds: this.findEntitiesByType(firstModel.dataStore, 'IFCPROJECT'),
             spatialLookup: this.buildSpatialLookup(firstModel.dataStore),
+            primaryAggregatePairs: collectRelAggregatePairs(firstModel.dataStore, this.findEntitiesByType.bind(this), this.extractStepAttribute.bind(this), firstModelOffset),
             primaryScale,
             primaryAreaScale: this.resolveDerivedUnitScale(firstModel.dataStore, 'AREAUNIT', primaryScale, 2),
             primaryVolumeScale: this.resolveDerivedUnitScale(firstModel.dataStore, 'VOLUMEUNIT', primaryScale, 3),
@@ -511,8 +537,8 @@ export class MergedExporter {
      * Resolve a model's declared AREAUNIT / VOLUMEUNIT scale (SI m² / m³ per unit)
      * by walking IfcProject → IfcUnitAssignment. Falls back to the length-derived
      * unit (`lengthScale ** power`) when the model declares no explicit area/volume
-     * unit — the IFC default. A prefixed SI area/volume unit (rare) applies the
-     * prefix once (buildingSMART / IfcOpenShell convention).
+     * unit — the IFC default. A prefixed SI area/volume unit (rare) raises the
+     * prefix to `power` (area = prefix², volume = prefix³), matching `rust/core`.
      */
     resolveDerivedUnitScale(dataStore, wantType, lengthScale, power) {
         const fallback = Math.pow(lengthScale, power);
@@ -539,8 +565,8 @@ export class MergedExporter {
                 const prefixRaw = this.extractStepAttribute(uid, dataStore, 2);
                 if (!prefixRaw || prefixRaw === '$' || prefixRaw === '*')
                     return 1.0; // square/cubic metre
-                const mult = SI_PREFIX_MULTIPLIERS[this.normalizeEnum(prefixRaw)];
-                return mult !== undefined ? mult : 1.0;
+                const mult = SI_PREFIX_MULTIPLIERS[this.normalizeEnum(prefixRaw)]; // see doc: raised to `power`
+                return mult !== undefined ? Math.pow(mult, power) : 1.0;
             }
             if (utype === 'IFCCONVERSIONBASEDUNIT') {
                 // IfcConversionBasedUnit: [1] UnitType, [2] Name, [3] ConversionFactor.
@@ -614,11 +640,13 @@ export class MergedExporter {
         const isolatedIds = options.isolatedEntityIdsByModel?.get(model.id) ?? null;
         const { roots, hiddenProductIds } = getVisibleEntityIds(model.dataStore, hiddenIds, isolatedIds);
         const included = collectReferencedEntityIds(roots, source, completeIndex, hiddenProductIds);
-        // Second pass: collect style entities that reference included geometry.
+        // Second pass: style entities referencing included geometry (see style-closure.ts).
         collectStyleEntities(included, source, {
             byId: completeIndex,
             byType: model.dataStore.entityIndex.byType,
-        });
+        }, hiddenProductIds);
+        // Third pass: rescue IFCMAPCONVERSION/IFCPROJECTEDCRS — see georef-closure.ts.
+        collectGeoreferencingEntities(included, source, { byId: completeIndex, byType: model.dataStore.entityIndex.byType }, hiddenProductIds);
         return { included, hiddenProductIds };
     }
     /**
@@ -641,10 +669,11 @@ export class MergedExporter {
         const sharedRemap = new Map();
         const skipEntityIds = new Set();
         const guidRewrite = new Map();
+        const relAggregateStrip = new Map();
         // One cheap pass to read each rooted entity's GlobalId (first attribute).
         const localGuids = new Map();
         for (const [id, ref] of completeIndex) {
-            const guid = this.extractGlobalIdFast(ref, source);
+            const guid = extractGlobalIdFast(ref, source);
             if (guid !== null)
                 localGuids.set(id, guid);
         }
@@ -657,21 +686,15 @@ export class MergedExporter {
                     skipEntityIds.add(pid);
                 }
             }
-            // Remap and skip duplicate infrastructure (units, contexts).
-            const modelInfra = this.findInfrastructureEntities(model.dataStore);
-            for (const [type, firstIds] of setup.firstModelInfraMap) {
-                const thisIds = modelInfra.get(type);
-                if (thisIds && firstIds.length > 0 && thisIds.length > 0) {
-                    sharedRemap.set(thisIds[0], firstIds[0] + setup.firstModelOffset);
-                    skipEntityIds.add(thisIds[0]);
-                }
-            }
+            // Remap and skip duplicate infrastructure (units, contexts) — WCS-gated; scale choice documented on planInfrastructureUnify (merged-context.ts).
+            planInfrastructureUnify(model.dataStore, this.findInfrastructureEntities(model.dataStore), setup.firstModelInfraMap, setup.firstModelContext, setup.firstModelOffset, setup.assumeShared ? setup.primaryScale : this.resolveUnitScale(model), sharedRemap, skipEntityIds);
             // Unify spatial hierarchy: match Site, Building, Storey to first model.
             // Under normalize, this model's raw elevations are in its own unit, so the
             // elevation match is done in the primary unit (rawElevation * lengthFactor).
             this.unifySpatialEntities(model.dataStore, setup.spatialLookup, setup.firstModelOffset, lengthFactor, sharedRemap, skipEntityIds, setup);
-            // Skip IfcRelAggregates that become fully redundant after unification.
-            this.skipRedundantRelAggregates(model.dataStore, sharedRemap, skipEntityIds);
+            // Skip IfcRelAggregates that become fully redundant after unification,
+            // and strip individually-duplicated members from ones only partially so.
+            skipRedundantRelAggregates(model.dataStore, sharedRemap, skipEntityIds, relAggregateStrip, setup.primaryAggregatePairs, this.findEntitiesByType.bind(this), this.extractStepAttribute.bind(this));
         }
         if (!isFirstModel) {
             // GlobalId reconciliation against everything emitted by earlier models.
@@ -699,11 +722,11 @@ export class MergedExporter {
                     skipEntityIds.add(id);
                 }
                 else {
-                    guidRewrite.set(id, this.mintUniqueGuid(guid, model.id, guidToFinalId, pendingMinted));
+                    guidRewrite.set(id, mintUniqueGuid(guid, model.id, guidToFinalId, pendingMinted));
                 }
             }
         }
-        return { sharedRemap, skipEntityIds, guidRewrite, localGuids };
+        return { sharedRemap, skipEntityIds, guidRewrite, localGuids, relAggregateStrip };
     }
     /**
      * Render one source entity into its final STEP line: apply id offset + shared
@@ -713,43 +736,69 @@ export class MergedExporter {
      * `hiddenProductIds` withholds a relationship whose every named subject was
      * hidden (below).
      */
-    renderEntity(localId, entityRef, source, offset, plan, sourceSchema, targetSchema, guidToFinalId, mode, hiddenProductIds, completeIndex) {
+    renderEntity(localId, entityRef, source, offset, plan, sourceSchema, targetSchema, guidToFinalId, mode, hiddenProductIds, completeIndex, includedIds) {
         let entityText = decodeRange(source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // A `visibleOnly` export must narrow — or entirely withhold — a
-        // relationship's own OUTPUT line the same way `StepExporter` does
-        // (`isOmittedFromOutput`, consumed at its two
-        // `filterHiddenRefsFromRelationshipLine` call sites — named rather than
-        // cited by line number, which went stale the first time either file moved).
-        // NOTE the predicates are not identical: `StepExporter`'s also answers for
-        // an unreadable source ref and a geometry exclusion, which this one — a
-        // hidden product or an id absent from the complete index — does not.
+        // relationship's (and, below, a rescued style/layer entity's) own OUTPUT
+        // line the same way `StepExporter` does (`isOmittedFromOutput`, its two
+        // `filterHiddenRefsFromRelationshipLine` call sites). NOTE the predicates
+        // are not identical: `StepExporter`'s also answers for an unreadable
+        // source ref and a geometry exclusion, which these do not.
         // `collectReferencedEntityIds` already refuses to WALK INTO a relationship
         // whose sole subject is hidden (#2548), but a root's own bytes are still
         // copied to the output verbatim unless narrowed here too — without this,
-        // a hidden id survived as a dangling `#N` with no `#N=` line (the #2398
-        // shape), which is exactly what closing the #2548 closure leak would
-        // otherwise have traded it for. Runs in LOCAL id space, before the remap
-        // below, because `hiddenProductIds` and `completeIndex` are both local to
-        // this model.
-        if (hiddenProductIds !== null && isRelationshipType(entityRef.type.toUpperCase())) {
-            const isExcluded = (id) => hiddenProductIds.has(id) || !completeIndex.has(id);
-            const filtered = filterHiddenRefsFromRelationshipLine(entityText, isExcluded);
-            if (filtered === null)
+        // a hidden id survives as a dangling `#N` with no `#N=` line (#2398).
+        // Runs in LOCAL id space, before the remap below.
+        if (hiddenProductIds !== null) {
+            const entityTypeUpper = entityRef.type.toUpperCase();
+            // Same narrowing for a rescued style/layer entity (`STYLE_RESCUE_TYPES`,
+            // `style-closure.ts`): its line can name a kept AND an excluded id (a
+            // shared CAD layer) — `hiddenProductIds` misses that id (exclusively-
+            // owned geometry, not a hidden PRODUCT), so this arm uses `includedIds`.
+            const isExcluded = isRelationshipType(entityTypeUpper)
+                ? (id) => hiddenProductIds.has(id) || !completeIndex.has(id)
+                : STYLE_RESCUE_TYPES.has(entityTypeUpper) && includedIds !== null
+                    ? (id) => !includedIds.has(id) || !completeIndex.has(id)
+                    : null;
+            if (isExcluded) {
+                const filtered = filterHiddenRefsFromRelationshipLine(entityText, isExcluded);
+                if (filtered === null)
+                    return null;
+                entityText = filtered;
+            }
+        }
+        // A dropped empty spatial container (#3643) is never written, so any line
+        // naming one is narrowed the same way — or withheld with it. Runs in LOCAL
+        // id space, before the remap below, like the visibility narrowing above.
+        if (plan.droppedContainerIds !== undefined) {
+            const kept = filterHiddenRefsFromRelationshipLine(entityText, id => plan.droppedContainerIds.has(id));
+            if (kept === null)
                 return null;
-            entityText = filtered;
+            entityText = kept;
         }
+        // Drop RelatedObjects members a partially redundant IFCRELAGGREGATES
+        // already shares with the first model's OWN relationship to the same
+        // (now-unified) RelatingObject — see skipRedundantRelAggregates /
+        // applyRelAggregateStrip (merged-rel-aggregates.ts). Runs in LOCAL id
+        // space, before the remap below. `null` (the filter would withhold the
+        // whole line) propagates like the two passes above: every edge the line
+        // declared already exists in the primary model.
+        const stripped = applyRelAggregateStrip(entityText, localId, plan.relAggregateStrip);
+        if (stripped === null)
+            return null;
+        entityText = stripped;
         // Remap ids. Fast path: the first model (offset 0, no remaps) is byte-identical.
         let finalText;
         if (offset === 0 && plan.sharedRemap.size === 0) {
             finalText = entityText;
         }
         else {
-            finalText = this.remapEntityText(entityText, offset, plan.sharedRemap);
+            finalText = remapEntityText(entityText, offset, plan.sharedRemap);
         }
         // Re-stamp the GlobalId for a federated entity whose id collides.
         const mintedGuid = plan.guidRewrite.get(localId);
         if (mintedGuid !== undefined) {
-            finalText = this.replaceGlobalId(finalText, mintedGuid);
+            finalText = replaceGlobalId(finalText, mintedGuid);
         }
         // Normalize units: rescale every length/area/volume-valued datum into the
         // primary unit. Done on the SOURCE-schema text (entityRef.type), before any
@@ -771,7 +820,7 @@ export class MergedExporter {
         // Emitted entities are not sharedRemap keys, so their final id is
         // localId + offset.
         if (plan.localGuids.has(localId)) {
-            const emittedGuid = this.readLeadingGuid(finalText)
+            const emittedGuid = readLeadingGuid(finalText)
                 ?? mintedGuid ?? plan.localGuids.get(localId);
             if (emittedGuid !== undefined) {
                 guidToFinalId.set(emittedGuid, { finalId: localId + offset, scale: mode.effectiveScale });
@@ -779,142 +828,6 @@ export class MergedExporter {
         }
         return finalText;
     }
-    /**
-     * Read the GlobalId (first quoted attribute) from an already-rendered STEP
-     * line. Used to register the id that was actually emitted, after any id
-     * remap, GlobalId re-stamp, or schema conversion. Returns null if the first
-     * quoted token is not a 22-char GlobalId.
-     */
-    readLeadingGuid(entityText) {
-        const open = entityText.indexOf('(');
-        if (open === -1)
-            return null;
-        const q1 = entityText.indexOf("'", open + 1);
-        if (q1 === -1)
-            return null;
-        const q2 = entityText.indexOf("'", q1 + 1);
-        if (q2 === -1)
-            return null;
-        const raw = entityText.slice(q1 + 1, q2);
-        return GLOBAL_ID_RE.test(raw) ? raw : null;
-    }
-    /**
-     * Mint a fresh, deterministic, collision-free GlobalId for an entity whose id
-     * collides. Seeded from the original GlobalId and the model's stable id so the
-     * output is reproducible and does not churn when an unrelated earlier model
-     * changes size; checked against both already-emitted ids and the ids minted
-     * so far for this model.
-     */
-    mintUniqueGuid(original, modelId, guidToFinalId, pendingMinted) {
-        let candidate = deterministicGlobalId(`${original}#${modelId}`);
-        let n = 0;
-        while (guidToFinalId.has(candidate) || pendingMinted.has(candidate)) {
-            candidate = deterministicGlobalId(`${original}#${modelId}#${n++}`);
-        }
-        pendingMinted.add(candidate);
-        return candidate;
-    }
-    /**
-     * Read an entity's GlobalId (first attribute) by decoding only its head.
-     * Returns the 22-char id for a rooted entity, or `null` for any entity whose
-     * first attribute is not a GlobalId (geometry, lists, property atoms, …).
-     */
-    extractGlobalIdFast(ref, source) {
-        // Non-rooted resource entities (property/quantity/material/style/actor …)
-        // lead with a Name string that can itself be 22 charset chars; never treat
-        // those as a GlobalId or reconciliation would drop/rename them.
-        if (!isRootedType(ref.type ?? ''))
-            return null;
-        // 128 bytes comfortably spans `#<id>=<LONGEST_TYPE_NAME>('<22-char id>'`,
-        // so the GlobalId is always fully inside the window.
-        const end = Math.min(ref.byteOffset + 128, ref.byteOffset + ref.byteLength);
-        const head = decodeRange(source, ref.byteOffset, end);
-        const open = head.indexOf('(');
-        if (open === -1)
-            return null;
-        let i = open + 1;
-        while (i < head.length && (head[i] === ' ' || head[i] === '\t' || head[i] === '\n' || head[i] === '\r'))
-            i++;
-        if (head[i] !== "'")
-            return null;
-        // A GlobalId never contains a quote (charset excludes it), so the next
-        // quote closes it.
-        const close = head.indexOf("'", i + 1);
-        if (close === -1)
-            return null;
-        const raw = head.slice(i + 1, close);
-        return GLOBAL_ID_RE.test(raw) ? raw : null;
-    }
-    /**
-     * Replace an entity's GlobalId (first quoted attribute) with `newGuid`.
-     * `newGuid` is a 22-char IFC id (no quote in its charset), so this is safe.
-     */
-    replaceGlobalId(entityText, newGuid) {
-        const open = entityText.indexOf('(');
-        if (open === -1)
-            return entityText;
-        const q1 = entityText.indexOf("'", open + 1);
-        if (q1 === -1)
-            return entityText;
-        const q2 = entityText.indexOf("'", q1 + 1);
-        if (q2 === -1)
-            return entityText;
-        return entityText.slice(0, q1 + 1) + newGuid + entityText.slice(q2);
-    }
-    /**
-     * Remap all #ID references in a STEP entity line.
-     * Applies offset to all IDs, then overrides with specific remappings.
-     *
-     * Only `#<digits>` tokens in code positions are rewritten; tokens inside
-     * single-quoted STEP strings (e.g. a 'Room #205' Name or a 'http://x#42'
-     * URL) are left untouched so string attribute values are not corrupted.
-     */
-    remapEntityText(entityText, offset, sharedRemap) {
-        const remapId = (originalId) => {
-            // Check if this ID has a specific remap (project, shared infrastructure)
-            const remapped = sharedRemap.get(originalId);
-            if (remapped !== undefined) {
-                return `#${remapped}`;
-            }
-            // Apply offset
-            return `#${originalId + offset}`;
-        };
-        let out = '';
-        let inString = false;
-        for (let i = 0; i < entityText.length; i++) {
-            const char = entityText[i];
-            if (inString) {
-                out += char;
-                if (char === "'") {
-                    // STEP escapes a literal quote by doubling it ('').
-                    if (entityText[i + 1] === "'") {
-                        out += entityText[i + 1];
-                        i++;
-                    }
-                    else {
-                        inString = false;
-                    }
-                }
-                continue;
-            }
-            if (char === "'") {
-                inString = true;
-                out += char;
-                continue;
-            }
-            if (char === '#' && entityText[i + 1] >= '0' && entityText[i + 1] <= '9') {
-                let j = i + 1;
-                while (j < entityText.length && entityText[j] >= '0' && entityText[j] <= '9')
-                    j++;
-                const originalId = parseInt(entityText.slice(i + 1, j), 10);
-                out += remapId(originalId);
-                i = j - 1;
-                continue;
-            }
-            out += char;
-        }
-        return out;
-    }
     /**
      * Find entity IDs of shared infrastructure types in a data store.
      * Returns a map of uppercase type name → array of expressIds.
@@ -1083,43 +996,6 @@ export class MergedExporter {
             return byName();
         return byName() ?? bySingle();
     }
-    /**
-     * Skip IfcRelAggregates that become fully redundant after spatial unification.
-     *
-     * When Model2's `IfcRelAggregates(Project, (Site))` gets remapped to
-     * `IfcRelAggregates(FirstProject, (FirstSite))`, it duplicates Model1's
-     * existing relationship, causing viewers to show Site multiple times.
-     *
-     * An IfcRelAggregates is redundant if both its RelatingObject (attr 4)
-     * and ALL its RelatedObjects (attr 5) were remapped via sharedRemap.
-     */
-    skipRedundantRelAggregates(dataStore, sharedRemap, skipEntityIds) {
-        for (const relId of this.findEntitiesByType(dataStore, 'IFCRELAGGREGATES')) {
-            // RelatingObject is attr 4 — single #ref
-            const relatingAttr = this.extractStepAttribute(relId, dataStore, 4);
-            if (!relatingAttr)
-                continue;
-            const relatingRef = relatingAttr.match(/^#(\d+)$/);
-            if (!relatingRef || !sharedRemap.has(parseInt(relatingRef[1], 10)))
-                continue;
-            // RelatedObjects is attr 5 — list of #refs like (#2,#3)
-            const relatedAttr = this.extractStepAttribute(relId, dataStore, 5);
-            if (!relatedAttr)
-                continue;
-            const refs = [];
-            const refRegex = /#(\d+)/g;
-            let m;
-            while ((m = refRegex.exec(relatedAttr)) !== null) {
-                refs.push(parseInt(m[1], 10));
-            }
-            if (refs.length === 0)
-                continue;
-            // If ALL related objects were also remapped, this rel is fully redundant
-            if (refs.every(ref => sharedRemap.has(ref))) {
-                skipEntityIds.add(relId);
-            }
-        }
-    }
     /**
      * Extract the Name attribute (index 2) from a STEP entity.
      */