@ifc-lite/parser 1.6.1 → 1.8.0

package/dist/columnar-parser.js

@@ -4,6 +4,7 @@
 import { SpatialHierarchyBuilder } from './spatial-hierarchy-builder.js';
 import { EntityExtractor } from './entity-extractor.js';
 import { extractLengthUnitScale } from './unit-extractor.js';
+import { getAttributeNames } from './ifc-schema.js';
 import { StringTable, EntityTableBuilder, PropertyTableBuilder, QuantityTableBuilder, RelationshipGraphBuilder, RelationshipType, QuantityType, } from '@ifc-lite/data';
 // Pre-computed type sets for O(1) lookups
 const GEOMETRY_TYPES = new Set([
@@ -21,6 +22,7 @@ const RELATIONSHIP_TYPES = new Set([
     'IFCRELCONTAINEDINSPATIALSTRUCTURE', 'IFCRELAGGREGATES',
     'IFCRELDEFINESBYPROPERTIES', 'IFCRELDEFINESBYTYPE',
     'IFCRELASSOCIATESMATERIAL', 'IFCRELASSOCIATESCLASSIFICATION',
+    'IFCRELASSOCIATESDOCUMENT',
     'IFCRELVOIDSELEMENT', 'IFCRELFILLSELEMENT',
     'IFCRELCONNECTSPATHELEMENTS', 'IFCRELCONNECTSELEMENTS',
     'IFCRELSPACEBOUNDARY',
@@ -36,6 +38,7 @@ const REL_TYPE_MAP = {
     'IFCRELDEFINESBYTYPE': RelationshipType.DefinesByType,
     'IFCRELASSOCIATESMATERIAL': RelationshipType.AssociatesMaterial,
     'IFCRELASSOCIATESCLASSIFICATION': RelationshipType.AssociatesClassification,
+    'IFCRELASSOCIATESDOCUMENT': RelationshipType.AssociatesDocument,
     'IFCRELVOIDSELEMENT': RelationshipType.VoidsElement,
     'IFCRELFILLSELEMENT': RelationshipType.FillsElement,
     'IFCRELCONNECTSPATHELEMENTS': RelationshipType.ConnectsPathElements,
@@ -60,11 +63,19 @@ const SPATIAL_TYPES = new Set([
 // Relationship types needed for hierarchy
 const HIERARCHY_REL_TYPES = new Set([
     'IFCRELAGGREGATES', 'IFCRELCONTAINEDINSPATIALSTRUCTURE',
+    'IFCRELDEFINESBYTYPE',
 ]);
 // Relationship types for on-demand property loading
 const PROPERTY_REL_TYPES = new Set([
     'IFCRELDEFINESBYPROPERTIES',
 ]);
+// Relationship types for on-demand classification/material loading
+const ASSOCIATION_REL_TYPES = new Set([
+    'IFCRELASSOCIATESCLASSIFICATION', 'IFCRELASSOCIATESMATERIAL',
+    'IFCRELASSOCIATESDOCUMENT',
+]);
+// Attributes to skip in extractAllEntityAttributes (shown elsewhere or non-displayable)
+const SKIP_DISPLAY_ATTRS = new Set(['GlobalId', 'OwnerHistory', 'ObjectPlacement', 'Representation']);
 // Property-related entity types for on-demand extraction
 const PROPERTY_ENTITY_TYPES = new Set([
     'IFCPROPERTYSET', 'IFCELEMENTQUANTITY',
@@ -74,6 +85,21 @@ const PROPERTY_ENTITY_TYPES = new Set([
     'IFCQUANTITYLENGTH', 'IFCQUANTITYAREA', 'IFCQUANTITYVOLUME',
     'IFCQUANTITYCOUNT', 'IFCQUANTITYWEIGHT', 'IFCQUANTITYTIME',
 ]);
+/**
+ * Detect the IFC schema version from the STEP FILE_SCHEMA header.
+ * Scans the first 2000 bytes for FILE_SCHEMA(('IFC2X3')), FILE_SCHEMA(('IFC4')), etc.
+ */
+function detectSchemaVersion(buffer) {
+    const headerEnd = Math.min(buffer.length, 2000);
+    const headerText = new TextDecoder().decode(buffer.subarray(0, headerEnd)).toUpperCase();
+    if (headerText.includes('IFC4X3'))
+        return 'IFC4X3';
+    if (headerText.includes('IFC4'))
+        return 'IFC4';
+    if (headerText.includes('IFC2X3'))
+        return 'IFC2X3';
+    return 'IFC4'; // Default fallback
+}
 export class ColumnarParser {
     /**
      * Parse IFC file into columnar data store
@@ -87,6 +113,8 @@ export class ColumnarParser {
         const uint8Buffer = new Uint8Array(buffer);
         const totalEntities = entityRefs.length;
         options.onProgress?.({ phase: 'building', percent: 0 });
+        // Detect schema version from FILE_SCHEMA header
+        const schemaVersion = detectSchemaVersion(uint8Buffer);
         // Initialize builders
         const strings = new StringTable();
         const entityTableBuilder = new EntityTableBuilder(totalEntities, strings);
@@ -104,6 +132,7 @@ export class ColumnarParser {
         const relationshipRefs = [];
         const propertyRelRefs = [];
         const propertyEntityRefs = [];
+        const associationRelRefs = [];
         for (const ref of entityRefs) {
             // Build entity index
             entityIndex.byId.set(ref.expressId, ref);
@@ -130,6 +159,9 @@ export class ColumnarParser {
             else if (PROPERTY_ENTITY_TYPES.has(typeUpper)) {
                 propertyEntityRefs.push(ref);
             }
+            else if (ASSOCIATION_REL_TYPES.has(typeUpper)) {
+                associationRelRefs.push(ref);
+            }
         }
         // === TARGETED PARSING: Parse spatial and geometry entities for GlobalIds ===
         options.onProgress?.({ phase: 'parsing spatial', percent: 10 });
@@ -220,6 +252,58 @@ export class ColumnarParser {
                 }
             }
         }
+        // === PARSE ASSOCIATION RELATIONSHIPS for on-demand classification/material/document loading ===
+        const onDemandClassificationMap = new Map();
+        const onDemandMaterialMap = new Map();
+        const onDemandDocumentMap = new Map();
+        for (const ref of associationRelRefs) {
+            const entity = extractor.extractEntity(ref);
+            if (entity) {
+                const attrs = entity.attributes || [];
+                // IfcRelAssociates subtypes:
+                // [0] GlobalId, [1] OwnerHistory, [2] Name, [3] Description
+                // [4] RelatedObjects (list of element IDs)
+                // [5] RelatingClassification / RelatingMaterial / RelatingDocument
+                const relatedObjects = attrs[4];
+                const relatingRef = attrs[5];
+                if (typeof relatingRef === 'number' && Array.isArray(relatedObjects)) {
+                    const typeUpper = ref.type.toUpperCase();
+                    if (typeUpper === 'IFCRELASSOCIATESCLASSIFICATION') {
+                        for (const objId of relatedObjects) {
+                            if (typeof objId === 'number') {
+                                let list = onDemandClassificationMap.get(objId);
+                                if (!list) {
+                                    list = [];
+                                    onDemandClassificationMap.set(objId, list);
+                                }
+                                list.push(relatingRef);
+                            }
+                        }
+                    }
+                    else if (typeUpper === 'IFCRELASSOCIATESMATERIAL') {
+                        // IFC allows multiple IfcRelAssociatesMaterial per element but typically
+                        // only one is valid. Last-write-wins: later relationships override earlier ones.
+                        for (const objId of relatedObjects) {
+                            if (typeof objId === 'number') {
+                                onDemandMaterialMap.set(objId, relatingRef);
+                            }
+                        }
+                    }
+                    else if (typeUpper === 'IFCRELASSOCIATESDOCUMENT') {
+                        for (const objId of relatedObjects) {
+                            if (typeof objId === 'number') {
+                                let list = onDemandDocumentMap.get(objId);
+                                if (!list) {
+                                    list = [];
+                                    onDemandDocumentMap.set(objId, list);
+                                }
+                                list.push(relatingRef);
+                            }
+                        }
+                    }
+                }
+            }
+        }
         // === BUILD ENTITY TABLE with spatial data included ===
         options.onProgress?.({ phase: 'building entities', percent: 30 });
         // OPTIMIZATION: Only add entities that are useful for the viewer UI
@@ -288,7 +372,7 @@ export class ColumnarParser {
         options.onProgress?.({ phase: 'complete', percent: 100 });
         return {
             fileSize: buffer.byteLength,
-            schemaVersion: 'IFC4',
+            schemaVersion,
             entityCount: totalEntities,
             parseTime,
             source: uint8Buffer,
@@ -301,6 +385,9 @@ export class ColumnarParser {
             spatialHierarchy,
             onDemandPropertyMap, // For instant property access
             onDemandQuantityMap, // For instant quantity access
+            onDemandClassificationMap, // For instant classification access
+            onDemandMaterialMap, // For instant material access
+            onDemandDocumentMap, // For instant document access
         };
     }
     /**
@@ -312,7 +399,7 @@ export class ColumnarParser {
             return null;
         let relatingObject;
         let relatedObjects;
-        if (typeUpper === 'IFCRELDEFINESBYPROPERTIES' || typeUpper === 'IFCRELCONTAINEDINSPATIALSTRUCTURE') {
+        if (typeUpper === 'IFCRELDEFINESBYPROPERTIES' || typeUpper === 'IFCRELDEFINESBYTYPE' || typeUpper === 'IFCRELCONTAINEDINSPATIALSTRUCTURE') {
             relatedObjects = attrs[4];
             relatingObject = attrs[5];
         }
@@ -371,20 +458,8 @@ export class ColumnarParser {
                     const propName = typeof propAttrs[0] === 'string' ? propAttrs[0] : '';
                     if (!propName)
                         continue;
-                    // IfcPropertySingleValue: [name, description, nominalValue, unit]
-                    const nominalValue = propAttrs[2];
-                    let type = 0; // String
-                    let value = nominalValue;
-                    if (typeof nominalValue === 'number') {
-                        type = 1; // Real
-                    }
-                    else if (typeof nominalValue === 'boolean') {
-                        type = 2; // Boolean
-                    }
-                    else if (nominalValue !== null && nominalValue !== undefined) {
-                        value = String(nominalValue);
-                    }
-                    properties.push({ name: propName, type, value });
+                    const parsed = parsePropertyValue(propEntity);
+                    properties.push({ name: propName, type: parsed.type, value: parsed.value });
                 }
             }
             if (properties.length > 0 || psetName) {
@@ -467,26 +542,813 @@ export function extractQuantitiesOnDemand(store, entityId) {
 }
 /**
  * Extract entity attributes on-demand from source buffer
- * Returns globalId, name, description, objectType for any IfcRoot-derived entity.
+ * Returns globalId, name, description, objectType, tag for any IfcRoot-derived entity.
  * This is used for entities that weren't fully parsed during initial load.
  */
 export function extractEntityAttributesOnDemand(store, entityId) {
     const ref = store.entityIndex.byId.get(entityId);
     if (!ref) {
-        return { globalId: '', name: '', description: '', objectType: '' };
+        return { globalId: '', name: '', description: '', objectType: '', tag: '' };
     }
     const extractor = new EntityExtractor(store.source);
     const entity = extractor.extractEntity(ref);
     if (!entity) {
-        return { globalId: '', name: '', description: '', objectType: '' };
+        return { globalId: '', name: '', description: '', objectType: '', tag: '' };
     }
     const attrs = entity.attributes || [];
     // IfcRoot attributes: [GlobalId, OwnerHistory, Name, Description]
     // IfcObject adds: [ObjectType] at index 4
+    // IfcProduct adds: [ObjectPlacement, Representation] at indices 5-6
+    // IfcElement adds: [Tag] at index 7
     const globalId = typeof attrs[0] === 'string' ? attrs[0] : '';
     const name = typeof attrs[2] === 'string' ? attrs[2] : '';
     const description = typeof attrs[3] === 'string' ? attrs[3] : '';
     const objectType = typeof attrs[4] === 'string' ? attrs[4] : '';
-    return { globalId, name, description, objectType };
+    const tag = typeof attrs[7] === 'string' ? attrs[7] : '';
+    return { globalId, name, description, objectType, tag };
+}
+/**
+ * Extract ALL named entity attributes on-demand from source buffer.
+ * Uses the IFC schema to map attribute indices to names.
+ * Returns only string/enum attributes, skipping references and structural attributes.
+ */
+export function extractAllEntityAttributes(store, entityId) {
+    const ref = store.entityIndex.byId.get(entityId);
+    if (!ref)
+        return [];
+    const extractor = new EntityExtractor(store.source);
+    const entity = extractor.extractEntity(ref);
+    if (!entity)
+        return [];
+    const attrs = entity.attributes || [];
+    // Use properly-cased type name from entity table (IfcTypeEnumToString)
+    // instead of ref.type which is UPPERCASE from STEP (e.g., IFCWALLSTANDARDCASE)
+    // and breaks multi-word type normalization in getAttributeNames
+    const typeName = store.entities.getTypeName(entityId);
+    const attrNames = getAttributeNames(typeName || ref.type);
+    const result = [];
+    const len = Math.min(attrs.length, attrNames.length);
+    for (let i = 0; i < len; i++) {
+        const attrName = attrNames[i];
+        if (SKIP_DISPLAY_ATTRS.has(attrName))
+            continue;
+        const raw = attrs[i];
+        if (typeof raw === 'string' && raw) {
+            // Clean enum values: .NOTDEFINED. -> NOTDEFINED
+            const display = raw.startsWith('.') && raw.endsWith('.')
+                ? raw.slice(1, -1)
+                : raw;
+            result.push({ name: attrName, value: display });
+        }
+    }
+    return result;
+}
+/**
+ * Extract classifications for a single entity ON-DEMAND.
+ * Uses the onDemandClassificationMap built during parsing.
+ * Falls back to relationship graph when on-demand map is not available (e.g., server-loaded models).
+ * Also checks type-level associations via IfcRelDefinesByType.
+ * Returns an array of classification references with system info.
+ */
+export function extractClassificationsOnDemand(store, entityId) {
+    let classRefIds;
+    if (store.onDemandClassificationMap) {
+        classRefIds = store.onDemandClassificationMap.get(entityId);
+    }
+    else if (store.relationships) {
+        // Fallback: use relationship graph (server-loaded models)
+        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesClassification, 'inverse');
+        if (related.length > 0)
+            classRefIds = related;
+    }
+    // Also check type-level classifications via IfcRelDefinesByType
+    if (store.relationships) {
+        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
+        for (const typeId of typeIds) {
+            let typeClassRefs;
+            if (store.onDemandClassificationMap) {
+                typeClassRefs = store.onDemandClassificationMap.get(typeId);
+            }
+            else {
+                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesClassification, 'inverse');
+                if (related.length > 0)
+                    typeClassRefs = related;
+            }
+            if (typeClassRefs && typeClassRefs.length > 0) {
+                classRefIds = classRefIds ? [...classRefIds, ...typeClassRefs] : [...typeClassRefs];
+            }
+        }
+    }
+    if (!classRefIds || classRefIds.length === 0)
+        return [];
+    if (!store.source?.length)
+        return [];
+    const extractor = new EntityExtractor(store.source);
+    const results = [];
+    for (const classRefId of classRefIds) {
+        const ref = store.entityIndex.byId.get(classRefId);
+        if (!ref)
+            continue;
+        const entity = extractor.extractEntity(ref);
+        if (!entity)
+            continue;
+        const typeUpper = entity.type.toUpperCase();
+        const attrs = entity.attributes || [];
+        if (typeUpper === 'IFCCLASSIFICATIONREFERENCE') {
+            // IfcClassificationReference: [Location, Identification, Name, ReferencedSource, Description, Sort]
+            const info = {
+                location: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                identification: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                name: typeof attrs[2] === 'string' ? attrs[2] : undefined,
+                description: typeof attrs[4] === 'string' ? attrs[4] : undefined,
+            };
+            // Walk up to find the classification system name
+            const referencedSourceId = typeof attrs[3] === 'number' ? attrs[3] : undefined;
+            if (referencedSourceId) {
+                const path = walkClassificationChain(store, extractor, referencedSourceId);
+                info.system = path.systemName;
+                info.path = path.codes;
+            }
+            results.push(info);
+        }
+        else if (typeUpper === 'IFCCLASSIFICATION') {
+            // IfcClassification: [Source, Edition, EditionDate, Name, Description, Location, ReferenceTokens]
+            results.push({
+                system: typeof attrs[3] === 'string' ? attrs[3] : undefined,
+                name: typeof attrs[3] === 'string' ? attrs[3] : undefined,
+                description: typeof attrs[4] === 'string' ? attrs[4] : undefined,
+                location: typeof attrs[5] === 'string' ? attrs[5] : undefined,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Walk up the IfcClassificationReference chain to find the root IfcClassification system.
+ */
+function walkClassificationChain(store, extractor, startId) {
+    const codes = [];
+    let currentId = startId;
+    const visited = new Set();
+    while (currentId !== undefined && !visited.has(currentId)) {
+        visited.add(currentId);
+        const ref = store.entityIndex.byId.get(currentId);
+        if (!ref)
+            break;
+        const entity = extractor.extractEntity(ref);
+        if (!entity)
+            break;
+        const typeUpper = entity.type.toUpperCase();
+        const attrs = entity.attributes || [];
+        if (typeUpper === 'IFCCLASSIFICATION') {
+            // Root: IfcClassification [Source, Edition, EditionDate, Name, ...]
+            const systemName = typeof attrs[3] === 'string' ? attrs[3] : undefined;
+            return { systemName, codes };
+        }
+        if (typeUpper === 'IFCCLASSIFICATIONREFERENCE') {
+            // IfcClassificationReference [Location, Identification, Name, ReferencedSource, ...]
+            const code = typeof attrs[1] === 'string' ? attrs[1] :
+                typeof attrs[2] === 'string' ? attrs[2] : undefined;
+            if (code)
+                codes.unshift(code);
+            currentId = typeof attrs[3] === 'number' ? attrs[3] : undefined;
+        }
+        else {
+            break;
+        }
+    }
+    return { codes };
+}
+/**
+ * Extract materials for a single entity ON-DEMAND.
+ * Uses the onDemandMaterialMap built during parsing.
+ * Falls back to relationship graph when on-demand map is not available (e.g., server-loaded models).
+ * Also checks type-level material assignments via IfcRelDefinesByType.
+ * Resolves the full material structure (layers, profiles, constituents, lists).
+ */
+export function extractMaterialsOnDemand(store, entityId) {
+    let materialId;
+    if (store.onDemandMaterialMap) {
+        materialId = store.onDemandMaterialMap.get(entityId);
+    }
+    else if (store.relationships) {
+        // Fallback: use relationship graph (server-loaded models)
+        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesMaterial, 'inverse');
+        if (related.length > 0)
+            materialId = related[0];
+    }
+    // Check type-level material if occurrence has none
+    if (materialId === undefined && store.relationships) {
+        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
+        for (const typeId of typeIds) {
+            if (store.onDemandMaterialMap) {
+                materialId = store.onDemandMaterialMap.get(typeId);
+            }
+            else {
+                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesMaterial, 'inverse');
+                if (related.length > 0)
+                    materialId = related[0];
+            }
+            if (materialId !== undefined)
+                break;
+        }
+    }
+    if (materialId === undefined)
+        return null;
+    if (!store.source?.length)
+        return null;
+    const extractor = new EntityExtractor(store.source);
+    return resolveMaterial(store, extractor, materialId, new Set());
+}
+/**
+ * Resolve a material entity by ID, handling all IFC material types.
+ * Uses visited set to prevent infinite recursion on cyclic *Usage references.
+ */
+function resolveMaterial(store, extractor, materialId, visited = new Set()) {
+    if (visited.has(materialId))
+        return null;
+    visited.add(materialId);
+    const ref = store.entityIndex.byId.get(materialId);
+    if (!ref)
+        return null;
+    const entity = extractor.extractEntity(ref);
+    if (!entity)
+        return null;
+    const typeUpper = entity.type.toUpperCase();
+    const attrs = entity.attributes || [];
+    switch (typeUpper) {
+        case 'IFCMATERIAL': {
+            // IfcMaterial: [Name, Description, Category]
+            return {
+                type: 'Material',
+                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+            };
+        }
+        case 'IFCMATERIALLAYERSET': {
+            // IfcMaterialLayerSet: [MaterialLayers, LayerSetName, Description]
+            const layerIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
+            const layers = [];
+            for (const layerId of layerIds) {
+                const layerRef = store.entityIndex.byId.get(layerId);
+                if (!layerRef)
+                    continue;
+                const layerEntity = extractor.extractEntity(layerRef);
+                if (!layerEntity)
+                    continue;
+                const la = layerEntity.attributes || [];
+                // IfcMaterialLayer: [Material, LayerThickness, IsVentilated, Name, Description, Category, Priority]
+                const matId = typeof la[0] === 'number' ? la[0] : undefined;
+                let materialName;
+                if (matId) {
+                    const matRef = store.entityIndex.byId.get(matId);
+                    if (matRef) {
+                        const matEntity = extractor.extractEntity(matRef);
+                        if (matEntity) {
+                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
+                        }
+                    }
+                }
+                layers.push({
+                    materialName,
+                    thickness: typeof la[1] === 'number' ? la[1] : undefined,
+                    isVentilated: la[2] === true || la[2] === '.T.',
+                    name: typeof la[3] === 'string' ? la[3] : undefined,
+                    category: typeof la[5] === 'string' ? la[5] : undefined,
+                });
+            }
+            return {
+                type: 'MaterialLayerSet',
+                name: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                description: typeof attrs[2] === 'string' ? attrs[2] : undefined,
+                layers,
+            };
+        }
+        case 'IFCMATERIALPROFILESET': {
+            // IfcMaterialProfileSet: [Name, Description, MaterialProfiles, CompositeProfile]
+            const profileIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
+            const profiles = [];
+            for (const profId of profileIds) {
+                const profRef = store.entityIndex.byId.get(profId);
+                if (!profRef)
+                    continue;
+                const profEntity = extractor.extractEntity(profRef);
+                if (!profEntity)
+                    continue;
+                const pa = profEntity.attributes || [];
+                // IfcMaterialProfile: [Name, Description, Material, Profile, Priority, Category]
+                const matId = typeof pa[2] === 'number' ? pa[2] : undefined;
+                let materialName;
+                if (matId) {
+                    const matRef = store.entityIndex.byId.get(matId);
+                    if (matRef) {
+                        const matEntity = extractor.extractEntity(matRef);
+                        if (matEntity) {
+                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
+                        }
+                    }
+                }
+                profiles.push({
+                    materialName,
+                    name: typeof pa[0] === 'string' ? pa[0] : undefined,
+                    category: typeof pa[5] === 'string' ? pa[5] : undefined,
+                });
+            }
+            return {
+                type: 'MaterialProfileSet',
+                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                profiles,
+            };
+        }
+        case 'IFCMATERIALCONSTITUENTSET': {
+            // IfcMaterialConstituentSet: [Name, Description, MaterialConstituents]
+            const constituentIds = Array.isArray(attrs[2]) ? attrs[2].filter((id) => typeof id === 'number') : [];
+            const constituents = [];
+            for (const constId of constituentIds) {
+                const constRef = store.entityIndex.byId.get(constId);
+                if (!constRef)
+                    continue;
+                const constEntity = extractor.extractEntity(constRef);
+                if (!constEntity)
+                    continue;
+                const ca = constEntity.attributes || [];
+                // IfcMaterialConstituent: [Name, Description, Material, Fraction, Category]
+                const matId = typeof ca[2] === 'number' ? ca[2] : undefined;
+                let materialName;
+                if (matId) {
+                    const matRef = store.entityIndex.byId.get(matId);
+                    if (matRef) {
+                        const matEntity = extractor.extractEntity(matRef);
+                        if (matEntity) {
+                            materialName = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : undefined;
+                        }
+                    }
+                }
+                constituents.push({
+                    materialName,
+                    name: typeof ca[0] === 'string' ? ca[0] : undefined,
+                    fraction: typeof ca[3] === 'number' ? ca[3] : undefined,
+                    category: typeof ca[4] === 'string' ? ca[4] : undefined,
+                });
+            }
+            return {
+                type: 'MaterialConstituentSet',
+                name: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                description: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                constituents,
+            };
+        }
+        case 'IFCMATERIALLIST': {
+            // IfcMaterialList: [Materials]
+            const matIds = Array.isArray(attrs[0]) ? attrs[0].filter((id) => typeof id === 'number') : [];
+            const materials = [];
+            for (const matId of matIds) {
+                const matRef = store.entityIndex.byId.get(matId);
+                if (!matRef)
+                    continue;
+                const matEntity = extractor.extractEntity(matRef);
+                if (matEntity) {
+                    const name = typeof matEntity.attributes?.[0] === 'string' ? matEntity.attributes[0] : `Material #${matId}`;
+                    materials.push(name);
+                }
+            }
+            return {
+                type: 'MaterialList',
+                materials,
+            };
+        }
+        case 'IFCMATERIALLAYERSETUSAGE': {
+            // IfcMaterialLayerSetUsage: [ForLayerSet, LayerSetDirection, DirectionSense, OffsetFromReferenceLine, ...]
+            const layerSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
+            if (layerSetId) {
+                return resolveMaterial(store, extractor, layerSetId, visited);
+            }
+            return null;
+        }
+        case 'IFCMATERIALPROFILESETUSAGE': {
+            // IfcMaterialProfileSetUsage: [ForProfileSet, ...]
+            const profileSetId = typeof attrs[0] === 'number' ? attrs[0] : undefined;
+            if (profileSetId) {
+                return resolveMaterial(store, extractor, profileSetId, visited);
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Parse a property entity's value based on its IFC type.
+ * Handles all 6 IfcProperty subtypes:
+ * - IfcPropertySingleValue: direct value
+ * - IfcPropertyEnumeratedValue: list of enum values → joined string
+ * - IfcPropertyBoundedValue: upper/lower bounds → "value [min – max]"
+ * - IfcPropertyListValue: list of values → joined string
+ * - IfcPropertyTableValue: defining/defined value pairs → "Table(N rows)"
+ * - IfcPropertyReferenceValue: entity reference → "Reference #ID"
+ */
+function parsePropertyValue(propEntity) {
+    const attrs = propEntity.attributes || [];
+    const typeUpper = propEntity.type.toUpperCase();
+    switch (typeUpper) {
+        case 'IFCPROPERTYENUMERATEDVALUE': {
+            // [Name, Description, EnumerationValues (list), EnumerationReference]
+            const enumValues = attrs[2];
+            if (Array.isArray(enumValues)) {
+                const values = enumValues.map(v => {
+                    if (Array.isArray(v) && v.length === 2)
+                        return String(v[1]); // Typed value
+                    return String(v);
+                }).filter(v => v !== 'null' && v !== 'undefined');
+                return { type: 0, value: values.join(', ') };
+            }
+            return { type: 0, value: null };
+        }
+        case 'IFCPROPERTYBOUNDEDVALUE': {
+            // [Name, Description, UpperBoundValue, LowerBoundValue, Unit, SetPointValue]
+            const upper = extractNumericValue(attrs[2]);
+            const lower = extractNumericValue(attrs[3]);
+            const setPoint = extractNumericValue(attrs[5]);
+            const displayValue = setPoint ?? upper ?? lower;
+            let display = displayValue != null ? String(displayValue) : '';
+            if (lower != null && upper != null) {
+                display += ` [${lower} – ${upper}]`;
+            }
+            return { type: displayValue != null ? 1 : 0, value: display || null };
+        }
+        case 'IFCPROPERTYLISTVALUE': {
+            // [Name, Description, ListValues (list), Unit]
+            const listValues = attrs[2];
+            if (Array.isArray(listValues)) {
+                const values = listValues.map(v => {
+                    if (Array.isArray(v) && v.length === 2)
+                        return String(v[1]);
+                    return String(v);
+                }).filter(v => v !== 'null' && v !== 'undefined');
+                return { type: 0, value: values.join(', ') };
+            }
+            return { type: 0, value: null };
+        }
+        case 'IFCPROPERTYTABLEVALUE': {
+            // [Name, Description, DefiningValues, DefinedValues, ...]
+            const definingValues = attrs[2];
+            const definedValues = attrs[3];
+            const rowCount = Array.isArray(definingValues) ? definingValues.length : 0;
+            if (rowCount > 0 && Array.isArray(definedValues)) {
+                return { type: 0, value: `Table (${rowCount} rows)` };
+            }
+            return { type: 0, value: null };
+        }
+        case 'IFCPROPERTYREFERENCEVALUE': {
+            // [Name, Description, PropertyReference]
+            const refValue = attrs[2];
+            if (typeof refValue === 'number') {
+                return { type: 0, value: `#${refValue}` };
+            }
+            return { type: 0, value: null };
+        }
+        default: {
+            // IfcPropertySingleValue and fallback: [Name, Description, NominalValue, Unit]
+            const nominalValue = attrs[2];
+            let type = 0;
+            let value = nominalValue;
+            // Handle typed values like IFCBOOLEAN(.T.), IFCREAL(1.5)
+            if (Array.isArray(nominalValue) && nominalValue.length === 2) {
+                const innerValue = nominalValue[1];
+                const typeName = String(nominalValue[0]).toUpperCase();
+                if (typeName.includes('BOOLEAN') || typeName.includes('LOGICAL')) {
+                    type = 2;
+                    value = innerValue === '.T.' || innerValue === true;
+                }
+                else if (typeof innerValue === 'number') {
+                    type = 1;
+                    value = innerValue;
+                }
+                else {
+                    type = 0;
+                    value = String(innerValue);
+                }
+            }
+            else if (typeof nominalValue === 'number') {
+                type = 1;
+            }
+            else if (typeof nominalValue === 'boolean') {
+                type = 2;
+            }
+            else if (nominalValue !== null && nominalValue !== undefined) {
+                value = String(nominalValue);
+            }
+            return { type, value };
+        }
+    }
+}
+/** Extract a numeric value from a possibly typed STEP value. */
+function extractNumericValue(attr) {
+    if (typeof attr === 'number')
+        return attr;
+    if (Array.isArray(attr) && attr.length === 2 && typeof attr[1] === 'number')
+        return attr[1];
+    return null;
+}
+/**
+ * Extract property sets from a list of pset IDs using the entity index.
+ * Shared logic between instance-level and type-level property extraction.
+ */
+function extractPsetsFromIds(store, extractor, psetIds) {
+    const result = [];
+    for (const psetId of psetIds) {
+        const psetRef = store.entityIndex.byId.get(psetId);
+        if (!psetRef)
+            continue;
+        // Only extract IFCPROPERTYSET entities (skip quantity sets etc.)
+        if (psetRef.type.toUpperCase() !== 'IFCPROPERTYSET')
+            continue;
+        const psetEntity = extractor.extractEntity(psetRef);
+        if (!psetEntity)
+            continue;
+        const psetAttrs = psetEntity.attributes || [];
+        const psetGlobalId = typeof psetAttrs[0] === 'string' ? psetAttrs[0] : undefined;
+        const psetName = typeof psetAttrs[2] === 'string' ? psetAttrs[2] : `PropertySet #${psetId}`;
+        const hasProperties = psetAttrs[4];
+        const properties = [];
+        if (Array.isArray(hasProperties)) {
+            for (const propRef of hasProperties) {
+                if (typeof propRef !== 'number')
+                    continue;
+                const propEntityRef = store.entityIndex.byId.get(propRef);
+                if (!propEntityRef)
+                    continue;
+                const propEntity = extractor.extractEntity(propEntityRef);
+                if (!propEntity)
+                    continue;
+                const propAttrs = propEntity.attributes || [];
+                const propName = typeof propAttrs[0] === 'string' ? propAttrs[0] : '';
+                if (!propName)
+                    continue;
+                const parsed = parsePropertyValue(propEntity);
+                properties.push({ name: propName, type: parsed.type, value: parsed.value });
+            }
+        }
+        if (properties.length > 0 || psetName) {
+            result.push({ name: psetName, globalId: psetGlobalId, properties });
+        }
+    }
+    return result;
+}
+/**
+ * Extract type-level properties for a single entity ON-DEMAND.
+ * Finds the element's type via IfcRelDefinesByType, then extracts property sets from:
+ * 1. The type entity's HasPropertySets attribute (IFC2X3/IFC4: index 5 on IfcTypeObject)
+ * 2. The onDemandPropertyMap for the type entity (IFC4 IFCRELDEFINESBYPROPERTIES → type)
+ * Returns null if no type relationship exists.
+ */
+export function extractTypePropertiesOnDemand(store, entityId) {
+    if (!store.relationships)
+        return null;
+    // Find type entity via DefinesByType relationship (inverse: element → type)
+    const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
+    if (typeIds.length === 0)
+        return null;
+    const typeId = typeIds[0]; // An element typically has one type
+    const typeRef = store.entityIndex.byId.get(typeId);
+    if (!typeRef)
+        return null;
+    if (!store.source?.length)
+        return null;
+    const extractor = new EntityExtractor(store.source);
+    // Get type name from entity
+    const typeEntity = extractor.extractEntity(typeRef);
+    const typeName = typeEntity && typeof typeEntity.attributes?.[2] === 'string'
+        ? typeEntity.attributes[2]
+        : typeRef.type;
+    const allPsets = [];
+    const seenPsetNames = new Set();
+    // Source 1: HasPropertySets attribute on the type entity (index 5 for IfcTypeObject subtypes)
+    // Works for both IFC2X3 and IFC4
+    if (typeEntity) {
+        const hasPropertySets = typeEntity.attributes?.[5];
+        if (Array.isArray(hasPropertySets)) {
+            const psetIds = hasPropertySets.filter((id) => typeof id === 'number');
+            const psets = extractPsetsFromIds(store, extractor, psetIds);
+            for (const pset of psets) {
+                seenPsetNames.add(pset.name);
+                allPsets.push(pset);
+            }
+        }
+    }
+    // Source 2: onDemandPropertyMap for the type entity (IFC4: via IFCRELDEFINESBYPROPERTIES)
+    if (store.onDemandPropertyMap) {
+        const typePsetIds = store.onDemandPropertyMap.get(typeId);
+        if (typePsetIds && typePsetIds.length > 0) {
+            const psets = extractPsetsFromIds(store, extractor, typePsetIds);
+            for (const pset of psets) {
+                if (!seenPsetNames.has(pset.name)) {
+                    allPsets.push(pset);
+                }
+            }
+        }
+    }
+    if (allPsets.length === 0)
+        return null;
+    return {
+        typeName,
+        typeId,
+        properties: allPsets,
+    };
+}
+/**
+ * Extract documents for a single entity ON-DEMAND.
+ * Uses the onDemandDocumentMap built during parsing.
+ * Falls back to relationship graph when on-demand map is not available.
+ * Also checks type-level documents via IfcRelDefinesByType.
+ * Returns an array of document info objects.
+ */
+export function extractDocumentsOnDemand(store, entityId) {
+    let docRefIds;
+    if (store.onDemandDocumentMap) {
+        docRefIds = store.onDemandDocumentMap.get(entityId);
+    }
+    else if (store.relationships) {
+        const related = store.relationships.getRelated(entityId, RelationshipType.AssociatesDocument, 'inverse');
+        if (related.length > 0)
+            docRefIds = related;
+    }
+    // Also check type-level documents via IfcRelDefinesByType
+    if (store.relationships) {
+        const typeIds = store.relationships.getRelated(entityId, RelationshipType.DefinesByType, 'inverse');
+        for (const typeId of typeIds) {
+            let typeDocRefs;
+            if (store.onDemandDocumentMap) {
+                typeDocRefs = store.onDemandDocumentMap.get(typeId);
+            }
+            else {
+                const related = store.relationships.getRelated(typeId, RelationshipType.AssociatesDocument, 'inverse');
+                if (related.length > 0)
+                    typeDocRefs = related;
+            }
+            if (typeDocRefs && typeDocRefs.length > 0) {
+                docRefIds = docRefIds ? [...docRefIds, ...typeDocRefs] : [...typeDocRefs];
+            }
+        }
+    }
+    if (!docRefIds || docRefIds.length === 0)
+        return [];
+    if (!store.source?.length)
+        return [];
+    const extractor = new EntityExtractor(store.source);
+    const results = [];
+    for (const docId of docRefIds) {
+        const docRef = store.entityIndex.byId.get(docId);
+        if (!docRef)
+            continue;
+        const docEntity = extractor.extractEntity(docRef);
+        if (!docEntity)
+            continue;
+        const typeUpper = docEntity.type.toUpperCase();
+        const attrs = docEntity.attributes || [];
+        if (typeUpper === 'IFCDOCUMENTREFERENCE') {
+            // IFC4: [Location, Identification, Name, Description, ReferencedDocument]
+            // IFC2X3: [Location, ItemReference, Name]
+            const info = {
+                location: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                identification: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                name: typeof attrs[2] === 'string' ? attrs[2] : undefined,
+                description: typeof attrs[3] === 'string' ? attrs[3] : undefined,
+            };
+            // Walk to IfcDocumentInformation if ReferencedDocument is set (IFC4 attr[4])
+            if (typeof attrs[4] === 'number') {
+                const docInfoRef = store.entityIndex.byId.get(attrs[4]);
+                if (docInfoRef) {
+                    const docInfoEntity = extractor.extractEntity(docInfoRef);
+                    if (docInfoEntity && docInfoEntity.type.toUpperCase() === 'IFCDOCUMENTINFORMATION') {
+                        const ia = docInfoEntity.attributes || [];
+                        // IfcDocumentInformation: [Identification, Name, Description, Location, Purpose, IntendedUse, Scope, Revision, ...]
+                        if (!info.identification && typeof ia[0] === 'string')
+                            info.identification = ia[0];
+                        if (!info.name && typeof ia[1] === 'string')
+                            info.name = ia[1];
+                        if (!info.description && typeof ia[2] === 'string')
+                            info.description = ia[2];
+                        if (!info.location && typeof ia[3] === 'string')
+                            info.location = ia[3];
+                        if (typeof ia[4] === 'string')
+                            info.purpose = ia[4];
+                        if (typeof ia[5] === 'string')
+                            info.intendedUse = ia[5];
+                        if (typeof ia[7] === 'string')
+                            info.revision = ia[7];
+                    }
+                }
+            }
+            if (info.name || info.location || info.identification) {
+                results.push(info);
+            }
+        }
+        else if (typeUpper === 'IFCDOCUMENTINFORMATION') {
+            // Direct IfcDocumentInformation (less common)
+            const info = {
+                identification: typeof attrs[0] === 'string' ? attrs[0] : undefined,
+                name: typeof attrs[1] === 'string' ? attrs[1] : undefined,
+                description: typeof attrs[2] === 'string' ? attrs[2] : undefined,
+                location: typeof attrs[3] === 'string' ? attrs[3] : undefined,
+                purpose: typeof attrs[4] === 'string' ? attrs[4] : undefined,
+                intendedUse: typeof attrs[5] === 'string' ? attrs[5] : undefined,
+                revision: typeof attrs[7] === 'string' ? attrs[7] : undefined,
+            };
+            if (info.name || info.location || info.identification) {
+                results.push(info);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Extract structural relationships for a single entity ON-DEMAND.
+ * Finds openings (VoidsElement), fills (FillsElement), groups (AssignsToGroup),
+ * and path connections (ConnectsPathElements).
+ */
+export function extractRelationshipsOnDemand(store, entityId) {
+    const result = {
+        voids: [],
+        fills: [],
+        groups: [],
+        connections: [],
+    };
+    if (!store.relationships)
+        return result;
+    const getEntityInfo = (id) => {
+        const ref = store.entityIndex.byId.get(id);
+        if (!ref)
+            return { type: 'Unknown' };
+        const name = store.entities?.getName(id);
+        return { name: name || undefined, type: ref.type };
+    };
+    // VoidsElement: openings that void this element
+    const voidsIds = store.relationships.getRelated(entityId, RelationshipType.VoidsElement, 'forward');
+    for (const id of voidsIds) {
+        const info = getEntityInfo(id);
+        result.voids.push({ id, ...info });
+    }
+    // FillsElement: this element fills an opening
+    const fillsIds = store.relationships.getRelated(entityId, RelationshipType.FillsElement, 'inverse');
+    for (const id of fillsIds) {
+        const info = getEntityInfo(id);
+        result.fills.push({ id, ...info });
+    }
+    // AssignsToGroup: groups this element belongs to
+    const groupIds = store.relationships.getRelated(entityId, RelationshipType.AssignsToGroup, 'inverse');
+    for (const id of groupIds) {
+        const name = store.entities?.getName(id);
+        result.groups.push({ id, name: name || undefined });
+    }
+    // ConnectsPathElements: connected walls
+    const connectedIds = store.relationships.getRelated(entityId, RelationshipType.ConnectsPathElements, 'forward');
+    const connectedInverseIds = store.relationships.getRelated(entityId, RelationshipType.ConnectsPathElements, 'inverse');
+    const allConnected = new Set([...connectedIds, ...connectedInverseIds]);
+    allConnected.delete(entityId);
+    for (const id of allConnected) {
+        const info = getEntityInfo(id);
+        result.connections.push({ id, ...info });
+    }
+    return result;
+}
+// ============================================================================
+// On-Demand Georeferencing Extraction
+// ============================================================================
+import { extractGeoreferencing as extractGeorefFromEntities } from './georef-extractor.js';
+/**
+ * Extract georeferencing info from on-demand store (source buffer + entityIndex).
+ * Bridges to the entity-based georef extractor by resolving entities lazily.
+ */
+export function extractGeoreferencingOnDemand(store) {
+    if (!store.source?.length || !store.entityIndex)
+        return null;
+    const extractor = new EntityExtractor(store.source);
+    const { byId, byType } = store.entityIndex;
+    // Build a lightweight entity map for just the georef-related types
+    const entityMap = new Map();
+    const typeMap = new Map();
+    for (const typeName of ['IFCMAPCONVERSION', 'IFCPROJECTEDCRS']) {
+        const ids = byType.get(typeName);
+        if (!ids?.length)
+            continue;
+        // Use mixed-case for the georef extractor's type lookup
+        const displayName = typeName === 'IFCMAPCONVERSION' ? 'IfcMapConversion' : 'IfcProjectedCRS';
+        typeMap.set(displayName, ids);
+        for (const id of ids) {
+            const ref = byId.get(id);
+            if (!ref)
+                continue;
+            const entity = extractor.extractEntity(ref);
+            if (entity) {
+                entityMap.set(id, entity);
+            }
+        }
+    }
+    if (entityMap.size === 0)
+        return null;
+    // Cast to IfcEntity (they share the same shape)
+    return extractGeorefFromEntities(entityMap, typeMap);
 }
 //# sourceMappingURL=columnar-parser.js.map