@ifc-lite/parser 2.1.1 → 2.1.3

package/dist/columnar-parser.js

@@ -62,10 +62,16 @@ const QUANTITY_TYPE_MAP = {
 const SPATIAL_TYPES = new Set([
     'IFCPROJECT', 'IFCSITE', 'IFCBUILDING', 'IFCBUILDINGSTOREY', 'IFCSPACE',
 ]);
-// Relationship types needed for hierarchy
+// Relationship types needed for hierarchy and structural relationships
 const HIERARCHY_REL_TYPES = new Set([
     'IFCRELAGGREGATES', 'IFCRELCONTAINEDINSPATIALSTRUCTURE',
     'IFCRELDEFINESBYTYPE',
+    // Structural relationships (voids, fills, connections, groups)
+    'IFCRELVOIDSELEMENT', 'IFCRELFILLSELEMENT',
+    'IFCRELCONNECTSPATHELEMENTS', 'IFCRELCONNECTSELEMENTS',
+    'IFCRELSPACEBOUNDARY',
+    'IFCRELASSIGNSTOGROUP', 'IFCRELASSIGNSTOPRODUCT',
+    'IFCRELREFERENCEDINSPATIALSTRUCTURE',
 ]);
 // Relationship types for on-demand property loading
 const PROPERTY_REL_TYPES = new Set([
@@ -90,10 +96,303 @@ const PROPERTY_ENTITY_TYPES = new Set([
 function isIfcTypeLikeEntity(typeUpper) {
     return typeUpper.endsWith('TYPE') || typeUpper.endsWith('STYLE');
 }
+// ==========================================
+// Byte-level helpers for fast extraction
+// These avoid per-entity TextDecoder calls by working on raw bytes.
+// ==========================================
 /**
- * Detect the IFC schema version from the STEP FILE_SCHEMA header.
- * Scans the first 2000 bytes for FILE_SCHEMA(('IFC2X3')), FILE_SCHEMA(('IFC4')), etc.
+ * Find the byte range of a quoted string at a specific attribute position in STEP entity bytes.
+ * Returns [start, end) byte offsets (excluding quotes), or null if not found.
+ *
+ * @param buffer - The IFC file buffer
+ * @param entityStart - byte offset of the entity
+ * @param entityLen - byte length of the entity
+ * @param attrIndex - 0-based attribute index (0=GlobalId, 2=Name)
  */
+function findQuotedAttrRange(buffer, entityStart, entityLen, attrIndex) {
+    const end = entityStart + entityLen;
+    let pos = entityStart;
+    // Skip to opening paren '(' after TYPE name
+    while (pos < end && buffer[pos] !== 0x28 /* ( */)
+        pos++;
+    if (pos >= end)
+        return null;
+    pos++; // skip '('
+    // Skip commas to reach the target attribute
+    if (attrIndex > 0) {
+        let toSkip = attrIndex;
+        let depth = 0;
+        let inStr = false;
+        while (pos < end && toSkip > 0) {
+            const ch = buffer[pos];
+            if (ch === 0x27 /* ' */) {
+                if (inStr && pos + 1 < end && buffer[pos + 1] === 0x27) {
+                    pos += 2;
+                    continue;
+                }
+                inStr = !inStr;
+            }
+            else if (!inStr) {
+                if (ch === 0x28)
+                    depth++;
+                else if (ch === 0x29)
+                    depth--;
+                else if (ch === 0x2C && depth === 0)
+                    toSkip--;
+            }
+            pos++;
+        }
+    }
+    // Skip whitespace
+    while (pos < end && (buffer[pos] === 0x20 || buffer[pos] === 0x09))
+        pos++;
+    // Check for quoted string
+    if (pos >= end || buffer[pos] !== 0x27 /* ' */)
+        return null;
+    pos++; // skip opening quote
+    const start = pos;
+    // Find closing quote (handle escaped quotes '')
+    while (pos < end) {
+        if (buffer[pos] === 0x27) {
+            if (pos + 1 < end && buffer[pos + 1] === 0x27) {
+                pos += 2;
+                continue;
+            }
+            break;
+        }
+        pos++;
+    }
+    return [start, pos];
+}
+/**
+ * Batch extract GlobalId (attr[0]) and Name (attr[2]) for many entities using
+ * only 2 TextDecoder.decode() calls total (one for all GlobalIds, one for all Names).
+ *
+ * This is ~100x faster than calling extractEntity() per entity for large batches
+ * because it eliminates per-entity TextDecoder overhead which is significant in Firefox.
+ *
+ * Returns a Map from expressId → { globalId, name }.
+ */
+function batchExtractGlobalIdAndName(buffer, refs) {
+    const result = new Map();
+    if (refs.length === 0)
+        return result;
+    // Phase 1: Scan byte ranges for GlobalId and Name positions (no string allocation)
+    const gidRanges = []; // [start, end) for each entity
+    const nameRanges = [];
+    const validIndices = []; // indices into refs for entities with valid ranges
+    for (let i = 0; i < refs.length; i++) {
+        const ref = refs[i];
+        const gidRange = findQuotedAttrRange(buffer, ref.byteOffset, ref.byteLength, 0);
+        const nameRange = findQuotedAttrRange(buffer, ref.byteOffset, ref.byteLength, 2);
+        gidRanges.push(gidRange ?? [0, 0]);
+        nameRanges.push(nameRange ?? [0, 0]);
+        validIndices.push(i);
+    }
+    // Phase 2: Concatenate all GlobalId bytes into one buffer, decode once
+    // Use null byte (0x00) as separator (never appears in IFC string content)
+    let totalGidBytes = 0;
+    let totalNameBytes = 0;
+    for (let i = 0; i < validIndices.length; i++) {
+        const [gs, ge] = gidRanges[i];
+        const [ns, ne] = nameRanges[i];
+        totalGidBytes += (ge - gs) + 1; // +1 for separator
+        totalNameBytes += (ne - ns) + 1;
+    }
+    const gidBuf = new Uint8Array(totalGidBytes);
+    const nameBuf = new Uint8Array(totalNameBytes);
+    let gidOffset = 0;
+    let nameOffset = 0;
+    for (let i = 0; i < validIndices.length; i++) {
+        const [gs, ge] = gidRanges[i];
+        const [ns, ne] = nameRanges[i];
+        if (ge > gs) {
+            gidBuf.set(buffer.subarray(gs, ge), gidOffset);
+            gidOffset += ge - gs;
+        }
+        gidBuf[gidOffset++] = 0; // null separator
+        if (ne > ns) {
+            nameBuf.set(buffer.subarray(ns, ne), nameOffset);
+            nameOffset += ne - ns;
+        }
+        nameBuf[nameOffset++] = 0;
+    }
+    // Phase 3: Two TextDecoder calls for ALL entities
+    const decoder = new TextDecoder();
+    const allGids = decoder.decode(gidBuf.subarray(0, gidOffset));
+    const allNames = decoder.decode(nameBuf.subarray(0, nameOffset));
+    const gids = allGids.split('\0');
+    const names = allNames.split('\0');
+    // Phase 4: Build result map
+    for (let i = 0; i < validIndices.length; i++) {
+        const ref = refs[validIndices[i]];
+        result.set(ref.expressId, {
+            globalId: gids[i] || '',
+            name: names[i] || '',
+        });
+    }
+    return result;
+}
+// ==========================================
+// Byte-level relationship scanners (numbers only, no TextDecoder)
+// ==========================================
+/**
+ * Skip N commas at depth 0 in STEP bytes.
+ */
+function skipCommas(buffer, start, end, count) {
+    let pos = start;
+    let remaining = count;
+    let depth = 0;
+    let inString = false;
+    while (pos < end && remaining > 0) {
+        const ch = buffer[pos];
+        if (ch === 0x27) {
+            if (inString && pos + 1 < end && buffer[pos + 1] === 0x27) {
+                pos += 2;
+                continue;
+            }
+            inString = !inString;
+        }
+        else if (!inString) {
+            if (ch === 0x28)
+                depth++;
+            else if (ch === 0x29)
+                depth--;
+            else if (ch === 0x2C && depth === 0)
+                remaining--;
+        }
+        pos++;
+    }
+    return pos;
+}
+/** Read a #ID entity reference as a number. Returns -1 if not an entity ref. */
+function readRefId(buffer, pos, end) {
+    while (pos < end && (buffer[pos] === 0x20 || buffer[pos] === 0x09))
+        pos++;
+    if (pos < end && buffer[pos] === 0x23) {
+        pos++;
+        let num = 0;
+        while (pos < end && buffer[pos] >= 0x30 && buffer[pos] <= 0x39) {
+            num = num * 10 + (buffer[pos] - 0x30);
+            pos++;
+        }
+        return [num, pos];
+    }
+    return [-1, pos];
+}
+/** Read a list of entity refs (#id1,#id2,...) or a single #id. Returns [ids, newPos]. */
+function readRefList(buffer, pos, end) {
+    while (pos < end && (buffer[pos] === 0x20 || buffer[pos] === 0x09))
+        pos++;
+    const ids = [];
+    if (pos < end && buffer[pos] === 0x28) {
+        pos++;
+        while (pos < end && buffer[pos] !== 0x29) {
+            while (pos < end && (buffer[pos] === 0x20 || buffer[pos] === 0x09 || buffer[pos] === 0x2C))
+                pos++;
+            if (pos < end && buffer[pos] === 0x23) {
+                const [id, np] = readRefId(buffer, pos, end);
+                if (id >= 0)
+                    ids.push(id);
+                pos = np;
+            }
+            else if (pos < end && buffer[pos] !== 0x29) {
+                pos++;
+            }
+        }
+    }
+    else if (pos < end && buffer[pos] === 0x23) {
+        const [id, np] = readRefId(buffer, pos, end);
+        if (id >= 0)
+            ids.push(id);
+        pos = np;
+    }
+    return [ids, pos];
+}
+/**
+ * Extract relatingObject and relatedObjects from a relationship entity using byte-level scanning.
+ * No TextDecoder needed - only extracts numeric entity IDs.
+ */
+function extractRelFast(buffer, byteOffset, byteLength, typeUpper) {
+    const end = byteOffset + byteLength;
+    let pos = byteOffset;
+    while (pos < end && buffer[pos] !== 0x28)
+        pos++;
+    if (pos >= end)
+        return null;
+    pos++;
+    // Skip to attr[4] (all IfcRelationship subtypes have 4 shared IfcRoot+IfcRelationship attrs)
+    pos = skipCommas(buffer, pos, end, 4);
+    if (typeUpper === 'IFCRELCONTAINEDINSPATIALSTRUCTURE'
+        || typeUpper === 'IFCRELREFERENCEDINSPATIALSTRUCTURE'
+        || typeUpper === 'IFCRELDEFINESBYPROPERTIES'
+        || typeUpper === 'IFCRELDEFINESBYTYPE') {
+        // attr[4]=RelatedObjects, attr[5]=RelatingObject
+        const [related, rp] = readRefList(buffer, pos, end);
+        pos = rp;
+        while (pos < end && buffer[pos] !== 0x2C)
+            pos++;
+        pos++;
+        const [relating, _] = readRefId(buffer, pos, end);
+        if (relating < 0 || related.length === 0)
+            return null;
+        return { relatingObject: relating, relatedObjects: related };
+    }
+    else if (typeUpper === 'IFCRELASSIGNSTOGROUP' || typeUpper === 'IFCRELASSIGNSTOPRODUCT') {
+        const [related, rp] = readRefList(buffer, pos, end);
+        pos = skipCommas(buffer, rp, end, 2);
+        const [relating, _] = readRefId(buffer, pos, end);
+        if (relating < 0 || related.length === 0)
+            return null;
+        return { relatingObject: relating, relatedObjects: related };
+    }
+    else if (typeUpper === 'IFCRELCONNECTSELEMENTS' || typeUpper === 'IFCRELCONNECTSPATHELEMENTS') {
+        pos = skipCommas(buffer, pos, end, 1);
+        const [relating, rp2] = readRefId(buffer, pos, end);
+        pos = skipCommas(buffer, rp2, end, 1);
+        const [related, _] = readRefId(buffer, pos, end);
+        if (relating < 0 || related < 0)
+            return null;
+        return { relatingObject: relating, relatedObjects: [related] };
+    }
+    else {
+        // Default: attr[4]=RelatingObject, attr[5]=RelatedObject(s)
+        const [relating, rp] = readRefId(buffer, pos, end);
+        if (relating < 0)
+            return null;
+        pos = rp;
+        while (pos < end && buffer[pos] !== 0x2C)
+            pos++;
+        pos++;
+        const [related, _] = readRefList(buffer, pos, end);
+        if (related.length === 0)
+            return null;
+        return { relatingObject: relating, relatedObjects: related };
+    }
+}
+/**
+ * Extract property rel data: attr[4]=relatedObjects, attr[5]=relatingDef.
+ * Numbers only, no TextDecoder.
+ */
+function extractPropertyRelFast(buffer, byteOffset, byteLength) {
+    const end = byteOffset + byteLength;
+    let pos = byteOffset;
+    while (pos < end && buffer[pos] !== 0x28)
+        pos++;
+    if (pos >= end)
+        return null;
+    pos++;
+    pos = skipCommas(buffer, pos, end, 4);
+    const [relatedObjects, rp] = readRefList(buffer, pos, end);
+    pos = rp;
+    while (pos < end && buffer[pos] !== 0x2C)
+        pos++;
+    pos++;
+    const [relatingDef, _] = readRefId(buffer, pos, end);
+    if (relatingDef < 0 || relatedObjects.length === 0)
+        return null;
+    return { relatedObjects, relatingDef };
+}
 function detectSchemaVersion(buffer) {
     const headerEnd = Math.min(buffer.length, 2000);
     const headerText = new TextDecoder().decode(buffer.subarray(0, headerEnd)).toUpperCase();
@@ -119,32 +418,67 @@ export class ColumnarParser {
         const startTime = performance.now();
         const uint8Buffer = new Uint8Array(buffer);
         const totalEntities = entityRefs.length;
+        // Phase timing for performance telemetry
+        let phaseStart = startTime;
+        const logPhase = (name) => {
+            const now = performance.now();
+            console.log(`[parseLite] ${name}: ${Math.round(now - phaseStart)}ms`);
+            phaseStart = now;
+        };
         options.onProgress?.({ phase: 'building', percent: 0 });
         // Detect schema version from FILE_SCHEMA header
         const schemaVersion = detectSchemaVersion(uint8Buffer);
-        // Initialize builders
+        // Initialize builders (entity table capacity set after categorization below)
         const strings = new StringTable();
-        const entityTableBuilder = new EntityTableBuilder(totalEntities, strings);
         const propertyTableBuilder = new PropertyTableBuilder(strings);
         const quantityTableBuilder = new QuantityTableBuilder(strings);
         const relationshipGraphBuilder = new RelationshipGraphBuilder();
+        logPhase('init builders');
         // Build compact entity index (typed arrays instead of Map for ~3x memory reduction)
         const compactByIdIndex = buildCompactEntityIndex(entityRefs);
-        // Also build byType index (Map<string, number[]>)
+        logPhase('compact entity index');
+        // Single pass: build byType index AND categorize entities simultaneously.
+        // Uses a type-name cache to avoid calling .toUpperCase() on 4.4M refs
+        // (only ~776 unique type names in IFC4).
         const byType = new Map();
-        for (const ref of entityRefs) {
-            let typeList = byType.get(ref.type);
-            if (!typeList) {
-                typeList = [];
-                byType.set(ref.type, typeList);
-            }
-            typeList.push(ref.expressId);
+        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',
+        ]);
+        // Category constants for the lookup cache
+        const CAT_SKIP = 0, CAT_SPATIAL = 1, CAT_GEOMETRY = 2, CAT_HIERARCHY_REL = 3, CAT_PROPERTY_REL = 4, CAT_PROPERTY_ENTITY = 5, CAT_ASSOCIATION_REL = 6, CAT_TYPE_OBJECT = 7, CAT_RELEVANT = 8;
+        // Cache: type name → category (avoids 4.4M .toUpperCase() calls)
+        const typeCategoryCache = new Map();
+        function getCategory(type) {
+            let cat = typeCategoryCache.get(type);
+            if (cat !== undefined)
+                return cat;
+            const upper = type.toUpperCase();
+            if (SPATIAL_TYPES.has(upper))
+                cat = CAT_SPATIAL;
+            else if (GEOMETRY_TYPES.has(upper))
+                cat = CAT_GEOMETRY;
+            else if (HIERARCHY_REL_TYPES.has(upper))
+                cat = CAT_HIERARCHY_REL;
+            else if (PROPERTY_REL_TYPES.has(upper))
+                cat = CAT_PROPERTY_REL;
+            else if (PROPERTY_ENTITY_TYPES.has(upper))
+                cat = CAT_PROPERTY_ENTITY;
+            else if (ASSOCIATION_REL_TYPES.has(upper))
+                cat = CAT_ASSOCIATION_REL;
+            else if (isIfcTypeLikeEntity(upper))
+                cat = CAT_TYPE_OBJECT;
+            else if (RELEVANT_ENTITY_PREFIXES.has(upper) || upper.startsWith('IFCREL'))
+                cat = CAT_RELEVANT;
+            else
+                cat = CAT_SKIP;
+            typeCategoryCache.set(type, cat);
+            return cat;
         }
-        const entityIndex = {
-            byId: compactByIdIndex,
-            byType,
-        };
-        // First pass: collect spatial, geometry, relationship, property, and type refs for targeted parsing
         const spatialRefs = [];
         const geometryRefs = [];
         const relationshipRefs = [];
@@ -152,238 +486,142 @@ export class ColumnarParser {
         const propertyEntityRefs = [];
         const associationRelRefs = [];
         const typeObjectRefs = [];
+        const otherRelevantRefs = [];
         for (const ref of entityRefs) {
-            // Categorize refs for targeted parsing
-            const typeUpper = ref.type.toUpperCase();
-            if (SPATIAL_TYPES.has(typeUpper)) {
-                spatialRefs.push(ref);
+            // Build byType index
+            let typeList = byType.get(ref.type);
+            if (!typeList) {
+                typeList = [];
+                byType.set(ref.type, typeList);
             }
-            else if (GEOMETRY_TYPES.has(typeUpper)) {
+            typeList.push(ref.expressId);
+            // Categorize (cached — .toUpperCase() called once per unique type)
+            const cat = getCategory(ref.type);
+            if (cat === CAT_SPATIAL)
+                spatialRefs.push(ref);
+            else if (cat === CAT_GEOMETRY)
                 geometryRefs.push(ref);
-            }
-            else if (HIERARCHY_REL_TYPES.has(typeUpper)) {
+            else if (cat === CAT_HIERARCHY_REL)
                 relationshipRefs.push(ref);
-            }
-            else if (PROPERTY_REL_TYPES.has(typeUpper)) {
+            else if (cat === CAT_PROPERTY_REL)
                 propertyRelRefs.push(ref);
-            }
-            else if (PROPERTY_ENTITY_TYPES.has(typeUpper)) {
+            else if (cat === CAT_PROPERTY_ENTITY)
                 propertyEntityRefs.push(ref);
-            }
-            else if (ASSOCIATION_REL_TYPES.has(typeUpper)) {
+            else if (cat === CAT_ASSOCIATION_REL)
                 associationRelRefs.push(ref);
-            }
-            else if (isIfcTypeLikeEntity(typeUpper)) {
+            else if (cat === CAT_TYPE_OBJECT)
                 typeObjectRefs.push(ref);
-            }
+            else if (cat === CAT_RELEVANT)
+                otherRelevantRefs.push(ref);
         }
-        // === TARGETED PARSING: Parse spatial and geometry entities for GlobalIds ===
-        options.onProgress?.({ phase: 'parsing spatial', percent: 10 });
+        logPhase(`categorize ${totalEntities} → spatial:${spatialRefs.length} geom:${geometryRefs.length} rel:${relationshipRefs.length} propRel:${propertyRelRefs.length} assocRel:${associationRelRefs.length} type:${typeObjectRefs.length} other:${otherRelevantRefs.length}`);
+        // Create entity table builder with EXACT capacity (not totalEntities which
+        // includes millions of geometry-representation entities we don't store).
+        // For a 14M entity file, this reduces allocation from ~546MB to ~20MB.
+        const relevantCount = spatialRefs.length + geometryRefs.length + typeObjectRefs.length
+            + relationshipRefs.length + otherRelevantRefs.length;
+        const entityTableBuilder = new EntityTableBuilder(relevantCount, strings);
+        const entityIndex = {
+            byId: compactByIdIndex,
+            byType,
+        };
+        // Time-based yielding: yield to the main thread every ~80ms so geometry
+        // streaming callbacks can fire. This limits main-thread blocking to short
+        // bursts that don't starve geometry, while adding minimal overhead (~15 yields
+        // × ~1ms each ≈ 15ms total over the full parse).
+        const YIELD_INTERVAL_MS = 80;
+        let lastYieldTime = performance.now();
+        const yieldIfNeeded = async () => {
+            const now = performance.now();
+            if (now - lastYieldTime >= YIELD_INTERVAL_MS) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                lastYieldTime = performance.now();
+            }
+        };
+        // === TARGETED PARSING using batch byte-level extraction ===
+        // Uses 2 TextDecoder.decode() calls total for ALL entity GlobalIds/Names
+        // (instead of per-entity calls), and pure byte scanning for relationships.
+        options.onProgress?.({ phase: 'parsing entities', percent: 10 });
         const extractor = new EntityExtractor(uint8Buffer);
+        // Spatial entities: small count, use extractEntity for full accuracy
         const parsedEntityData = 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] : '';
-                parsedEntityData.set(ref.expressId, { globalId, name });
-            }
-            else {
-                console.warn(`[ColumnarParser] Failed to extract spatial entity #${ref.expressId} (${ref.type})`);
-            }
-        }
-        // Parse geometry entities for GlobalIds (needed for BCF component references)
-        // IFC entities with geometry have GlobalId at attribute[0] and Name at attribute[2]
-        options.onProgress?.({ phase: 'parsing geometry globalIds', percent: 12 });
-        for (const ref of geometryRefs) {
-            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] : '';
-                parsedEntityData.set(ref.expressId, { globalId, name });
-            }
-        }
-        // Parse type objects (IfcWallType, IfcDoorType, etc.) for GlobalId and Name
-        // Type objects derive from IfcRoot: attrs[0]=GlobalId, attrs[2]=Name
-        // Needed for IDS validation against type entities
-        for (const ref of typeObjectRefs) {
-            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] : '';
-                parsedEntityData.set(ref.expressId, { globalId, name });
+                parsedEntityData.set(ref.expressId, {
+                    globalId: typeof attrs[0] === 'string' ? attrs[0] : '',
+                    name: typeof attrs[2] === 'string' ? attrs[2] : '',
+                });
             }
         }
