@ifc-lite/export 2.8.0 → 2.8.3

package/dist/step-exporter.js

@@ -1,8 +1,7 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-import { EntityExtractor, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
-import { safeUtf8Decode } from '@ifc-lite/data';
+import { asSourceBytes, EntityExtractor, generateHeader, parseSourceHeader, getAttributeNamesAcrossSchemas, serializeValue, ref, } from '@ifc-lite/parser';
 import { generateIfcGuid } from '@ifc-lite/encoding';
 import { collectReferencedEntityIds, getVisibleEntityIds, collectStyleEntities } from './reference-collector.js';
 import { convertStepLine, needsConversion } from './schema-converter.js';
@@ -14,8 +13,32 @@ import { escapeStepString, toStepReal, quantityTypeToIfcType, serializePropertyV
 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';
+/**
+ * UTF-8 decode of `[start, end)` of the source, accepting either the raw bytes
+ * or the {@link IfcSourceBytes} accessor (#2183). Replaces the direct
+ * `safeUtf8Decode(source, …)` calls this file used to make: `decodeUtf8` is
+ * SAB-safe in exactly the same way, and routing through the accessor is what
+ * lets `IfcDataStore.source` change shape without touching these eight reads.
+ */
+function decodeRange(src, start, end) {
+    return asSourceBytes(src).decodeUtf8(start, end);
+}
 /** `OwnerHistory` is slot 1 on every `IfcRoot` subtype, all schemas. */
 const OWNER_HISTORY_SLOT = 1;
+/**
+ * Message for the one refusal `export()` can report, shared by the returned
+ * `stats.warnings` entry and the console line so the two cannot drift.
+ */
+const MAP_CONVERSION_WITHOUT_CONTEXT_WARNING = 'Cannot create IfcMapConversion: no IfcGeometricRepresentationContext is available to reference as SourceCRS. The IfcProjectedCRS is unaffected.';
+/**
+ * Message for the refusal `export()` reports when a map conversion is
+ * requested but there is no IfcProjectedCRS to attach it to — none was
+ * requested and none exists in the file — distinct from
+ * {@link MAP_CONVERSION_WITHOUT_CONTEXT_WARNING}, which is worded for the
+ * case where an IfcProjectedCRS exists (or was written) but no context is
+ * available to reference.
+ */
+const MAP_CONVERSION_WITHOUT_CRS_WARNING = 'Cannot create IfcMapConversion: no IfcProjectedCRS was requested and none exists in the file to reference as TargetCRS. Nothing was written.';
 /**
  * IFC STEP file exporter
  */
@@ -69,7 +92,9 @@ export class StepExporter {
         // `sourceHeader`; fall back to parsing the (always-present) source bytes so
         // cache-restored stores — which don't carry `sourceHeader` — still work.
         const sourceHeader = this.dataStore.sourceHeader
-            ?? (this.dataStore.source ? parseSourceHeader(this.dataStore.source) : undefined);
+            ?? (this.dataStore.source.byteLength > 0
+                ? parseSourceHeader(this.dataStore.source)
+                : undefined);
         // Preserve the exact FILE_SCHEMA identifier (e.g. IFC4X3_ADD2) only when we
         // are NOT converting schemas; conversion must emit the coarse target token.
         const schemaToken = !converting && sourceHeader?.schemaIdentifiers?.[0]
@@ -115,6 +140,60 @@ export class StepExporter {
         // entity has no source bytes, so the source-iteration pass below never sees
         // it and the new-entities pass at the end owns its line entirely (#2006).
         const isOverlayCreated = (entityId) => effective.isOverlayCreated(entityId);
+        // Build visible-only closure if requested. Classification, the closure walk
+        // and the style pass all run over the EFFECTIVE index: an overlay-created
+        // product becomes a root by the same type rules as a parsed one, the walk
+        // follows its authored references into the geometry it alone owns, and a
+        // tombstoned entity is simply not there. Run over the source buffer, a
+        // created wall could never be a root and nothing referenced it, so
+        // `visibleOnly` wrote a file without it and said nothing (#2012).
+        //
+        // Computed here, ahead of the modification-count passes below, because
+        // `hasEmittableHostBytes` needs it: a source-backed host EXCLUDED by
+        // `visibleOnly` never gets its line written by the source-iteration pass
+        // either, so counting it as "modified" would make the header claim a
+        // change the DATA section does not contain (CodeRabbit finding on #2414).
+        let allowedEntityIds = null;
+        if (options.visibleOnly && this.dataStore.source) {
+            const { roots, hiddenProductIds } = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, effective);
+            allowedEntityIds = collectReferencedEntityIds(roots, this.dataStore.source, effective, hiddenProductIds);
+            // Second pass: collect IFCSTYLEDITEM entities that reference included
+            // geometry. Styled items reference geometry items but nothing references
+            // them back, so the forward closure misses them.
+            collectStyleEntities(allowedEntityIds, this.dataStore.source, { byId: effective, byType: effective.byType });
+        }
+        // Will THIS entity's own line ever land in the file? The same byte-range
+        // test `willBeEmitted` uses (defined further below) and the source-
+        // iteration pass's own skip at `entityRef.byteLength === 0` — a source
+        // entity with no bytes (a point-cloud / GLB "entity" from
+        // `createSyntheticDataStore`, not an overlay-created one) never gets a
+        // defining line written, source-iteration or otherwise, so a pset/attribute
+        // edit against it must not count as a modification either: the header
+        // would describe a change the file does not contain (out-of-scope finding
+        // in #2398). Also excludes a source-backed host the visible-only closure
+        // above drops — same reasoning, different reason the line never lands.
+        //
+        // And, like `willBeEmitted` below, excludes a geometry-classified SOURCE
+        // host under `includeGeometry: false`: the source-iteration pass's own
+        // `isGeometryEntity` skip (further below) drops that line too, so this
+        // predicate must agree or a geometry entity's attribute edit inflates the
+        // count over an omitted line (CodeRabbit finding on #2414). Guarded by
+        // `!deltaOnly` for the same reason `willBeEmitted` is: under `deltaOnly`
+        // the source-iteration pass — and its geometry skip — never runs at all,
+        // so a source entity's line is assumed to already exist in the file being
+        // patched, geometry or not.
+        const isGeometryExcluded = (entityId, recordType) => options.includeGeometry === false
+            && this.isGeometryEntity(effective.effectiveType(entityId, recordType));
+        const hasEmittableHostBytes = (entityId) => {
+            if (allowedEntityIds !== null && !allowedEntityIds.has(entityId))
+                return false;
+            const ref = effective.get(entityId);
+            if (!ref || ref.byteLength <= 0 || ref.byteOffset < 0)
+                return false;
+            if (options.deltaOnly !== true && isGeometryExcluded(entityId, ref.type))
+                return false;
+            return true;
+        };
         // Collect entities that need to be modified or created
         const modifiedEntities = new Set();
         const modifiedPsets = new Map(); // entityId -> psetNames being modified
@@ -216,7 +295,7 @@ export class StepExporter {
                 // `newEntityCount` — as are the pset entities this loop goes on to
                 // generate. Only the COUNT is guarded; the entity still records its
                 // pset edits and still emits them.
-                if (!isOverlayCreated(entityId))
+                if (!isOverlayCreated(entityId) && hasEmittableHostBytes(entityId))
                     modifiedEntityCount++;
                 // Get the FULL mutated property sets for this entity (merged base + mutations)
                 const allPsets = this.mutationView.getForEntity(entityId);
@@ -282,7 +361,7 @@ export class StepExporter {
                 modifiedEntities.add(entityId);
                 // See the property loop above — an overlay-created entity is counted as
                 // new, not modified.
-                if (!isOverlayCreated(entityId) && !modifiedPsets.has(entityId))
+                if (!isOverlayCreated(entityId) && !modifiedPsets.has(entityId) && hasEmittableHostBytes(entityId))
                     modifiedEntityCount++;
                 const allQsets = this.mutationView.getQuantitiesForEntity(entityId);
                 const relevantQsets = allQsets.filter((qset) => qsetNames.has(qset.name));
@@ -313,6 +392,11 @@ export class StepExporter {
                 // one created-then-renamed wall.
                 if (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))
+                    continue;
                 if (!entityPropMutations.has(entityId) && !entityQuantMutations.has(entityId)) {
                     modifiedEntityCount++;
                 }
@@ -320,10 +404,19 @@ export class StepExporter {
         }
         // Process georeferencing mutations (only when applyMutations is enabled)
         const newGeorefLines = [];
+        const warnings = [];
         if (options.applyMutations !== false && options.georefMutations) {
             const gm = options.georefMutations;
-            const existingCrsIds = this.dataStore.entityIndex.byType.get('IFCPROJECTEDCRS');
-            const existingMcIds = this.dataStore.entityIndex.byType.get('IFCMAPCONVERSION');
+            // `effective.byType`, not the raw index: a source IfcProjectedCRS the
+            // session tombstoned is still in `dataStore.entityIndex`, so the modify
+            // branch below would queue attribute edits against an id the
+            // source-iteration pass then skips — the replacement georeferencing
+            // vanishes from the file with no error. `effective.byType` drops
+            // tombstones and adds overlay-created records, which the new-entities
+            // pass applies `modifiedAttributes` to, so both branches agree on which
+            // georeferencing entities exist (#2048).
+            const existingCrsIds = effective.byType.get('IFCPROJECTEDCRS');
+            const existingMcIds = effective.byType.get('IFCMAPCONVERSION');
             // Modify existing IfcProjectedCRS
             if (gm.projectedCRS && existingCrsIds?.length) {
                 const entityId = existingCrsIds[0];
@@ -358,13 +451,14 @@ export class StepExporter {
                     changed = true;
                 }
                 if (crs.mapUnit !== undefined) {
-                    const mapUnitRef = this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines);
+                    const mapUnitRef = this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines, effective);
                     attrMap.set('MapUnit', `#${mapUnitRef}`);
                     changed = true;
                 }
                 if (changed && !modifiedEntities.has(entityId)) {
                     modifiedEntities.add(entityId);
-                    modifiedEntityCount++;
+                    if (hasEmittableHostBytes(entityId))
+                        modifiedEntityCount++;
                 }
             }
             // Modify existing IfcMapConversion
@@ -402,7 +496,8 @@ export class StepExporter {
                 }
                 if (changed && !modifiedEntities.has(entityId)) {
                     modifiedEntities.add(entityId);
-                    modifiedEntityCount++;
+                    if (hasEmittableHostBytes(entityId))
+                        modifiedEntityCount++;
                 }
             }
             // CREATE new georef entities when file has none
@@ -417,12 +512,12 @@ export class StepExporter {
                 const proj = crs.mapProjection ? `'${escapeStepString(String(crs.mapProjection))}'` : '$';
                 const zone = crs.mapZone ? `'${escapeStepString(String(crs.mapZone))}'` : '$';
                 const mapUnitRef = crs.mapUnit
-                    ? `#${this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines)}`
+                    ? `#${this.resolveMapUnitReference(String(crs.mapUnit), newGeorefLines, effective)}`
                     : '$';
                 newGeorefLines.push(`#${crsId}=IFCPROJECTEDCRS(${name},${desc},${datum},${vDatum},${proj},${zone},${mapUnitRef});`);
                 newEntityCount++;
                 // Find IfcGeometricRepresentationContext as SourceCRS for MapConversion
-                const contextId = this.findPreferredGeometricRepresentationContextId();
+                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
                 if (contextId) {
                     const mc = gm.mapConversion || {};
                     const mcId = this.nextExpressId++;
@@ -437,12 +532,12 @@ export class StepExporter {
                     newEntityCount++;
                 }
                 else {
-                    console.warn('[StepExporter] Cannot create IfcMapConversion: no IfcGeometricRepresentationContext found in source file');
+                    this.reportMapConversionRefused(warnings);
                 }
             }
             else if (gm.mapConversion && !existingMcIds?.length && existingCrsIds?.length) {
                 // CRS exists but no MapConversion — create just the conversion
-                const contextId = this.findPreferredGeometricRepresentationContextId();
+                const contextId = this.findPreferredGeometricRepresentationContextId(effective);
                 if (contextId) {
                     const mc = gm.mapConversion;
                     const mcId = this.nextExpressId++;
@@ -456,9 +551,17 @@ export class StepExporter {
                     newEntityCount++;
                 }
                 else {
-                    console.warn('[StepExporter] Cannot create IfcMapConversion: no IfcGeometricRepresentationContext found in source file');
+                    this.reportMapConversionRefused(warnings);
                 }
             }
+            else if (gm.mapConversion && !existingMcIds?.length && !existingCrsIds?.length) {
+                // A map conversion was requested, but there is no IfcProjectedCRS to
+                // reference as TargetCRS: none was requested (the first branch above
+                // didn't fire) and none exists in the file. Both CREATE branches are
+                // skipped, so nothing is attempted — report the refusal so the
+                // caller isn't left with an empty stats.warnings and no hint (#2105).
+                this.reportMapConversionRefusedNoCrs(warnings);
+            }
         }
         // If delta only, only export modified entities. Overlay-created entities
         // also count — without this, `createEntity()`-only edits would silently
@@ -480,25 +583,10 @@ export class StepExporter {
                     newEntityCount: 0,
                     modifiedEntityCount: 0,
                     fileSize: emptyContent.byteLength,
+                    warnings,
                 },
             };
         }
-        // Build visible-only closure if requested. Classification, the closure walk
-        // and the style pass all run over the EFFECTIVE index: an overlay-created
-        // product becomes a root by the same type rules as a parsed one, the walk
-        // follows its authored references into the geometry it alone owns, and a
-        // tombstoned entity is simply not there. Run over the source buffer, a
-        // created wall could never be a root and nothing referenced it, so
-        // `visibleOnly` wrote a file without it and said nothing (#2012).
-        let allowedEntityIds = null;
-        if (options.visibleOnly && this.dataStore.source) {
-            const { roots, hiddenProductIds } = getVisibleEntityIds(this.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, effective);
-            allowedEntityIds = collectReferencedEntityIds(roots, this.dataStore.source, effective, hiddenProductIds);
-            // Second pass: collect IFCSTYLEDITEM entities that reference included
-            // geometry. Styled items reference geometry items but nothing references
-            // them back, so the forward closure misses them.
-            collectStyleEntities(allowedEntityIds, this.dataStore.source, { byId: effective, byType: effective.byType });
-        }
         /**
          * Will this id have a defining STEP line in the output at all?
          *
@@ -540,7 +628,21 @@ export class StepExporter {
                 return false;
             // An overlay-created record carries the placeholder byte range and is
             // written by the new-entities pass; a source record needs real bytes.
-            return effective.isOverlayCreated(entityId) || (ref.byteLength > 0 && ref.byteOffset >= 0);
+            if (effective.isOverlayCreated(entityId)) {
+                // The overlay new-entities pass applies its OWN `isGeometryEntity`
+                // filter unconditionally — deltaOnly or not (see the comment at that
+                // loop, further below) — so this branch mirrors it without the
+                // deltaOnly carve-out the source branch gets.
+                return !isGeometryExcluded(entityId, ref.type);
+            }
+            if (!(ref.byteLength > 0 && ref.byteOffset >= 0))
+                return false;
+            // Mirrors `hasEmittableHostBytes`: under `deltaOnly` the source-
+            // iteration pass — and its geometry skip — never runs, so a source
+            // entity's line is assumed to already exist in the file being patched.
+            if (options.deltaOnly === true)
+                return true;
+            return !isGeometryExcluded(entityId, ref.type);
         };
         // A modified pset is replaced wholesale, which skips ALL of its member atoms.
         // But IFC exporters deduplicate identical Pset_*Common atoms (e.g. one
@@ -577,11 +679,11 @@ export class StepExporter {
                 if (options.includeGeometry === false && this.isGeometryEntity(entityType)) {
                     continue;
                 }
-                // Get original entity text — safeUtf8Decode handles SAB-backed
+                // Get original entity text — decodeRange handles SAB-backed
                 // sources (Firefox/Chrome reject `TextDecoder.decode()` on a
                 // SharedArrayBuffer-backed view; the parser deliberately keeps
                 // `source` zero-copy SAB-backed for worker sharing).
-                const entityText = safeUtf8Decode(source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+                const entityText = decodeRange(source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
                 let nextEntityText = entityText;
                 // Entity retype (reassign class) runs FIRST so attribute mutations
                 // below resolve against the TARGET class's attribute names. The
@@ -638,7 +740,7 @@ export class StepExporter {
             // see `willBeEmitted` (#1978, #2030, #2012).
             if (!willBeEmitted(entityId))
                 continue;
-            const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
+            const newEntities = this.generatePropertySetEntities(entityId, psets, willBeEmitted, effective, typeOwnedPsetNamesByEntity.get(entityId), options.guidRandom);
             entities.push(...newEntities.lines);
             newEntityCount += newEntities.count;
             generatedTypeOwnedPsetIds.set(entityId, newEntities.generatedTypeOwnedPsetIds);
@@ -772,6 +874,7 @@ export class StepExporter {
                 newEntityCount,
                 modifiedEntityCount,
                 fileSize: content.byteLength,
+                warnings,
             },
         };
     }
@@ -887,7 +990,7 @@ export class StepExporter {
         }
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (entityRef && this.dataStore.source && entityRef.byteLength > 0) {
-            const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+            const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
             // #ID=IFCWALL('GlobalId',#owner,...): GlobalId is a quoted STEP string
             // (doubled '' escapes); OwnerHistory is the ref/`$` right after it.
             const match = entityText.match(/=\s*IFC\w+\s*\(\s*'(?:[^']|'')*'\s*,\s*#(\d+)/i);
@@ -900,7 +1003,7 @@ export class StepExporter {
     /**
      * Generate STEP entities for property sets
      */
-    generatePropertySetEntities(entityId, psets, willBeEmitted, typeOwnedPsetNames, random) {
+    generatePropertySetEntities(entityId, psets, willBeEmitted, effective, typeOwnedPsetNames, random) {
         const lines = [];
         let count = 0;
         const generatedTypeOwnedPsetIds = new Map();
@@ -911,7 +1014,7 @@ export class StepExporter {
                 const propId = this.nextExpressId++;
                 count++;
                 const valueStr = serializePropertyValue(prop.value, prop.type);
-                const unitId = prop.unit ? this.findUnitId(prop.unit) : null;
+                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) : '$'});`;
@@ -1141,9 +1244,9 @@ export class StepExporter {
         const forceReal = realSlots.has(index) || tokenIsRealLiteral(currentToken);
         return serializeStepValue(value, forceReal);
     }
-    resolveMapUnitReference(unitName, newGeorefLines) {
+    resolveMapUnitReference(unitName, newGeorefLines, effective) {
         const normalized = this.normalizeMapUnitName(unitName);
-        const existing = this.findLengthUnitReference(normalized);
+        const existing = this.findLengthUnitReference(normalized, effective);
         if (existing !== null) {
             return existing;
         }
@@ -1179,14 +1282,22 @@ export class StepExporter {
             return 'FOOT';
         return normalized;
     }
-    findLengthUnitReference(preferredUnitName) {
+    /**
+     * `effective` filters the candidates the same way the georef reads above do:
+     * returning a tombstoned unit id hands the caller a `#id` for a line the
+     * export never writes. Returning null instead makes `resolveMapUnitReference`
+     * synthesise a fresh unit, which is the outcome a deleted unit deserves.
+     */
+    findLengthUnitReference(preferredUnitName, effective) {
         if (!this.entityExtractor)
             return null;
-        const projectIds = this.dataStore.entityIndex.byType.get('IFCPROJECT') ?? [];
-        const projectRef = projectIds[0] ? this.dataStore.entityIndex.byId.get(projectIds[0]) : undefined;
+        // Only source records carry the bytes `extractEntity` reads, so an
+        // overlay-created project is skipped rather than shadowing the file's own.
+        const projectId = (effective.byType.get('IFCPROJECT') ?? []).find((id) => this.dataStore.entityIndex.byId.has(id));
+        const projectRef = projectId !== undefined ? this.dataStore.entityIndex.byId.get(projectId) : undefined;
         const project = projectRef ? this.entityExtractor.extractEntity(projectRef) : null;
         const unitAssignmentId = project?.attributes?.[8];
-        if (typeof unitAssignmentId !== 'number')
+        if (typeof unitAssignmentId !== 'number' || effective.isDeleted(unitAssignmentId))
             return null;
         const unitAssignmentRef = this.dataStore.entityIndex.byId.get(unitAssignmentId);
         const unitAssignment = unitAssignmentRef ? this.entityExtractor.extractEntity(unitAssignmentRef) : null;
@@ -1194,7 +1305,7 @@ export class StepExporter {
         if (!Array.isArray(units))
             return null;
         for (const unitId of units) {
-            if (typeof unitId !== 'number')
+            if (typeof unitId !== 'number' || effective.isDeleted(unitId))
                 continue;
             const unitRef = this.dataStore.entityIndex.byId.get(unitId);
             const unit = unitRef ? this.entityExtractor.extractEntity(unitRef) : null;
@@ -1222,10 +1333,36 @@ export class StepExporter {
         }
         return null;
     }
-    findPreferredGeometricRepresentationContextId() {
+    /**
+     * Record that a requested IfcMapConversion could not be written. Emitting it
+     * anyway would leave `SourceCRS` pointing at nothing, so the refusal is the
+     * correct output — but the file alone cannot express it, which is why it goes
+     * back to the caller in `stats.warnings` as well as to the console (#2067).
+     */
+    reportMapConversionRefused(warnings) {
+        warnings.push(MAP_CONVERSION_WITHOUT_CONTEXT_WARNING);
+        console.warn(`[StepExporter] ${MAP_CONVERSION_WITHOUT_CONTEXT_WARNING}`);
+    }
+    /**
+     * Record that a requested IfcMapConversion could not be written because
+     * there is no IfcProjectedCRS to attach it to — a different refusal from
+     * {@link reportMapConversionRefused}: "no CRS to attach it to" rather than
+     * "no context to reference" (#2105).
+     */
+    reportMapConversionRefusedNoCrs(warnings) {
+        warnings.push(MAP_CONVERSION_WITHOUT_CRS_WARNING);
+        console.warn(`[StepExporter] ${MAP_CONVERSION_WITHOUT_CRS_WARNING}`);
+    }
+    /**
+     * `effective` again: the id returned here becomes the new IfcMapConversion's
+     * SourceCRS, so a tombstoned context would leave the created line pointing at
+     * a record the export skips — a dangling reference and an invalid file.
+     */
+    findPreferredGeometricRepresentationContextId(effective) {
         if (!this.entityExtractor)
             return null;
-        const contextIds = this.dataStore.entityIndex.byType.get('IFCGEOMETRICREPRESENTATIONCONTEXT') ?? [];
+        const contextIds = (effective.byType.get('IFCGEOMETRICREPRESENTATIONCONTEXT') ?? [])
+            .filter((id) => this.dataStore.entityIndex.byId.has(id));
         let first3dContext = null;
         for (const contextId of contextIds) {
             const contextRef = this.dataStore.entityIndex.byId.get(contextId);
@@ -1263,8 +1400,8 @@ export class StepExporter {
     /**
      * Find a unit entity ID by name (simplified - returns null for now)
      */
-    findUnitId(unitName) {
-        return this.findLengthUnitReference(this.normalizeMapUnitName(unitName));
+    findUnitId(unitName, effective) {
+        return this.findLengthUnitReference(this.normalizeMapUnitName(unitName), effective);
     }
     /**
      * Check if an entity type is a geometry-related type
@@ -1343,7 +1480,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(relId);
         if (!entityRef || !this.dataStore.source)
             return [];
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse IfcRelDefinesByProperties: #ID=IFCRELDEFINESBYPROPERTIES('guid',$,$,$,(#objects),#pset);
         // The 5th argument (index 4) is the list of related objects
         const match = entityText.match(/\(([^)]+)\)\s*,\s*#(\d+)\s*\)\s*;/);
@@ -1364,7 +1501,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(relId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Last #ID before the closing );
         const match = entityText.match(/,\s*#(\d+)\s*\)\s*;$/);
         if (!match)
@@ -1378,7 +1515,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(psetId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCPROPERTYSET('guid',$,'Name',$,...) - Name is 3rd argument
         const match = entityText.match(/IFCPROPERTYSET\s*\([^,]*,[^,]*,'([^']*)'/i);
         if (!match)
@@ -1392,7 +1529,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCELEMENTQUANTITY('guid',$,'Name',...) - Name is 3rd argument
         const match = entityText.match(/IFCELEMENTQUANTITY\s*\([^,]*,[^,]*,'([^']*)'/i);
         if (!match)
@@ -1440,7 +1577,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(psetId);
         if (!entityRef || !this.dataStore.source)
             return [];
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         // Parse: IFCPROPERTYSET(...,(#prop1,#prop2,...)); - Last argument is properties list
         const match = entityText.match(/\(\s*(#[^)]+)\s*\)\s*\)\s*;$/);
         if (!match)
@@ -1487,7 +1624,7 @@ export class StepExporter {
         const entityRef = this.dataStore.entityIndex.byId.get(entityId);
         if (!entityRef || !this.dataStore.source)
             return null;
-        const entityText = safeUtf8Decode(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
+        const entityText = decodeRange(this.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
         const match = entityText.match(/^(#\d+\s*=\s*\w+\()([\s\S]*)(\)\s*;)\s*$/);
         if (!match)
             return null;