@ifc-lite/parser 1.1.7 → 1.2.0

package/dist/columnar-parser.js

@@ -1,216 +1,296 @@
 /* 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 { PropertyExtractor } from './property-extractor.js';
-import { QuantityExtractor } from './quantity-extractor.js';
-import { RelationshipExtractor } from './relationship-extractor.js';
 import { SpatialHierarchyBuilder } from './spatial-hierarchy-builder.js';
-import { StringTable, EntityTableBuilder, PropertyTableBuilder, QuantityTableBuilder, RelationshipGraphBuilder, RelationshipType, PropertyValueType, QuantityType, } from '@ifc-lite/data';
+import { EntityExtractor } from './entity-extractor.js';
+import { extractLengthUnitScale } from './unit-extractor.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([
+    'IFCWALL', 'IFCWALLSTANDARDCASE', 'IFCDOOR', 'IFCWINDOW', 'IFCSLAB',
+    'IFCCOLUMN', 'IFCBEAM', 'IFCROOF', 'IFCSTAIR', 'IFCSTAIRFLIGHT',
+    'IFCRAILING', 'IFCRAMP', 'IFCRAMPFLIGHT', 'IFCPLATE', 'IFCMEMBER',
+    'IFCCURTAINWALL', 'IFCFOOTING', 'IFCPILE', 'IFCBUILDINGELEMENTPROXY',
+    'IFCFURNISHINGELEMENT', 'IFCFLOWSEGMENT', 'IFCFLOWTERMINAL',
+    'IFCFLOWCONTROLLER', 'IFCFLOWFITTING', 'IFCSPACE', 'IFCOPENINGELEMENT',
+    'IFCSITE', 'IFCBUILDING', 'IFCBUILDINGSTOREY',
+]);
+// IMPORTANT: This set MUST include ALL RelationshipType enum values to prevent semantic loss
+// Missing types will be skipped during parsing, causing incomplete relationship graphs
+const RELATIONSHIP_TYPES = new Set([
+    'IFCRELCONTAINEDINSPATIALSTRUCTURE', 'IFCRELAGGREGATES',
+    'IFCRELDEFINESBYPROPERTIES', 'IFCRELDEFINESBYTYPE',
+    'IFCRELASSOCIATESMATERIAL', 'IFCRELASSOCIATESCLASSIFICATION',
+    'IFCRELVOIDSELEMENT', 'IFCRELFILLSELEMENT',
+    'IFCRELCONNECTSPATHELEMENTS', 'IFCRELCONNECTSELEMENTS',
+    'IFCRELSPACEBOUNDARY',
+    'IFCRELASSIGNSTOGROUP', 'IFCRELASSIGNSTOPRODUCT',
+    'IFCRELREFERENCEDINSPATIALSTRUCTURE',
+]);
+// Map IFC relationship type strings to RelationshipType enum
+// MUST cover ALL RelationshipType enum values (14 types total)
+const REL_TYPE_MAP = {
+    'IFCRELCONTAINEDINSPATIALSTRUCTURE': RelationshipType.ContainsElements,
+    'IFCRELAGGREGATES': RelationshipType.Aggregates,
+    'IFCRELDEFINESBYPROPERTIES': RelationshipType.DefinesByProperties,
+    'IFCRELDEFINESBYTYPE': RelationshipType.DefinesByType,
+    'IFCRELASSOCIATESMATERIAL': RelationshipType.AssociatesMaterial,
+    'IFCRELASSOCIATESCLASSIFICATION': RelationshipType.AssociatesClassification,
+    'IFCRELVOIDSELEMENT': RelationshipType.VoidsElement,
+    'IFCRELFILLSELEMENT': RelationshipType.FillsElement,
+    'IFCRELCONNECTSPATHELEMENTS': RelationshipType.ConnectsPathElements,
+    'IFCRELCONNECTSELEMENTS': RelationshipType.ConnectsElements,
+    'IFCRELSPACEBOUNDARY': RelationshipType.SpaceBoundary,
+    'IFCRELASSIGNSTOGROUP': RelationshipType.AssignsToGroup,
+    'IFCRELASSIGNSTOPRODUCT': RelationshipType.AssignsToProduct,
+    'IFCRELREFERENCEDINSPATIALSTRUCTURE': RelationshipType.ReferencedInSpatialStructure,
+};
+const QUANTITY_TYPE_MAP = {
+    'IFCQUANTITYLENGTH': QuantityType.Length,
+    'IFCQUANTITYAREA': QuantityType.Area,
+    'IFCQUANTITYVOLUME': QuantityType.Volume,
+    'IFCQUANTITYCOUNT': QuantityType.Count,
+    'IFCQUANTITYWEIGHT': QuantityType.Weight,
+    'IFCQUANTITYTIME': QuantityType.Time,
+};
+// Types needed for spatial hierarchy (small subset)
+const SPATIAL_TYPES = new Set([
+    'IFCPROJECT', 'IFCSITE', 'IFCBUILDING', 'IFCBUILDINGSTOREY', 'IFCSPACE',
+]);
+// Relationship types needed for hierarchy
+const HIERARCHY_REL_TYPES = new Set([
+    'IFCRELAGGREGATES', 'IFCRELCONTAINEDINSPATIALSTRUCTURE',
+]);
+// Relationship types for on-demand property loading
+const PROPERTY_REL_TYPES = new Set([
+    'IFCRELDEFINESBYPROPERTIES',
+]);
+// Property-related entity types for on-demand extraction
+const PROPERTY_ENTITY_TYPES = new Set([
+    'IFCPROPERTYSET', 'IFCELEMENTQUANTITY',
+    'IFCPROPERTYSINGLEVALUE', 'IFCPROPERTYENUMERATEDVALUE',
+    'IFCPROPERTYBOUNDEDVALUE', 'IFCPROPERTYTABLEVALUE',
+    'IFCPROPERTYLISTVALUE', 'IFCPROPERTYREFERENCEVALUE',
+    'IFCQUANTITYLENGTH', 'IFCQUANTITYAREA', 'IFCQUANTITYVOLUME',
+    'IFCQUANTITYCOUNT', 'IFCQUANTITYWEIGHT', 'IFCQUANTITYTIME',
+]);
+// Yield helper - batched to reduce overhead
+const YIELD_INTERVAL = 5000;
+let yieldCounter = 0;
+async function maybeYield() {
+    yieldCounter++;
+    if (yieldCounter >= YIELD_INTERVAL) {
+        yieldCounter = 0;
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+}
 export class ColumnarParser {
     /**
      * Parse IFC file into columnar data store
+     *
+     * Uses fast semicolon-based scanning with on-demand property extraction.
+     * Properties are parsed lazily when accessed, not upfront.
+     * This provides instant UI responsiveness even for very large files.
      */
