@ifc-lite/export 1.11.5 → 1.13.0

package/README.md

@@ -1,6 +1,6 @@
 # @ifc-lite/export
 
-Export formats for IFClite. Supports exporting IFC data to glTF/GLB, Apache Parquet, Apache Arrow, and IFC.
+Export formats for IFC-Lite. Supports exporting IFC data to glTF/GLB, Apache Parquet, Apache Arrow, IFC STEP, and IFC5 IFCX.
 
 ## Installation
 
@@ -11,7 +11,7 @@ npm install @ifc-lite/export
 ## Quick Start
 
 ```typescript
-import { GLTFExporter, ParquetExporter, exportToStep } from '@ifc-lite/export';
+import { GLTFExporter, ParquetExporter, exportToStep, Ifc5Exporter } from '@ifc-lite/export';
 
 // Export geometry to GLB
 const gltfExporter = new GLTFExporter();
@@ -22,7 +22,12 @@ const parquetExporter = new ParquetExporter();
 const parquet = await parquetExporter.exportEntities(parseResult);
 
 // Export to IFC STEP (with mutations applied)
-const step = await exportToStep(dataStore, mutations);
+const step = exportToStep(dataStore, { schema: 'IFC4' });
+
+// Export to IFC5 IFCX (JSON + USD geometry)
+const ifc5 = new Ifc5Exporter(dataStore, geometryResult);
+const result = ifc5.export({ includeGeometry: true });
+// result.content is IFCX JSON, save as .ifcx
 ```
 
 ## Features
@@ -31,6 +36,34 @@ const step = await exportToStep(dataStore, mutations);
 - Apache Parquet serialization (columnar, compressed)
 - Apache Arrow in-memory format
 - IFC STEP export with mutations applied
+- **IFC5 IFCX export** with USD geometry and full schema conversion
+- Cross-schema conversion (IFC2X3 ↔ IFC4 ↔ IFC4X3 ↔ IFC5)
+
+## IFC5 Export
+
+The `Ifc5Exporter` converts IFC data from any schema version to the IFC5 IFCX JSON format:
+
+```typescript
+import { Ifc5Exporter } from '@ifc-lite/export';
+
+const exporter = new Ifc5Exporter(dataStore, geometryResult, mutationView);
+const result = exporter.export({
+  includeGeometry: true,    // Convert meshes to USD format
+  includeProperties: true,  // Map properties to bsi::ifc::prop:: namespace
+  applyMutations: true,     // Apply property edits
+  visibleOnly: false,       // Filter by visibility
+});
+
+// result.content → IFCX JSON string
+// result.stats → { nodeCount, propertyCount, meshCount, fileSize }
+```
+
+Output includes:
+- Entity types converted to IFC5 naming
+- Properties in IFCX attribute namespaces (`bsi::ifc::prop::PsetName::PropName`)
+- Tessellated geometry as USD meshes (`usd::usdgeom::mesh`)
+- Spatial hierarchy as IFCX path-based nodes
+- Presentation data (diffuse color, opacity)
 
 ## API
 

package/dist/ifc5-exporter.d.ts