-        // Parse relationship entities (typically < 10k entities)
+        logPhase('spatial entities');
+        await yieldIfNeeded();
+        // Geometry + type object entities: batch extract GlobalId+Name with 2 TextDecoder calls
+        options.onProgress?.({ phase: 'parsing geometry names', percent: 12 });
+        const geomData = batchExtractGlobalIdAndName(uint8Buffer, geometryRefs);
+        for (const [id, data] of geomData)
+            parsedEntityData.set(id, data);
+        await yieldIfNeeded();
+        const typeData = batchExtractGlobalIdAndName(uint8Buffer, typeObjectRefs);
+        for (const [id, data] of typeData)
+            parsedEntityData.set(id, data);
+        logPhase('batch geom GlobalId+Name');
+        await yieldIfNeeded();
+        // Relationships: byte-level scanning (numbers only, no TextDecoder)
         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);
-                        }
-                    }
-                }
-            }
-        }
-        // === 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);
-                                }
-                            }
-                        }
-                    }
-                }
+        // Use a toUpperCase cache across relationship refs (same type name set)
+        const typeUpperCache = new Map();
+        const getTypeUpper = (type) => {
+            let u = typeUpperCache.get(type);
+            if (u === undefined) {
+                u = type.toUpperCase();
+                typeUpperCache.set(type, u);
             }
-        }
-        // === 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);
-                            }
-                        }
+            return u;
+        };
+        for (const ref of relationshipRefs) {
+            const typeUpper = getTypeUpper(ref.type);
+            const rel = extractRelFast(uint8Buffer, ref.byteOffset, ref.byteLength, typeUpper);
+            if (rel) {
+                const relType = REL_TYPE_MAP[typeUpper];
+                if (relType) {
+                    for (const targetId of rel.relatedObjects) {
+                        relationshipGraphBuilder.addEdge(rel.relatingObject, targetId, relType, ref.expressId);
                     }
                 }
             }
         }