-    async parse(buffer, entityRefs, entities, options = {}) {
+    async parseLite(buffer, entityRefs, options = {}) {
         const startTime = performance.now();
         const uint8Buffer = new Uint8Array(buffer);
+        const totalEntities = entityRefs.length;
+        options.onProgress?.({ phase: 'building', percent: 0 });
         // Initialize builders
         const strings = new StringTable();
-        const entityTableBuilder = new EntityTableBuilder(entities.size, strings);
+        const entityTableBuilder = new EntityTableBuilder(totalEntities, strings);
         const propertyTableBuilder = new PropertyTableBuilder(strings);
+        const quantityTableBuilder = new QuantityTableBuilder(strings);
         const relationshipGraphBuilder = new RelationshipGraphBuilder();
-        // === Build Entity Table ===
-        options.onProgress?.({ phase: 'entities', percent: 0 });
-        let processed = 0;
-        for (const [id, entity] of entities) {
-            const attrs = entity.attributes || [];
-            const globalId = String(attrs[0] || '');
-            const name = String(attrs[2] || '');
-            const description = String(attrs[3] || '');
-            const objectType = String(attrs[7] || '');
-            // Check if entity has geometry (simplified check)
-            const hasGeometry = entity.type.toUpperCase().includes('WALL') ||
-                entity.type.toUpperCase().includes('DOOR') ||
-                entity.type.toUpperCase().includes('WINDOW') ||
-                entity.type.toUpperCase().includes('SLAB') ||
-                entity.type.toUpperCase().includes('COLUMN') ||
-                entity.type.toUpperCase().includes('BEAM');
-            const isType = entity.type.toUpperCase().endsWith('TYPE');
-            entityTableBuilder.add(id, entity.type, globalId, name, description, objectType, hasGeometry, isType);
-            processed++;
-            if (processed % 1000 === 0) {
-                options.onProgress?.({ phase: 'entities', percent: (processed / entities.size) * 100 });
+        // Build entity index early (needed for property relationship lookup)
+        const entityIndex = {
+            byId: new Map(),
+            byType: new Map(),
+        };
+        // First pass: collect spatial, relationship, and property refs for targeted parsing
+        const spatialRefs = [];
+        const relationshipRefs = [];
+        const propertyRelRefs = [];
+        const propertyEntityRefs = [];
+        for (const ref of entityRefs) {
+            // Build entity index
+            entityIndex.byId.set(ref.expressId, ref);
+            let typeList = entityIndex.byType.get(ref.type);
+            if (!typeList) {
+                typeList = [];
+                entityIndex.byType.set(ref.type, typeList);
+            }
+            typeList.push(ref.expressId);
+            // Categorize refs for targeted parsing
+            const typeUpper = ref.type.toUpperCase();
+            if (SPATIAL_TYPES.has(typeUpper)) {
+                spatialRefs.push(ref);
+            }
+            else if (HIERARCHY_REL_TYPES.has(typeUpper)) {
+                relationshipRefs.push(ref);
+            }
+            else if (PROPERTY_REL_TYPES.has(typeUpper)) {
+                propertyRelRefs.push(ref);
+            }
+            else if (PROPERTY_ENTITY_TYPES.has(typeUpper)) {
+                propertyEntityRefs.push(ref);
             }
         }
-        const entityTable = entityTableBuilder.build();
-        options.onProgress?.({ phase: 'entities', percent: 100 });
-        // === Build Property Table ===
-        options.onProgress?.({ phase: 'properties', percent: 0 });
-        const propertyExtractor = new PropertyExtractor(entities);
-        const propertySets = propertyExtractor.extractPropertySets();
-        // Build mapping: psetId -> entityIds
-        const psetToEntities = new Map();
-        const relationshipExtractor = new RelationshipExtractor(entities);
-        const relationships = relationshipExtractor.extractRelationships();
-        for (const rel of relationships) {
-            if (rel.type.toUpperCase() === 'IFCRELDEFINESBYPROPERTIES') {
-                const psetId = rel.relatingObject;
-                for (const entityId of rel.relatedObjects) {
-                    let list = psetToEntities.get(psetId);
-                    if (!list) {
-                        list = [];
-                        psetToEntities.set(psetId, list);
-                    }
-                    list.push(entityId);
-                }
+        // === TARGETED PARSING: Parse spatial entities first ===
+        options.onProgress?.({ phase: 'parsing spatial', percent: 10 });
+        const extractor = new EntityExtractor(uint8Buffer);
+        const parsedSpatialData = new Map();
+        // Parse spatial entities (typically < 100 entities)
+        for (const ref of spatialRefs) {
+            const entity = extractor.extractEntity(ref);
+            if (entity) {
+                const attrs = entity.attributes || [];
+                const globalId = typeof attrs[0] === 'string' ? attrs[0] : '';
+                const name = typeof attrs[2] === 'string' ? attrs[2] : '';
+                parsedSpatialData.set(ref.expressId, { globalId, name });
             }
         }
-        // Extract properties into columnar format
-        for (const [psetId, pset] of propertySets) {
-            const entityIds = psetToEntities.get(psetId) || [];
-            const globalId = String(entities.get(psetId)?.attributes?.[0] || '');
-            for (const [propName, propValue] of pset.properties) {
-                for (const entityId of entityIds) {
-                    let propType = PropertyValueType.String;
-                    let value = propValue.value;
-                    if (propValue.type === 'number') {
-                        propType = PropertyValueType.Real;
-                        value = propValue.value;
-                    }
-                    else if (propValue.type === 'boolean') {
-                        propType = PropertyValueType.Boolean;
-                        value = propValue.value;
-                    }
-                    else if (propValue.type === 'string') {
-                        propType = PropertyValueType.String;
-                        value = String(propValue.value);
+        console.log(`[ColumnarParser] Parsed ${spatialRefs.length} spatial entities`);
+        // Parse relationship entities (typically < 10k entities)
+        options.onProgress?.({ phase: 'parsing relationships', percent: 20 });
+        const relationships = [];
+        for (const ref of relationshipRefs) {
+            const entity = extractor.extractEntity(ref);
+            if (entity) {
+                const typeUpper = entity.type.toUpperCase();
+                const rel = this.extractRelationshipFast(entity, typeUpper);
+                if (rel) {
+                    relationships.push(rel);
+                    // Add to relationship graph
+                    const relType = REL_TYPE_MAP[typeUpper];
+                    if (relType) {
+                        for (const targetId of rel.relatedObjects) {
+                            relationshipGraphBuilder.addEdge(rel.relatingObject, targetId, relType, rel.relatingObject);
+                        }
                     }
-                    propertyTableBuilder.add({
-                        entityId,
-                        psetName: pset.name,
-                        psetGlobalId: globalId,
-                        propName,
-                        propType,
-                        value,
-                    });
                 }
             }
         }
-        const propertyTable = propertyTableBuilder.build();
-        options.onProgress?.({ phase: 'properties', percent: 100 });
-        // === Build Quantity Table ===
-        options.onProgress?.({ phase: 'quantities', percent: 0 });
-        const quantityTableBuilder = new QuantityTableBuilder(strings);
-        const quantityExtractor = new QuantityExtractor(entities);
-        const quantitySets = quantityExtractor.extractQuantitySets();
-        // Build mapping: qsetId -> entityIds (similar to properties)
-        const qsetToEntities = new Map();
-        for (const rel of relationships) {
-            if (rel.type.toUpperCase() === 'IFCRELDEFINESBYPROPERTIES') {
-                const qsetId = rel.relatingObject;
-                // Check if this is actually a quantity set (not a property set)
-                if (quantitySets.has(qsetId)) {
-                    for (const entityId of rel.relatedObjects) {
-                        let list = qsetToEntities.get(qsetId);
-                        if (!list) {
-                            list = [];
-                            qsetToEntities.set(qsetId, list);
+        console.log(`[ColumnarParser] Parsed ${relationshipRefs.length} relationship entities, ${relationships.length} valid relationships`);
+        // === PARSE PROPERTY RELATIONSHIPS for on-demand loading ===
+        options.onProgress?.({ phase: 'parsing property refs', percent: 25 });
+        const onDemandPropertyMap = new Map();
+        const onDemandQuantityMap = new Map();
+        // Parse IfcRelDefinesByProperties to build entity -> pset/qset mapping
+        // ALSO add to relationship graph so cache loads can rebuild on-demand maps
+        for (const ref of propertyRelRefs) {
+            const entity = extractor.extractEntity(ref);
+            if (entity) {
+                const attrs = entity.attributes || [];
+                // IfcRelDefinesByProperties: relatedObjects at [4], relatingPropertyDefinition at [5]
+                const relatedObjects = attrs[4];
+                const relatingDef = attrs[5];
+                if (typeof relatingDef === 'number' && Array.isArray(relatedObjects)) {
+                    // Add to relationship graph (needed for cache rebuild)
+                    for (const objId of relatedObjects) {
+                        if (typeof objId === 'number') {
+                            relationshipGraphBuilder.addEdge(relatingDef, objId, RelationshipType.DefinesByProperties, ref.expressId);
+                        }
+                    }
+                    // Find if the relating definition is a property set or quantity set
+                    const defRef = entityIndex.byId.get(relatingDef);
+                    if (defRef) {
+                        const defTypeUpper = defRef.type.toUpperCase();
+                        const isPropertySet = defTypeUpper === 'IFCPROPERTYSET';
+                        const isQuantitySet = defTypeUpper === 'IFCELEMENTQUANTITY';
+                        if (isPropertySet || isQuantitySet) {
+                            const targetMap = isPropertySet ? onDemandPropertyMap : onDemandQuantityMap;
+                            for (const objId of relatedObjects) {
+                                if (typeof objId === 'number') {
+                                    let list = targetMap.get(objId);
+                                    if (!list) {
+                                        list = [];
+                                        targetMap.set(objId, list);
+                                    }
+                                    list.push(relatingDef);
+                                }
+                            }
                         }
-                        list.push(entityId);
                     }
                 }
             }
         }
-        // Map quantity type names to QuantityType enum
-        const quantityTypeMap = {
-            'length': QuantityType.Length,
-            'area': QuantityType.Area,
-            'volume': QuantityType.Volume,
-            'count': QuantityType.Count,
-            'weight': QuantityType.Weight,
-            'time': QuantityType.Time,
-        };
-        // Extract quantities into columnar format
-        for (const [qsetId, qset] of quantitySets) {
-            const entityIds = qsetToEntities.get(qsetId) || [];
-            for (const quantity of qset.quantities) {
-                for (const entityId of entityIds) {
-                    quantityTableBuilder.add({
-                        entityId,
-                        qsetName: qset.name,
-                        quantityName: quantity.name,
-                        quantityType: quantityTypeMap[quantity.type] ?? QuantityType.Length,
-                        value: quantity.value,
-                        formula: quantity.formula,
-                    });
-                }
+        console.log(`[ColumnarParser] On-demand: ${onDemandPropertyMap.size} entities with properties, ${onDemandQuantityMap.size} with quantities`);
+        // === 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
+        // Skip geometric primitives like IFCCARTESIANPOINT, IFCDIRECTION, etc.
+        // This reduces 4M+ entities to ~100K relevant ones
+        const RELEVANT_ENTITY_PREFIXES = new Set([
+            'IFCWALL', 'IFCSLAB', 'IFCBEAM', 'IFCCOLUMN', 'IFCPLATE', 'IFCDOOR', 'IFCWINDOW',
+            'IFCROOF', 'IFCSTAIR', 'IFCRAILING', 'IFCRAMP', 'IFCFOOTING', 'IFCPILE',
+            'IFCMEMBER', 'IFCCURTAINWALL', 'IFCBUILDINGELEMENTPROXY', 'IFCFURNISHINGELEMENT',
+            'IFCFLOWSEGMENT', 'IFCFLOWTERMINAL', 'IFCFLOWCONTROLLER', 'IFCFLOWFITTING',
+            'IFCSPACE', 'IFCOPENINGELEMENT', 'IFCSITE', 'IFCBUILDING', 'IFCBUILDINGSTOREY',
+            'IFCPROJECT', 'IFCCOVERING', 'IFCANNOTATION', 'IFCGRID',
+        ]);
+        let processed = 0;
+        let added = 0;
+        for (const ref of entityRefs) {
+            const typeUpper = ref.type.toUpperCase();
+            // Skip non-relevant entities (geometric primitives, etc.)
+            const hasGeometry = GEOMETRY_TYPES.has(typeUpper);
+            const isType = typeUpper.endsWith('TYPE');
+            const isSpatial = SPATIAL_TYPES.has(typeUpper);
+            const isRelevant = hasGeometry || isType || isSpatial ||
+                RELEVANT_ENTITY_PREFIXES.has(typeUpper) ||
+                typeUpper.startsWith('IFCREL') || // Keep relationships for hierarchy
+                onDemandPropertyMap.has(ref.expressId) || // Keep entities with properties
+                onDemandQuantityMap.has(ref.expressId); // Keep entities with quantities
+            if (!isRelevant) {
+                processed++;
+                continue;
             }
-        }
-        const quantityTable = quantityTableBuilder.build();
-        options.onProgress?.({ phase: 'quantities', percent: 100 });
-        // === Build Relationship Graph ===
-        options.onProgress?.({ phase: 'relationships', percent: 0 });
-        const relTypeMap = {
-            'IFCRELCONTAINEDINSPATIALSTRUCTURE': RelationshipType.ContainsElements,
-            'IFCRELAGGREGATES': RelationshipType.Aggregates,
-            'IFCRELDEFINESBYPROPERTIES': RelationshipType.DefinesByProperties,
-            'IFCRELDEFINESBYTYPE': RelationshipType.DefinesByType,
-            'IFCRELASSOCIATESMATERIAL': RelationshipType.AssociatesMaterial,
-            'IFCRELASSOCIATESCLASSIFICATION': RelationshipType.AssociatesClassification,
-            'IFCRELVOIDSELEMENT': RelationshipType.VoidsElement,
-            'IFCRELFILLSELEMENT': RelationshipType.FillsElement,
-            'IFCRELCONNECTSPATHELEMENTS': RelationshipType.ConnectsPathElements,
-            'IFCRELSPACEBOUNDARY': RelationshipType.SpaceBoundary,
-        };
-        for (const rel of relationships) {
-            const relType = relTypeMap[rel.type.toUpperCase()];
-            if (relType) {
-                for (const targetId of rel.relatedObjects) {
-                    relationshipGraphBuilder.addEdge(rel.relatingObject, targetId, relType, rel.relatingObject);
-                }
+            // Get parsed data for spatial entities
+            const spatialData = parsedSpatialData.get(ref.expressId);
+            const globalId = spatialData?.globalId || '';
+            const name = spatialData?.name || '';
+            entityTableBuilder.add(ref.expressId, ref.type, globalId, name, '', // description
+            '', // objectType
+            hasGeometry, isType);
+            added++;
+            processed++;
+            // Yield every 10000 entities for better interleaving with geometry streaming
+            if (processed % 10000 === 0) {
+                options.onProgress?.({ phase: 'building entities', percent: 30 + (processed / totalEntities) * 50 });
+                // Direct yield - don't use maybeYield since we're already throttling
+                await new Promise(resolve => setTimeout(resolve, 0));
             }
         }
+        console.log(`[ColumnarParser] Added ${added} relevant entities (skipped ${totalEntities - added} primitives)`);
+        const entityTable = entityTableBuilder.build();
+        // Empty property/quantity tables - use on-demand extraction instead
+        const propertyTable = propertyTableBuilder.build();
+        const quantityTable = quantityTableBuilder.build();
         const relationshipGraph = relationshipGraphBuilder.build();
-        options.onProgress?.({ phase: 'relationships', percent: 100 });
-        // Detect schema version (simplified)
-        let schemaVersion = 'IFC4';
-        for (const [, entity] of entities) {
-            if (entity.type.toUpperCase() === 'IFCPROJECT') {
-                // Check schema version from header or entity
-                schemaVersion = 'IFC4';
-                break;
-            }
-        }
-        const parseTime = performance.now() - startTime;
-        // Build entity index
-        const entityIndex = {
-            byId: new Map(),
-            byType: new Map(),
-        };
-        for (const ref of entityRefs) {
-            entityIndex.byId.set(ref.expressId, ref);
-            let typeList = entityIndex.byType.get(ref.type);
-            if (!typeList) {
-                typeList = [];
-                entityIndex.byType.set(ref.type, typeList);
-            }
-            typeList.push(ref.expressId);
-        }
-        // === Build Spatial Hierarchy ===
-        options.onProgress?.({ phase: 'spatial-hierarchy', percent: 0 });
+        // === EXTRACT LENGTH UNIT SCALE ===
+        options.onProgress?.({ phase: 'extracting units', percent: 85 });
+        const lengthUnitScale = extractLengthUnitScale(uint8Buffer, entityIndex);
+        console.log(`[ColumnarParser] Length unit scale: ${lengthUnitScale}`);
+        // === BUILD SPATIAL HIERARCHY ===
+        options.onProgress?.({ phase: 'building hierarchy', percent: 90 });
         let spatialHierarchy;
         try {
             const hierarchyBuilder = new SpatialHierarchyBuilder();
-            spatialHierarchy = hierarchyBuilder.build(entityTable, relationshipGraph, strings, uint8Buffer, entityIndex);
+            spatialHierarchy = hierarchyBuilder.build(entityTable, relationshipGraph, strings, uint8Buffer, entityIndex, lengthUnitScale);
+            console.log(`[ColumnarParser] Built spatial hierarchy with ${spatialHierarchy.byStorey.size} storeys`);
         }
         catch (error) {
             console.warn('[ColumnarParser] Failed to build spatial hierarchy:', error);
-            // Continue without hierarchy - it's optional
         }
-        options.onProgress?.({ phase: 'spatial-hierarchy', percent: 100 });
+        const parseTime = performance.now() - startTime;
+        console.log(`[ColumnarParser] Parsed ${totalEntities} entities in ${parseTime.toFixed(0)}ms`);
+        options.onProgress?.({ phase: 'complete', percent: 100 });
         return {
             fileSize: buffer.byteLength,
-            schemaVersion,
-            entityCount: entities.size,
+            schemaVersion: 'IFC4',
+            entityCount: totalEntities,
             parseTime,
             source: uint8Buffer,
             entityIndex,
@@ -220,7 +300,194 @@ export class ColumnarParser {
             quantities: quantityTable,
             relationships: relationshipGraph,
             spatialHierarchy,
+            onDemandPropertyMap, // For instant property access
+            onDemandQuantityMap, // For instant quantity access
         };
     }
+    /**
+     * Fast relationship extraction - inline for performance
+     */
+    extractRelationshipFast(entity, typeUpper) {
+        const attrs = entity.attributes;
+        if (attrs.length < 6)
+            return null;
+        let relatingObject;
+        let relatedObjects;
+        if (typeUpper === 'IFCRELDEFINESBYPROPERTIES' || typeUpper === 'IFCRELCONTAINEDINSPATIALSTRUCTURE') {
+            relatedObjects = attrs[4];
+            relatingObject = attrs[5];
+        }
+        else {
+            relatingObject = attrs[4];
+            relatedObjects = attrs[5];
+        }
+        if (typeof relatingObject !== 'number' || !Array.isArray(relatedObjects)) {
+            return null;
+        }
+        return {
+            type: entity.type,
+            relatingObject,
+            relatedObjects: relatedObjects.filter((id) => typeof id === 'number'),
+        };
+    }
+    /**
+     * Extract properties for a single entity ON-DEMAND
+     * Parses only what's needed from the source buffer - instant results.
+     */
+    extractPropertiesOnDemand(store, entityId) {
+        // Use on-demand extraction if map is available (preferred for single-entity access)
+        if (!store.onDemandPropertyMap) {
+            // Fallback to pre-computed property table (e.g., server-parsed data)
+            return store.properties.getForEntity(entityId);
+        }
+        const psetIds = store.onDemandPropertyMap.get(entityId);
+        if (!psetIds || psetIds.length === 0) {
+            return [];
+        }
+        const extractor = new EntityExtractor(store.source);
+        const result = [];
+        for (const psetId of psetIds) {
+            const psetRef = store.entityIndex.byId.get(psetId);
+            if (!psetRef)
+                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;
+                    // 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 });
+                }
+            }
+            if (properties.length > 0 || psetName) {
+                result.push({ name: psetName, globalId: psetGlobalId, properties });
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract quantities for a single entity ON-DEMAND
+     * Parses only what's needed from the source buffer - instant results.
+     */
+    extractQuantitiesOnDemand(store, entityId) {
+        // Use on-demand extraction if map is available (preferred for single-entity access)
+        if (!store.onDemandQuantityMap) {
+            // Fallback to pre-computed quantity table (e.g., server-parsed data)
+            return store.quantities.getForEntity(entityId);
+        }
+        const qsetIds = store.onDemandQuantityMap.get(entityId);
+        if (!qsetIds || qsetIds.length === 0) {
+            return [];
+        }
+        const extractor = new EntityExtractor(store.source);
+        const result = [];
+        for (const qsetId of qsetIds) {
+            const qsetRef = store.entityIndex.byId.get(qsetId);
+            if (!qsetRef)
+                continue;
+            const qsetEntity = extractor.extractEntity(qsetRef);
+            if (!qsetEntity)
+                continue;
+            const qsetAttrs = qsetEntity.attributes || [];
+            const qsetName = typeof qsetAttrs[2] === 'string' ? qsetAttrs[2] : `QuantitySet #${qsetId}`;
+            const hasQuantities = qsetAttrs[5];
+            const quantities = [];
+            if (Array.isArray(hasQuantities)) {
+                for (const qtyRef of hasQuantities) {
+                    if (typeof qtyRef !== 'number')
+                        continue;
+                    const qtyEntityRef = store.entityIndex.byId.get(qtyRef);
+                    if (!qtyEntityRef)
+                        continue;
+                    const qtyEntity = extractor.extractEntity(qtyEntityRef);
+                    if (!qtyEntity)
+                        continue;
+                    const qtyAttrs = qtyEntity.attributes || [];
+                    const qtyName = typeof qtyAttrs[0] === 'string' ? qtyAttrs[0] : '';
+                    if (!qtyName)
+                        continue;
+                    // Get quantity type from entity type
+                    const qtyTypeUpper = qtyEntity.type.toUpperCase();
+                    const qtyType = QUANTITY_TYPE_MAP[qtyTypeUpper] ?? QuantityType.Count;
+                    // Value is at index 3 for most quantity types
+                    const value = typeof qtyAttrs[3] === 'number' ? qtyAttrs[3] : 0;
+                    quantities.push({ name: qtyName, type: qtyType, value });
+                }
+            }
+            if (quantities.length > 0 || qsetName) {
+                result.push({ name: qsetName, quantities });
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Standalone on-demand property extractor
+ * Can be used outside ColumnarParser class
+ */
+export function extractPropertiesOnDemand(store, entityId) {
+    const parser = new ColumnarParser();
+    return parser.extractPropertiesOnDemand(store, entityId);
+}
+/**
+ * Standalone on-demand quantity extractor
+ * Can be used outside ColumnarParser class
+ */
+export function extractQuantitiesOnDemand(store, entityId) {
+    const parser = new ColumnarParser();
+    return parser.extractQuantitiesOnDemand(store, entityId);
+}
+/**
+ * Extract entity attributes on-demand from source buffer
+ * Returns globalId, name, description, objectType 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: '' };
+    }
+    const extractor = new EntityExtractor(store.source);
+    const entity = extractor.extractEntity(ref);
+    if (!entity) {
+        return { globalId: '', name: '', description: '', objectType: '' };
+    }
+    const attrs = entity.attributes || [];
+    // IfcRoot attributes: [GlobalId, OwnerHistory, Name, Description]
+    // IfcObject adds: [ObjectType] at index 4
+    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 };
 }
 //# sourceMappingURL=columnar-parser.js.map