@@ -0,0 +1,101 @@
+/**
+ * IFC5 (IFCX) Exporter
+ *
+ * Converts an IfcDataStore (from IFC2X3/IFC4/IFC4X3 STEP files) to the
+ * IFC5 IFCX JSON format with USD geometry.
+ *
+ * This performs full schema conversion:
+ * - Entity type mapping to IFC5 (aligned with IFC4X3 naming)
+ * - Properties converted to IFCX attribute namespaces
+ * - Tessellated geometry converted to USD mesh format
+ * - Spatial hierarchy mapped to IFCX path-based structure
+ */
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { GeometryResult } from '@ifc-lite/geometry';
+/** Options for IFC5 export */
+export interface Ifc5ExportOptions {
+    /** Author name */
+    author?: string;
+    /** Data version identifier */
+    dataVersion?: string;
+    /** Include geometry as USD meshes (default: true) */
+    includeGeometry?: boolean;
+    /** Include properties (default: true) */
+    includeProperties?: boolean;
+    /** Apply mutations (default: true if mutation view provided) */
+    applyMutations?: boolean;
+    /** Pretty print JSON (default: true) */
+    prettyPrint?: boolean;
+    /** Only export visible entities */
+    visibleOnly?: boolean;
+    /** Hidden entity IDs (local expressIds) */
+    hiddenEntityIds?: Set<number>;
+    /** Isolated entity IDs (local expressIds, null = no isolation) */
+    isolatedEntityIds?: Set<number> | null;
+}
+/** Result of IFC5 export */
+export interface Ifc5ExportResult {
+    /** IFCX JSON content */
+    content: string;
+    /** Statistics */
+    stats: {
+        nodeCount: number;
+        propertyCount: number;
+        meshCount: number;
+        fileSize: number;
+    };
+}
+/**
+ * Exports IFC data (from any schema) to IFC5 IFCX JSON format.
+ */
+export declare class Ifc5Exporter {
+    private dataStore;
+    private mutationView;
+    private geometryResult;
+    private idOffset;
+    /** Unique path segment name per entity (with _<id> suffix when siblings collide) */
+    private segmentNames;
+    /** Real names from SpatialNode tree (reliable for spatial containers) */
+    private spatialNodeNames;
+    /** Spatial container children (Project→Sites, Site→Buildings, etc.) */
+    private spatialChildIds;
+    constructor(dataStore: IfcDataStore, geometryResult?: GeometryResult | null, mutationView?: MutablePropertyView, idOffset?: number);
+    /**
+     * Export to IFCX JSON format
+     */
+    export(options?: Ifc5ExportOptions): Ifc5ExportResult;
+    /**
+     * Build path strings for all entities using the spatial hierarchy.
+     * Paths follow IFCX convention: "0/SiteName/BuildingName/StoreyName/ElementName"
+     */
+    private buildEntityPaths;
+    /**
+     * Get properties for an entity, converted to IFCX attribute format.
+     */
+    private getPropertiesForEntity;
+    /**
+     * Convert a property value to IFCX-compatible format.
+     * IFCX uses native JSON types rather than IFC wrapped types.
+     */
+    private convertPropertyValue;
+    /**
+     * Get children for a spatial entity.
+     * IFCX children format: { childName: childPath }
+     */
+    private getChildrenForEntity;
+    /**
+     * Build mesh lookup from GeometryResult, keyed by original expressId.
+     */
+    private buildMeshLookup;
+    /**
+     * Convert tessellated MeshData (Y-up) to USD mesh format (Z-up).
+     * Merges multiple mesh fragments for the same entity.
+     */
+    private convertToUsdMesh;
+    /**
+     * Build visible entity set if visibility filtering is requested.
+     */
+    private buildVisibleSet;
+}
+//# sourceMappingURL=ifc5-exporter.d.ts.map

package/dist/ifc5-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc5-exporter.d.ts","sourceRoot":"","sources":["../src/ifc5-exporter.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAanE,8BAA8B;AAC9B,MAAM,WAAW,iBAAiB;IAChC,kBAAkB;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,yCAAyC;IACzC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wCAAwC;IACxC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mCAAmC;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,2CAA2C;IAC3C,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,kEAAkE;IAClE,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CACxC;AAED,4BAA4B;AAC5B,MAAM,WAAW,gBAAgB;IAC/B,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB;IACjB,KAAK,EAAE;QACL,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AA4BD;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAS;IACzB,oFAAoF;IACpF,OAAO,CAAC,YAAY,CAA6B;IACjD,yEAAyE;IACzE,OAAO,CAAC,gBAAgB,CAA6B;IACrD,uEAAuE;IACvE,OAAO,CAAC,eAAe,CAA+B;gBAGpD,SAAS,EAAE,YAAY,EACvB,cAAc,CAAC,EAAE,cAAc,GAAG,IAAI,EACtC,YAAY,CAAC,EAAE,mBAAmB,EAClC,QAAQ,CAAC,EAAE,MAAM;IAQnB;;OAEG;IACH,MAAM,CAAC,OAAO,GAAE,iBAAsB,GAAG,gBAAgB;IA4IzD;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoJxB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA4B9B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA6C5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAkBvB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAqExB;;OAEG;IACH,OAAO,CAAC,eAAe;CAsBxB"}

package/dist/ifc5-exporter.js