-        // === BUILD ENTITY TABLE with spatial data included ===
+        logPhase('byte-level relationships');
+        // === BUILD ENTITY TABLE from categorized arrays ===
+        // Instead of iterating ALL 4.4M entityRefs, iterate only categorized arrays
+        // (~100K-200K total). This eliminates a 200-300ms loop over 4.4M items.
         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 = isIfcTypeLikeEntity(typeUpper);
-            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;
-            }
-            // Get parsed data (GlobalId, Name) for spatial and geometry entities
-            const entityData = parsedEntityData.get(ref.expressId);
-            const globalId = entityData?.globalId || '';
-            const name = entityData?.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));
+        // Helper to add entities with pre-parsed data
+        const addEntityBatch = (refs, hasGeometry, isType) => {
+            for (const ref of refs) {
+                const entityData = parsedEntityData.get(ref.expressId);
+                entityTableBuilder.add(ref.expressId, ref.type, entityData?.globalId || '', entityData?.name || '', '', // description
+                '', // objectType
+                hasGeometry, isType);
             }
-        }
+        };
+        addEntityBatch(spatialRefs, false, false);
+        addEntityBatch(geometryRefs, true, false);
+        addEntityBatch(typeObjectRefs, false, true);
+        addEntityBatch(relationshipRefs, false, false);
+        addEntityBatch(otherRelevantRefs, false, false);
+        logPhase('add entity batches');
         const entityTable = entityTableBuilder.build();