@@ -0,0 +1,487 @@
+/* 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 { IfcTypeEnumToString, IfcTypeEnumFromString, PropertyValueType, } from '@ifc-lite/data';
+import { convertEntityType } from './schema-converter.js';
+// ============================================================================
+// Exporter
+// ============================================================================
+/**
+ * Exports IFC data (from any schema) to IFC5 IFCX JSON format.
+ */
+export class Ifc5Exporter {
+    dataStore;
+    mutationView;
+    geometryResult;
+    idOffset;
+    /** Unique path segment name per entity (with _<id> suffix when siblings collide) */
+    segmentNames = new Map();
+    /** Real names from SpatialNode tree (reliable for spatial containers) */
+    spatialNodeNames = new Map();
+    /** Spatial container children (Project→Sites, Site→Buildings, etc.) */
+    spatialChildIds = new Map();
+    constructor(dataStore, geometryResult, mutationView, idOffset) {
+        this.dataStore = dataStore;
+        this.geometryResult = geometryResult ?? null;
+        this.mutationView = mutationView ?? null;
+        this.idOffset = idOffset ?? 0;
+    }
+    /**
+     * Export to IFCX JSON format
+     */
+    export(options = {}) {
+        const sourceSchema = this.dataStore.schemaVersion || 'IFC4';
+        // Build entity path map using spatial hierarchy
+        const entityPaths = this.buildEntityPaths();
+        // Build mesh lookup by expressId
+        const meshByEntity = this.buildMeshLookup(options);
+        // Build visible set
+        const visibleIds = this.buildVisibleSet(options);
+        // Collect nodes
+        const nodes = [];
+        let propertyCount = 0;
+        let meshCount = 0;
+        const { entities, strings } = this.dataStore;
+        for (let i = 0; i < entities.count; i++) {
+            const expressId = entities.expressId[i];
+            // Visibility filter
+            if (visibleIds && !visibleIds.has(expressId))
+                continue;
+            const typeEnum = entities.typeEnum[i];
+            const typeName = IfcTypeEnumToString(typeEnum) || 'IfcElement';
+            // Convert entity type to IFC5 (aligned with IFC4X3)
+            const ifc5Type = convertEntityType(typeName.toUpperCase(), sourceSchema, 'IFC5');
+            // Convert back to PascalCase for IFCX
+            const ifc5Class = stepTypeToClassName(ifc5Type);
+            // Get path for this entity
+            const path = entityPaths.get(expressId) || `ifc:${ifc5Class}.${expressId}`;
+            // Build attributes
+            const attributes = {};
+            // IFC class
+            attributes['bsi::ifc::class'] = { code: ifc5Class };
+            // GlobalId
+            const globalId = strings.get(entities.globalId[i]);
+            if (globalId) {
+                attributes['bsi::ifc::globalId'] = globalId;
+            }
+            // Name - only write when real data exists (don't fabricate names)
+            const name = strings.get(entities.name[i])
+                || this.spatialNodeNames.get(expressId);
+            if (name) {
+                attributes['bsi::ifc::name'] = name;
+            }
+            // Description
+            const description = strings.get(entities.description[i]);
+            if (description) {
+                attributes['bsi::ifc::description'] = description;
+            }
+            // Properties
+            if (options.includeProperties !== false) {
+                const props = this.getPropertiesForEntity(expressId, options);
+                for (const [key, value] of Object.entries(props)) {
+                    attributes[key] = value;
+                    propertyCount++;
+                }
+            }
+            // Build node
+            const node = { path };
+            // Children from spatial hierarchy
+            const children = this.getChildrenForEntity(expressId, entityPaths);
+            if (Object.keys(children).length > 0) {
+                node.children = children;
+            }
+            // Geometry as USD mesh
+            if (options.includeGeometry !== false) {
+                const meshes = meshByEntity.get(expressId);
+                if (meshes && meshes.length > 0) {
+                    const usdMesh = this.convertToUsdMesh(meshes);
+                    attributes['usd::usdgeom::mesh'] = usdMesh;
+                    // Color/presentation
+                    const [r, g, b, a] = meshes[0].color;
+                    attributes['bsi::ifc::presentation::diffuseColor'] = [r, g, b];
+                    if (a < 1.0) {
+                        attributes['bsi::ifc::presentation::opacity'] = a;
+                    }
+                    meshCount++;
+                }
+            }
+            if (Object.keys(attributes).length > 0) {
+                node.attributes = attributes;
+            }
+            nodes.push(node);
+        }
+        // Assemble IFCX file
+        const file = {
+            header: {
+                id: `ifcx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+                ifcxVersion: 'IFCX-1.0',
+                dataVersion: options.dataVersion || '1.0.0',
+                author: options.author || 'ifc-lite',
+                timestamp: new Date().toISOString(),
+            },
+            imports: [],
+            schemas: {},
+            data: nodes,
+        };
+        const content = options.prettyPrint !== false
+            ? JSON.stringify(file, null, 2)
+            : JSON.stringify(file);
+        return {
+            content,
+            stats: {
+                nodeCount: nodes.length,
+                propertyCount,
+                meshCount,
+                fileSize: new TextEncoder().encode(content).length,
+            },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Path building
+    // --------------------------------------------------------------------------
+    /**
+     * Build path strings for all entities using the spatial hierarchy.
+     * Paths follow IFCX convention: "0/SiteName/BuildingName/StoreyName/ElementName"
+     */
+    buildEntityPaths() {
+        const paths = new Map();
+        const { spatialHierarchy, entities, strings } = this.dataStore;
+        if (!spatialHierarchy)
+            return paths;
+        // Build parent→children map from hierarchy
+        const parentOf = new Map();
+        const processChildren = (parentId, childIds) => {
+            if (!childIds)
+                return;
+            for (const childId of childIds) {
+                parentOf.set(childId, parentId);
+            }
+        };
+        // Add spatial container hierarchy from the project tree first
+        // (Project→Site, Site→Building, Building→Storey, Storey→Space)
+        // Also collect spatial node names (SpatialNode.name is often more reliable
+        // than the entity table for spatial containers)
+        this.spatialChildIds.clear();
+        this.spatialNodeNames.clear();
+        if (spatialHierarchy.project) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const walkTree = (node) => {
+                if (node.name) {
+                    this.spatialNodeNames.set(node.expressId, node.name);
+                }
+                const childIds = [];
+                for (const child of node.children) {
+                    parentOf.set(child.expressId, node.expressId);
+                    childIds.push(child.expressId);
+                    walkTree(child);
+                }
+                this.spatialChildIds.set(node.expressId, childIds);
+            };
+            walkTree(spatialHierarchy.project);
+        }
+        // Add element containment from flat maps (element→storey/building/site/space)
+        if (spatialHierarchy.bySite) {
+            for (const [siteId, children] of spatialHierarchy.bySite) {
+                processChildren(siteId, children);
+            }
+        }
+        if (spatialHierarchy.byBuilding) {
+            for (const [buildingId, children] of spatialHierarchy.byBuilding) {
+                processChildren(buildingId, children);
+            }
+        }
+        if (spatialHierarchy.byStorey) {
+            for (const [storeyId, children] of spatialHierarchy.byStorey) {
+                processChildren(storeyId, children);
+            }
+        }
+        if (spatialHierarchy.bySpace) {
+            for (const [spaceId, children] of spatialHierarchy.bySpace) {
+                processChildren(spaceId, children);
+            }
+        }
+        // Build index lookup for entity names.
+        // Priority: entity table name → spatial node name → IFC type name fallback
+        const entityNameById = new Map();
+        for (let i = 0; i < entities.count; i++) {
+            const id = entities.expressId[i];
+            let name = strings.get(entities.name[i]) || '';
+            // For entities with empty names, try spatial node name (from hierarchy tree)
+            if (!name) {
+                name = this.spatialNodeNames.get(id) || '';
+            }
+            // Last resort: use the IFC type name so paths are readable (e.g. "IfcProject")
+            if (!name) {
+                const typeName = IfcTypeEnumToString(entities.typeEnum[i]);
+                if (typeName !== 'Unknown') {
+                    name = typeName;
+                }
+            }
+            entityNameById.set(id, name);
+        }
+        // Build children-per-parent map so we can detect name collisions among siblings
+        const childrenOf = new Map();
+        for (const [childId, parentId] of parentOf) {
+            if (!childrenOf.has(parentId))
+                childrenOf.set(parentId, []);
+            childrenOf.get(parentId).push(childId);
+        }
+        // Also collect root entities (those not in parentOf)
+        for (let i = 0; i < entities.count; i++) {
+            const id = entities.expressId[i];
+            if (!parentOf.has(id)) {
+                if (!childrenOf.has(undefined))
+                    childrenOf.set(undefined, []);
+                childrenOf.get(undefined).push(id);
+            }
+        }
+        // Pre-compute unique segment names: append _<expressId> when siblings share a name
+        this.segmentNames.clear();
+        for (const [, siblings] of childrenOf) {
+            // Count how many siblings share each sanitised name
+            const nameCount = new Map();
+            for (const id of siblings) {
+                const raw = entityNameById.get(id) || `e${id}`;
+                const safe = raw.replace(/[/\\]/g, '_').replace(/\s+/g, '_');
+                nameCount.set(safe, (nameCount.get(safe) || 0) + 1);
+            }
+            for (const id of siblings) {
+                const raw = entityNameById.get(id) || `e${id}`;
+                const safe = raw.replace(/[/\\]/g, '_').replace(/\s+/g, '_');
+                this.segmentNames.set(id, nameCount.get(safe) > 1 ? `${safe}_${id}` : safe);
+            }
+        }
+        // Generate path for each entity by walking up to root
+        const getPath = (expressId) => {
+            if (paths.has(expressId))
+                return paths.get(expressId);
+            const segments = [];
+            let current = expressId;
+            const visited = new Set();
+            while (current !== undefined) {
+                if (visited.has(current))
+                    break; // cycle protection
+                visited.add(current);
+                segments.unshift(this.segmentNames.get(current) || `e${current}`);
+                const parent = parentOf.get(current);
+                if (parent === undefined)
+                    break;
+                current = parent;
+            }
+            // Prefix with "0" (root index, per IFCX convention)
+            const path = '0/' + segments.join('/');
+            paths.set(expressId, path);
+            return path;
+        };
+        for (let i = 0; i < entities.count; i++) {
+            getPath(entities.expressId[i]);
+        }
+        return paths;
+    }
+    // --------------------------------------------------------------------------
+    // Properties
+    // --------------------------------------------------------------------------
+    /**
+     * Get properties for an entity, converted to IFCX attribute format.
+     */
+    getPropertiesForEntity(entityId, options) {
+        const result = {};
+        // Prefer mutation view if available
+        if (this.mutationView && options.applyMutations !== false) {
+            const psets = this.mutationView.getForEntity(entityId);
+            for (const pset of psets) {
+                for (const prop of pset.properties) {
+                    const key = `bsi::ifc::prop::${pset.name}::${prop.name}`;
+                    result[key] = this.convertPropertyValue(prop.value, prop.type);
+                }
+            }
+        }
+        else if (this.dataStore.properties) {
+            const psets = this.dataStore.properties.getForEntity(entityId);
+            for (const pset of psets) {
+                for (const prop of pset.properties) {
+                    const key = `bsi::ifc::prop::${pset.name}::${prop.name}`;
+                    result[key] = this.convertPropertyValue(prop.value, prop.type);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Convert a property value to IFCX-compatible format.
+     * IFCX uses native JSON types rather than IFC wrapped types.
+     */
+    convertPropertyValue(value, type) {
+        if (value === null || value === undefined)
+            return null;
+        switch (type) {
+            case PropertyValueType.Real:
+                return Number(value);
+            case PropertyValueType.Integer:
+                return Math.round(Number(value));
+            case PropertyValueType.Boolean:
+            case PropertyValueType.Logical:
+                return Boolean(value);
+            default:
+                return value;
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Children
+    // --------------------------------------------------------------------------
+    /**
+     * Get children for a spatial entity.
+     * IFCX children format: { childName: childPath }
+     */
+    getChildrenForEntity(entityId, entityPaths) {
+        const children = {};
+        const addChild = (childId) => {
+            const childPath = entityPaths.get(childId);
+            if (!childPath)
+                return;
+            const childName = this.segmentNames.get(childId) || `e${childId}`;
+            children[childName] = childPath;
+        };
+        // Spatial container children (Project→Sites, Site→Buildings, etc.)
+        const spatialKids = this.spatialChildIds.get(entityId);
+        if (spatialKids) {
+            for (const childId of spatialKids) {
+                addChild(childId);
+            }
+        }
+        // Element children from containment maps
+        const { spatialHierarchy } = this.dataStore;
+        if (spatialHierarchy) {
+            const childSets = [
+                spatialHierarchy.bySite?.get(entityId),
+                spatialHierarchy.byBuilding?.get(entityId),
+                spatialHierarchy.byStorey?.get(entityId),
+                spatialHierarchy.bySpace?.get(entityId),
+            ];
+            for (const childSet of childSets) {
+                if (!childSet)
+                    continue;
+                for (const childId of childSet) {
+                    addChild(childId);
+                }
+            }
+        }
+        return children;
+    }
+    // --------------------------------------------------------------------------
+    // Geometry conversion
+    // --------------------------------------------------------------------------
+    /**
+     * Build mesh lookup from GeometryResult, keyed by original expressId.
+     */
+    buildMeshLookup(options) {
+        const lookup = new Map();
+        if (!this.geometryResult || options.includeGeometry === false)
+            return lookup;
+        for (const mesh of this.geometryResult.meshes) {
+            // Convert global expressId back to original local expressId
+            const localId = mesh.expressId - this.idOffset;
+            const id = localId > 0 ? localId : mesh.expressId;
+            if (!lookup.has(id)) {
+                lookup.set(id, []);
+            }
+            lookup.get(id).push(mesh);
+        }
+        return lookup;
+    }
+    /**
+     * Convert tessellated MeshData (Y-up) to USD mesh format (Z-up).
+     * Merges multiple mesh fragments for the same entity.
+     */
+    convertToUsdMesh(meshes) {
+        const allPoints = [];
+        const allIndices = [];
+        const allFaceCounts = [];
+        const allNormals = [];
+        let indexOffset = 0;
+        for (const mesh of meshes) {
+            // Convert positions from Y-up to Z-up
+            // Y-up: X=right, Y=up, Z=back
+            // Z-up: X=right, Y=forward, Z=up
+            // Reverse of: Yx=Zx, Yy=Zz, Yz=-Zy
+            for (let i = 0; i < mesh.positions.length; i += 3) {
+                const x = mesh.positions[i];
+                const y = mesh.positions[i + 1]; // Y-up Y = Z-up Z
+                const z = mesh.positions[i + 2]; // Y-up Z = -Z-up Y
+                allPoints.push([x, -z, y]);
+            }
+            // Convert normals from Y-up to Z-up
+            if (mesh.normals) {
+                for (let i = 0; i < mesh.normals.length; i += 3) {
+                    const nx = mesh.normals[i];
+                    const ny = mesh.normals[i + 1];
+                    const nz = mesh.normals[i + 2];
+                    allNormals.push([nx, -nz, ny]);
+                }
+            }
+            // Offset indices for merged mesh
+            for (let i = 0; i < mesh.indices.length; i += 3) {
+                allIndices.push(mesh.indices[i] + indexOffset, mesh.indices[i + 1] + indexOffset, mesh.indices[i + 2] + indexOffset);
+                allFaceCounts.push(3); // triangles
+            }
+            indexOffset += mesh.positions.length / 3;
+        }
+        const result = {
+            points: allPoints,
+            faceVertexIndices: allIndices,
+            faceVertexCounts: allFaceCounts,
+        };
+        if (allNormals.length > 0) {
+            result.normals = allNormals;
+        }
+        return result;
+    }
+    // --------------------------------------------------------------------------
+    // Visibility
+    // --------------------------------------------------------------------------
+    /**
+     * Build visible entity set if visibility filtering is requested.
+     */
+    buildVisibleSet(options) {
+        if (!options.visibleOnly)
+            return null;
+        const hidden = options.hiddenEntityIds ?? new Set();
+        const isolated = options.isolatedEntityIds ?? null;
+        const visible = new Set();
+        const { entities } = this.dataStore;
+        for (let i = 0; i < entities.count; i++) {
+            const id = entities.expressId[i];
+            if (isolated) {
+                // When isolation is active, only isolated entities are visible
+                if (isolated.has(id))
+                    visible.add(id);
+            }
+            else {
+                // Otherwise, everything except hidden is visible
+                if (!hidden.has(id))
+                    visible.add(id);
+            }
+        }
+        return visible;
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Convert STEP uppercase type name (e.g. "IFCWALL") to PascalCase class name (e.g. "IfcWall").
+ * Uses the IFC type enum lookup for canonical casing (e.g. "IfcRelAggregates", not "Ifcrelaggregates").
+ */
+function stepTypeToClassName(stepType) {
+    const enumVal = IfcTypeEnumFromString(stepType);
+    const name = IfcTypeEnumToString(enumVal);
+    if (name !== 'Unknown')
+        return name;
+    // Fallback for types not in the enum: simple prefix normalisation
+    const lower = stepType.toLowerCase();
+    if (lower.startsWith('ifc')) {
+        return 'Ifc' + lower.charAt(3).toUpperCase() + lower.slice(4);
+    }
+    return stepType;
+}
+//# sourceMappingURL=ifc5-exporter.js.map