+        logPhase('entity table build()');
         // Empty property/quantity tables - use on-demand extraction instead
         const propertyTable = propertyTableBuilder.build();
         const quantityTable = quantityTableBuilder.build();
-        const relationshipGraph = relationshipGraphBuilder.build();
+        // Build intermediate relationship graph (spatial/hierarchy edges only).
+        // Property/association edges are added later; final graph is rebuilt at the end.
+        const hierarchyRelGraph = relationshipGraphBuilder.build();
+        logPhase('hierarchy rel graph build()');
+        await yieldIfNeeded();
         // === EXTRACT LENGTH UNIT SCALE ===
         options.onProgress?.({ phase: 'extracting units', percent: 85 });
         const lengthUnitScale = extractLengthUnitScale(uint8Buffer, entityIndex);
@@ -392,57 +630,134 @@ export class ColumnarParser {
         let spatialHierarchy;
         try {
             const hierarchyBuilder = new SpatialHierarchyBuilder();
-            spatialHierarchy = hierarchyBuilder.build(entityTable, relationshipGraph, strings, uint8Buffer, entityIndex, lengthUnitScale);
+            spatialHierarchy = hierarchyBuilder.build(entityTable, hierarchyRelGraph, strings, uint8Buffer, entityIndex, lengthUnitScale);
+            logPhase('spatial hierarchy');
         }
         catch (error) {
             console.warn('[ColumnarParser] Failed to build spatial hierarchy:', error);
         }
-        const parseTime = performance.now() - startTime;
-        options.onProgress?.({ phase: 'complete', percent: 100 });
-        return {
+        // === EMIT SPATIAL HIERARCHY EARLY ===
+        // The hierarchy panel can render immediately while property/association
+        // parsing continues. This lets the panel appear at the same time as
+        // geometry streaming completes.
+        const earlyStore = {
             fileSize: buffer.byteLength,
             schemaVersion,
             entityCount: totalEntities,
-            parseTime,
+            parseTime: performance.now() - startTime,
             source: uint8Buffer,
             entityIndex,
             strings,
             entities: entityTable,
             properties: propertyTable,
             quantities: quantityTable,
-            relationships: relationshipGraph,
+            relationships: hierarchyRelGraph,
             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
         };
-    }
-    /**
-     * 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 === 'IFCRELDEFINESBYTYPE' || typeUpper === 'IFCRELCONTAINEDINSPATIALSTRUCTURE') {
-            relatedObjects = attrs[4];
-            relatingObject = attrs[5];
+        options.onSpatialReady?.(earlyStore);
+        await yieldIfNeeded(); // Let geometry process after hierarchy emission
+        // === DEFERRED: Parse property and association relationships ===
+        // These are NOT needed for the spatial hierarchy panel.
+        options.onProgress?.({ phase: 'parsing property refs', percent: 92 });
+        const onDemandPropertyMap = new Map();
+        const onDemandQuantityMap = new Map();
+        // Pre-build Sets of property set / quantity set IDs from already-categorized refs.
+        // This replaces 252K binary searches on the 14M compact entity index with O(1) Set lookups.
+        const propertySetIds = new Set();
+        const quantitySetIds = new Set();
+        for (const ref of propertyEntityRefs) {
+            const tu = getTypeUpper(ref.type);
+            if (tu === 'IFCPROPERTYSET')
+                propertySetIds.add(ref.expressId);
+            else if (tu === 'IFCELEMENTQUANTITY')
+                quantitySetIds.add(ref.expressId);
         }
-        else {
-            relatingObject = attrs[4];
-            relatedObjects = attrs[5];
+        // Property rels: byte-level scanning + addEdge (now fast with SoA builder).
+        let totalPropRelObjects = 0;
+        for (let pi = 0; pi < propertyRelRefs.length; pi++) {
+            if ((pi & 0x3FF) === 0)
+                await yieldIfNeeded();
+            const ref = propertyRelRefs[pi];
+            const result = extractPropertyRelFast(uint8Buffer, ref.byteOffset, ref.byteLength);
+            if (result) {
+                const { relatedObjects, relatingDef } = result;
+                totalPropRelObjects += relatedObjects.length;
+                for (const objId of relatedObjects) {
+                    relationshipGraphBuilder.addEdge(relatingDef, objId, RelationshipType.DefinesByProperties, ref.expressId);
+                }
+                // Build on-demand property/quantity maps using pre-built Sets (O(1) vs binary search)
+                const isPropSet = propertySetIds.has(relatingDef);
+                const isQtySet = !isPropSet && quantitySetIds.has(relatingDef);
+                if (isPropSet || isQtySet) {
+                    const targetMap = isPropSet ? onDemandPropertyMap : onDemandQuantityMap;
+                    for (const objId of relatedObjects) {
+                        let list = targetMap.get(objId);
+                        if (!list) {
+                            list = [];
+                            targetMap.set(objId, list);
+                        }
+                        list.push(relatingDef);
+                    }
+                }
+            }
         }
-        if (typeof relatingObject !== 'number' || !Array.isArray(relatedObjects)) {
-            return null;
+        console.log(`[parseLite] propertyRels: ${propertyRelRefs.length} rels, ${totalPropRelObjects} total relatedObjects`);
+        await yieldIfNeeded();
+        // Association rels: byte-level scanning, no addEdge (same reasoning as property rels)
+        options.onProgress?.({ phase: 'parsing associations', percent: 95 });
+        const onDemandClassificationMap = new Map();
+        const onDemandMaterialMap = new Map();
+        const onDemandDocumentMap = new Map();
+        for (const ref of associationRelRefs) {
+            const result = extractPropertyRelFast(uint8Buffer, ref.byteOffset, ref.byteLength);
+            if (result) {
+                const { relatedObjects, relatingDef: relatingRef } = result;
+                const typeUpper = getTypeUpper(ref.type);
+                if (typeUpper === 'IFCRELASSOCIATESCLASSIFICATION') {
+                    for (const objId of relatedObjects) {
+                        let list = onDemandClassificationMap.get(objId);
+                        if (!list) {
+                            list = [];
+                            onDemandClassificationMap.set(objId, list);
+                        }
+                        list.push(relatingRef);
+                        relationshipGraphBuilder.addEdge(relatingRef, objId, RelationshipType.AssociatesClassification, ref.expressId);
+                    }
+                }
+                else if (typeUpper === 'IFCRELASSOCIATESMATERIAL') {
+                    for (const objId of relatedObjects) {
+                        onDemandMaterialMap.set(objId, relatingRef);
+                        relationshipGraphBuilder.addEdge(relatingRef, objId, RelationshipType.AssociatesMaterial, ref.expressId);
+                    }
+                }
+                else if (typeUpper === 'IFCRELASSOCIATESDOCUMENT') {
+                    for (const objId of relatedObjects) {
+                        let list = onDemandDocumentMap.get(objId);
+                        if (!list) {
+                            list = [];
+                            onDemandDocumentMap.set(objId, list);
+                        }
+                        list.push(relatingRef);
+                        relationshipGraphBuilder.addEdge(relatingRef, objId, RelationshipType.AssociatesDocument, ref.expressId);
+                    }
+                }
+            }
         }
+        logPhase('property+association rels');
+        // Rebuild relationship graph with ALL edges (hierarchy + property + association)
+        const fullRelationshipGraph = relationshipGraphBuilder.build();
+        logPhase('relationship graph build()');
+        const parseTime = performance.now() - startTime;
+        options.onProgress?.({ phase: 'complete', percent: 100 });
         return {
-            type: entity.type,
-            relatingObject,
-            relatedObjects: relatedObjects.filter((id) => typeof id === 'number'),
+            ...earlyStore,
+            parseTime,
+            relationships: fullRelationshipGraph,
+            onDemandPropertyMap,
+            onDemandQuantityMap,
+            onDemandClassificationMap,
+            onDemandMaterialMap,
+            onDemandDocumentMap,
         };
     }
     /**