@ifc-lite/geometry 1.16.2 → 1.16.4

package/dist/index.js

@@ -42,16 +42,32 @@ export function calculateDynamicBatchSize(batchNumber, initialBatchSize = 50, ma
         return maxBatchSize; // Full throughput earlier
     }
 }
+const MAX_NATIVE_STREAM_QUEUE_EVENTS = 8;
+const MAX_NATIVE_STREAM_QUEUE_MESHES = 32768;
+const MAX_NATIVE_STREAM_EVENTS_PER_TURN = 4;
+const MAX_NATIVE_STREAM_MESHES_PER_TURN = 8192;
+const MAX_NATIVE_STREAM_DRAIN_MS = 10;
+function yieldToEventLoop() {
+    const maybeScheduler = globalThis.scheduler;
+    if (typeof maybeScheduler?.yield === 'function') {
+        return maybeScheduler.yield();
+    }
+    return new Promise((resolve) => {
+        globalThis.setTimeout(resolve, 0);
+    });
+}
 export class GeometryProcessor {
+    static largeFileByteStreamingThreshold = 256 * 1024 * 1024;
     bridge = null;
     platformBridge = null;
     bufferBuilder;
     coordinateHandler;
     isNative = false;
+    lastNativeStats = null;
     constructor(options = {}) {
         this.bufferBuilder = new BufferBuilder();
         this.coordinateHandler = new CoordinateHandler();
-        this.isNative = isTauri();
+        this.isNative = options.preferNative !== false && isTauri();
         // Note: options accepted for API compatibility
         void options.quality;
         if (!this.isNative) {
@@ -88,9 +104,7 @@ export class GeometryProcessor {
         if (this.isNative && this.platformBridge) {
             // NATIVE PATH - Use Tauri commands
             console.time('[GeometryProcessor] native-processing');
-            const decoder = new TextDecoder();
-            const content = decoder.decode(buffer);
-            const result = await this.platformBridge.processGeometry(content);
+            const result = await this.platformBridge.processGeometry(buffer);
             meshes = result.meshes;
             console.timeEnd('[GeometryProcessor] native-processing');
         }
@@ -132,6 +146,30 @@ export class GeometryProcessor {
         };
         return result;
     }
+    /**
+     * Process IFC geometry directly from a filesystem path in native desktop
+     * hosts. This avoids copying IFC content through JS when the host already
+     * has the file path.
+     */
+    async processPath(path) {
+        if (!this.isNative) {
+            throw new Error('Path-based geometry processing is only available in native desktop builds');
+        }
+        if (!this.platformBridge) {
+            await this.init();
+        }
+        if (!this.platformBridge?.processGeometryPath) {
+            throw new Error('Native platform bridge does not support file-path geometry processing');
+        }
+        const result = await this.platformBridge.processGeometryPath(path);
+        const coordinateInfo = this.coordinateHandler.processMeshes(result.meshes);
+        return {
+            meshes: result.meshes,
+            totalTriangles: result.totalTriangles,
+            totalVertices: result.totalVertices,
+            coordinateInfo,
+        };
+    }
     /**
      * Collect meshes on main thread using IFC-Lite WASM
      */
@@ -147,6 +185,182 @@ export class GeometryProcessor {
         const buildingRotation = collector.getBuildingRotation();
         return { meshes, buildingRotation };
     }
+    getStreamingBatchSize(buffer, batchConfig) {
+        if (typeof batchConfig === 'number') {
+            return batchConfig;
+        }
+        const fileSizeMB = batchConfig.fileSizeMB
+            ? batchConfig.fileSizeMB
+            : buffer.length / (1024 * 1024);
+        return fileSizeMB < 10 ? 100
+            : fileSizeMB < 50 ? 200
+                : fileSizeMB < 100 ? 300
+                    : fileSizeMB < 300 ? 500
+                        : fileSizeMB < 500 ? 1500
+                            : 3000;
+    }
+    convertMeshCollectionToBatch(collection) {
+        const batch = [];
+        try {
+            for (let i = 0; i < collection.length; i++) {
+                const mesh = collection.get(i);
+                if (!mesh)
+                    continue;
+                try {
+                    batch.push({
+                        expressId: mesh.expressId,
+                        ifcType: mesh.ifcType,
+                        positions: mesh.positions,
+                        normals: mesh.normals,
+                        indices: mesh.indices,
+                        color: [mesh.color[0], mesh.color[1], mesh.color[2], mesh.color[3]],
+                    });
+                }
+                finally {
+                    mesh.free();
+                }
+            }
+        }
+        finally {
+            collection.free();
+        }
+        return batch;
+    }
+    withBuildingRotation(coordinateInfo, buildingRotation) {
+        return buildingRotation !== undefined
+            ? { ...coordinateInfo, buildingRotation }
+            : coordinateInfo;
+    }
+    convertInstancedCollectionToBatch(collection) {
+        const batch = [];
+        try {
+            for (let i = 0; i < collection.length; i++) {
+                const geometry = collection.get(i);
+                if (geometry) {
+                    batch.push(geometry);
+                }
+            }
+        }
+        finally {
+            collection.free();
+        }
+        return batch;
+    }
+    async *processStreamingBytes(buffer, batchConfig) {
+        if (!this.bridge) {
+            throw new Error('WASM bridge not initialized');
+        }
+        const api = this.bridge.getApi();
+        const prePass = api.buildPrePassOnce(buffer);
+        yield { type: 'model-open', modelID: 0 };
+        if (prePass.rtcOffset) {
+            yield {
+                type: 'rtcOffset',
+                rtcOffset: {
+                    x: prePass.rtcOffset[0] ?? 0,
+                    y: prePass.rtcOffset[1] ?? 0,
+                    z: prePass.rtcOffset[2] ?? 0,
+                },
+                hasRtc: Boolean(prePass.needsShift),
+            };
+        }
+        const buildingRotation = prePass.buildingRotation ?? undefined;
+        if (!prePass.jobs || prePass.totalJobs === 0) {
+            const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+            yield { type: 'complete', totalMeshes: 0, coordinateInfo };
+            return;
+        }
+        const batchSize = this.getStreamingBatchSize(buffer, batchConfig);
+        let totalMeshes = 0;
+        for (let startJob = 0; startJob < prePass.totalJobs; startJob += batchSize) {
+            const endJob = Math.min(startJob + batchSize, prePass.totalJobs);
+            const jobSlice = prePass.jobs.slice(startJob * 3, endJob * 3);
+            const collection = api.processGeometryBatch(buffer, jobSlice, prePass.unitScale, prePass.rtcOffset?.[0] ?? 0, prePass.rtcOffset?.[1] ?? 0, prePass.rtcOffset?.[2] ?? 0, prePass.needsShift, prePass.voidKeys, prePass.voidCounts, prePass.voidValues, prePass.styleIds, prePass.styleColors);
+            const batch = this.convertMeshCollectionToBatch(collection);
+            if (batch.length === 0) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                continue;
+            }
+            this.coordinateHandler.processMeshesIncremental(batch);
+            totalMeshes += batch.length;
+            const currentCoordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
+            const coordinateInfo = currentCoordinateInfo
+                ? this.withBuildingRotation(currentCoordinateInfo, buildingRotation)
+                : null;
+            yield {
+                type: 'batch',
+                meshes: batch,
+                totalSoFar: totalMeshes,
+                coordinateInfo: coordinateInfo || undefined,
+            };
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+        yield { type: 'complete', totalMeshes, coordinateInfo };
+    }
+    async *processInstancedStreamingBytes(buffer, batchSize) {
+        if (!this.bridge) {
+            throw new Error('WASM bridge not initialized');
+        }
+        const api = this.bridge.getApi();
+        const prePass = api.buildPrePassOnce(buffer);
+        const buildingRotation = prePass.buildingRotation ?? undefined;
+        yield { type: 'model-open', modelID: 0 };
+        if (!prePass.jobs || prePass.totalJobs === 0) {
+            const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+            yield { type: 'complete', totalGeometries: 0, totalInstances: 0, coordinateInfo };
+            return;
+        }
+        let totalGeometries = 0;
+        let totalInstances = 0;
+        for (let startJob = 0; startJob < prePass.totalJobs; startJob += batchSize) {
+            const endJob = Math.min(startJob + batchSize, prePass.totalJobs);
+            const jobSlice = prePass.jobs.slice(startJob * 3, endJob * 3);
+            const collection = api.processInstancedGeometryBatch(buffer, jobSlice, prePass.unitScale, prePass.rtcOffset?.[0] ?? 0, prePass.rtcOffset?.[1] ?? 0, prePass.rtcOffset?.[2] ?? 0, prePass.needsShift, prePass.styleIds, prePass.styleColors);
+            const batch = this.convertInstancedCollectionToBatch(collection);
+            if (batch.length === 0) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                continue;
+            }
+            const meshDataBatch = [];
+            for (const geom of batch) {
+                const positions = geom.positions;
+                const normals = geom.normals;
+                const indices = geom.indices;
+                if (geom.instance_count > 0) {
+                    const firstInstance = geom.get_instance(0);
+                    if (firstInstance) {
+                        const color = firstInstance.color;
+                        meshDataBatch.push({
+                            expressId: firstInstance.expressId,
+                            positions,
+                            normals,
+                            indices,
+                            color: [color[0], color[1], color[2], color[3]],
+                        });
+                    }
+                }
+            }
+            if (meshDataBatch.length > 0) {
+                this.coordinateHandler.processMeshesIncremental(meshDataBatch);
+            }
+            totalGeometries += batch.length;
+            totalInstances += batch.reduce((sum, geometry) => sum + geometry.instance_count, 0);
+            const currentCoordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
+            const coordinateInfo = currentCoordinateInfo
+                ? this.withBuildingRotation(currentCoordinateInfo, buildingRotation)
+                : null;
+            yield {
+                type: 'batch',
+                geometries: batch,
+                totalSoFar: totalGeometries,
+                coordinateInfo: coordinateInfo || undefined,
+            };
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+        yield { type: 'complete', totalGeometries, totalInstances, coordinateInfo };
+    }
     /**
      * Process IFC file with streaming output for progressive rendering
      * Uses native Rust in Tauri, WASM in browser
@@ -168,23 +382,75 @@ export class GeometryProcessor {
         this.coordinateHandler.reset();
         // Yield start event FIRST so UI can update before heavy processing
         yield { type: 'start', totalEstimate: buffer.length / 1000 };
-        // Yield to main thread before heavy decode operation
+        // Yield to main thread before heavy processing begins
         await new Promise(resolve => setTimeout(resolve, 0));
-        // Convert buffer to string (IFC files are text)
-        const decoder = new TextDecoder();
-        const content = decoder.decode(buffer);
-        yield { type: 'model-open', modelID: 0 };
         if (this.isNative && this.platformBridge) {
+            yield { type: 'model-open', modelID: 0 };
             // NATIVE PATH - Use Tauri streaming
             console.time('[GeometryProcessor] native-streaming');
-            // For native, we do a single batch for now (streaming via events is complex)
-            // TODO: Implement proper streaming with Tauri events
-            const result = await this.platformBridge.processGeometry(content);
-            const totalMeshes = result.meshes.length;
-            this.coordinateHandler.processMeshesIncremental(result.meshes);
+            const queuedEvents = [];
+            let resolvePending = null;
+            let completed = false;
+            let streamError = null;
+            let completedTotalMeshes;
+            let totalMeshes = 0;
+            const wake = () => {
+                if (resolvePending) {
+                    resolvePending();
+                    resolvePending = null;
+                }
+            };
+            const streamingPromise = this.platformBridge.processGeometryStreaming(buffer, {
+                onBatch: (batch) => {
+                    queuedEvents.push({ type: 'batch', meshes: batch.meshes, nativeTelemetry: batch.nativeTelemetry });
+                    wake();
+                },
+                onColorUpdate: (updates) => {
+                    queuedEvents.push({ type: 'colorUpdate', updates: new Map(updates) });
+                    wake();
+                },
+                onComplete: (stats) => {
+                    this.lastNativeStats = stats;
+                    completedTotalMeshes = stats.totalMeshes;
+                    completed = true;
+                    wake();
+                },
+                onError: (error) => {
+                    streamError = error;
+                    completed = true;
+                    wake();
+                },
+            });
+            while (!completed || queuedEvents.length > 0) {
+                while (queuedEvents.length > 0) {
+                    const event = queuedEvents.shift();
+                    if (event.type === 'colorUpdate') {
+                        yield { type: 'colorUpdate', updates: event.updates };
+                        continue;
+                    }
+                    this.coordinateHandler.processMeshesIncremental(event.meshes);
+                    totalMeshes += event.meshes.length;
+                    const coordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
+                    yield {
+                        type: 'batch',
+                        meshes: event.meshes,
+                        totalSoFar: totalMeshes,
+                        coordinateInfo: coordinateInfo || undefined,
+                        nativeTelemetry: event.nativeTelemetry,
+                    };
+                }
+                if (streamError) {
+                    throw streamError;
+                }
+                if (!completed) {
+                    await new Promise((resolve) => {
+                        resolvePending = resolve;
+                    });
+                }
+            }
+            await streamingPromise;
             const coordinateInfo = this.coordinateHandler.getFinalCoordinateInfo();
-            yield { type: 'batch', meshes: result.meshes, totalSoFar: totalMeshes, coordinateInfo: coordinateInfo || undefined };
-            yield { type: 'complete', totalMeshes, coordinateInfo };
+            yield { type: 'complete', totalMeshes: completedTotalMeshes ?? totalMeshes, coordinateInfo };
             console.timeEnd('[GeometryProcessor] native-streaming');
         }
         else {
@@ -192,19 +458,18 @@ export class GeometryProcessor {
             if (!this.bridge) {
                 throw new Error('WASM bridge not initialized');
             }
+            if (buffer.length >= GeometryProcessor.largeFileByteStreamingThreshold) {
+                yield* this.processStreamingBytes(buffer, batchConfig);
+                return;
+            }
+            // Convert buffer to string (IFC files are text)
+            const decoder = new TextDecoder();
+            const content = decoder.decode(buffer);
+            yield { type: 'model-open', modelID: 0 };
             const collector = new IfcLiteMeshCollector(this.bridge.getApi(), content);
             let totalMeshes = 0;
             let extractedBuildingRotation = undefined;
-            // Determine optimal WASM batch size based on file size
-            // Larger batches = fewer callbacks = faster processing
-            const fileSizeMB = typeof batchConfig !== 'number' && batchConfig.fileSizeMB
-                ? batchConfig.fileSizeMB
-                : buffer.length / (1024 * 1024);
-            // Use WASM batches directly - no JS accumulation layer
-            // WASM already prioritizes simple geometry (walls, slabs) for fast first frame
-            // PERF: Larger batches dramatically reduce WASM↔JS boundary crossing overhead.
-            // 487MB file: batch 500→1500 cut WASM wait from 79s to 39s.
-            const wasmBatchSize = fileSizeMB < 10 ? 100 : fileSizeMB < 50 ? 200 : fileSizeMB < 100 ? 300 : fileSizeMB < 300 ? 500 : fileSizeMB < 500 ? 1500 : 3000;
+            const wasmBatchSize = this.getStreamingBatchSize(buffer, batchConfig);
             // Use WASM batches directly for maximum throughput
             for await (const item of collector.collectMeshesStreaming(wasmBatchSize)) {
                 // Handle color update events
@@ -239,6 +504,34 @@ export class GeometryProcessor {
             yield { type: 'complete', totalMeshes, coordinateInfo: finalCoordinateInfo };
         }
     }
+    /**
+     * Stream geometry directly from a filesystem path in native desktop hosts.
+     * This avoids copying very large IFC files through JS and Tauri IPC.
+     */
+    async *processStreamingPath(path, estimatedBytes = 0, cacheKey) {
+        if (!this.isNative) {
+            throw new Error('File-path geometry streaming is only available in native desktop builds');
+        }
+        if (!this.platformBridge) {
+            await this.init();
+        }
+        if (!this.platformBridge?.processGeometryStreamingPath) {
+            throw new Error('Native platform bridge does not support file-path streaming');
+        }
+        yield* this.streamNativeGeometry((options) => this.platformBridge.processGeometryStreamingPath(path, options, cacheKey), estimatedBytes > 0 ? estimatedBytes / 1000 : 0);
+    }
+    async *processStreamingCache(cacheKey) {
+        if (!this.isNative) {
+            throw new Error('Native cached geometry streaming is only available in native desktop builds');
+        }
+        if (!this.platformBridge) {
+            await this.init();
+        }
+        if (!this.platformBridge?.processGeometryStreamingCache) {
+            throw new Error('Native platform bridge does not support cached geometry streaming');
+        }
+        yield* this.streamNativeGeometry((options) => this.platformBridge.processGeometryStreamingCache(cacheKey, options), 0);
+    }
     /**
      * Process IFC file with streaming instanced geometry output for progressive rendering
      * Groups identical geometries by hash (before transformation) for GPU instancing
@@ -261,6 +554,15 @@ export class GeometryProcessor {
         // Reset coordinate handler for new file
         this.coordinateHandler.reset();
         yield { type: 'start', totalEstimate: buffer.length / 1000 };
+        // Adapt batch size for large files to reduce callback overhead
+        // Larger batches = fewer callbacks = less overhead for huge models
+        const fileSizeMB = buffer.length / (1024 * 1024);
+        const effectiveBatchSize = fileSizeMB < 50 ? batchSize : fileSizeMB < 200 ? Math.max(batchSize, 50) : fileSizeMB < 300 ? Math.max(batchSize, 100) : Math.max(batchSize, 200);
+        const byteBatchSize = Math.max(effectiveBatchSize, this.getStreamingBatchSize(buffer, batchSize));
+        if (buffer.length >= GeometryProcessor.largeFileByteStreamingThreshold) {
+            yield* this.processInstancedStreamingBytes(buffer, byteBatchSize);
+            return;
+        }
         // Convert buffer to string (IFC files are text)
         const decoder = new TextDecoder();
         const content = decoder.decode(buffer);
@@ -269,10 +571,6 @@ export class GeometryProcessor {
         const collector = new IfcLiteMeshCollector(this.bridge.getApi(), content);
         let totalGeometries = 0;
         let totalInstances = 0;
-        // Adapt batch size for large files to reduce callback overhead
-        // Larger batches = fewer callbacks = less overhead for huge models
-        const fileSizeMB = buffer.length / (1024 * 1024);
-        const effectiveBatchSize = fileSizeMB < 50 ? batchSize : fileSizeMB < 200 ? Math.max(batchSize, 50) : fileSizeMB < 300 ? Math.max(batchSize, 100) : Math.max(batchSize, 200);
         for await (const batch of collector.collectInstancedGeometryStreaming(effectiveBatchSize)) {
             // For instanced geometry, we need to extract mesh data from instances for coordinate handling
             // Convert InstancedGeometry to MeshData[] for coordinate handler
@@ -526,20 +824,19 @@ export class GeometryProcessor {
         // Small files: Load all at once (sync)
         if (buffer.length < sizeThreshold) {
             yield { type: 'start', totalEstimate: buffer.length / 1000 };
-            // Convert buffer to string (IFC files are text)
-            const decoder = new TextDecoder();
-            const content = decoder.decode(buffer);
             yield { type: 'model-open', modelID: 0 };
             let allMeshes;
             if (this.isNative && this.platformBridge) {
                 // NATIVE PATH - single batch processing
                 console.time('[GeometryProcessor] native-adaptive-sync');
-                const result = await this.platformBridge.processGeometry(content);
+                const result = await this.platformBridge.processGeometry(buffer);
                 allMeshes = result.meshes;
                 console.timeEnd('[GeometryProcessor] native-adaptive-sync');
             }
             else {
                 // WASM PATH
+                const decoder = new TextDecoder();
+                const content = decoder.decode(buffer);
                 const collector = new IfcLiteMeshCollector(this.bridge.getApi(), content);
                 allMeshes = collector.collectMeshes();
             }
@@ -578,6 +875,128 @@ export class GeometryProcessor {
         }
         return this.bridge.getApi();
     }
+    getLastNativeStats() {
+        return this.lastNativeStats;
+    }
+    enqueueNativeStreamingEvent(queuedEvents, event, queueState) {
+        if (event.type === 'colorUpdate') {
+            const lastEvent = queuedEvents[queuedEvents.length - 1];
+            if (lastEvent?.type === 'colorUpdate') {
+                for (const [expressId, color] of event.updates) {
+                    lastEvent.updates.set(expressId, color);
+                }
+                return;
+            }
+            queuedEvents.push(event);
+            return;
+        }
+        const lastEvent = queuedEvents[queuedEvents.length - 1];
+        const shouldCoalesce = lastEvent?.type === 'batch' &&
+            (queuedEvents.length >= MAX_NATIVE_STREAM_QUEUE_EVENTS || queueState.queuedMeshes >= MAX_NATIVE_STREAM_QUEUE_MESHES);
+        if (shouldCoalesce) {
+            for (let i = 0; i < event.meshes.length; i++) {
+                lastEvent.meshes.push(event.meshes[i]);
+            }
+            lastEvent.nativeTelemetry = event.nativeTelemetry;
+            queueState.coalescedBatchCount += 1;
+        }
+        else {
+            queuedEvents.push(event);
+        }
+        queueState.queuedMeshes += event.meshes.length;
+    }
+    async *streamNativeGeometry(startStream, totalEstimate) {
+        this.coordinateHandler.reset();
+        yield { type: 'start', totalEstimate };
+        await yieldToEventLoop();
+        yield { type: 'model-open', modelID: 0 };
+        const queuedEvents = [];
+        const queueState = { queuedMeshes: 0, coalescedBatchCount: 0 };
+        let resolvePending = null;
+        let completed = false;
+        let streamError = null;
+        let completedTotalMeshes;
+        let totalMeshes = 0;
+        const wake = () => {
+            if (resolvePending) {
+                resolvePending();
+                resolvePending = null;
+            }
+        };
+        const streamingPromise = startStream({
+            onBatch: (batch) => {
+                this.enqueueNativeStreamingEvent(queuedEvents, { type: 'batch', meshes: batch.meshes, nativeTelemetry: batch.nativeTelemetry }, queueState);
+                wake();
+            },
+            onColorUpdate: (updates) => {
+                this.enqueueNativeStreamingEvent(queuedEvents, { type: 'colorUpdate', updates: new Map(updates) }, queueState);
+                wake();
+            },
+            onComplete: (stats) => {
+                this.lastNativeStats = stats;
+                completedTotalMeshes = stats.totalMeshes;
+                completed = true;
+                wake();
+            },
+            onError: (error) => {
+                streamError = error;
+                completed = true;
+                wake();
+            },
+        });
+        while (!completed || queuedEvents.length > 0) {
+            let drainedEventCount = 0;
+            let drainedMeshCount = 0;
+            let drainStartedAt = performance.now();
+            while (queuedEvents.length > 0) {
+                const event = queuedEvents.shift();
+                if (event.type === 'colorUpdate') {
+                    yield { type: 'colorUpdate', updates: event.updates };
+                    continue;
+                }
+                queueState.queuedMeshes = Math.max(0, queueState.queuedMeshes - event.meshes.length);
+                // Native desktop streaming already produces site-local geometry, so
+                // avoid the generic JS RTC/outlier scan on every streamed batch.
+                this.coordinateHandler.processTrustedMeshesIncremental(event.meshes);
+                totalMeshes += event.meshes.length;
+                const coordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
+                yield {
+                    type: 'batch',
+                    meshes: event.meshes,
+                    totalSoFar: totalMeshes,
+                    coordinateInfo: coordinateInfo || undefined,
+                    nativeTelemetry: event.nativeTelemetry,
+                };
+                drainedEventCount += 1;
+                drainedMeshCount += event.meshes.length;
+                if (queuedEvents.length > 0) {
+                    const shouldYield = drainedEventCount >= MAX_NATIVE_STREAM_EVENTS_PER_TURN ||
+                        drainedMeshCount >= MAX_NATIVE_STREAM_MESHES_PER_TURN ||
+                        performance.now() - drainStartedAt >= MAX_NATIVE_STREAM_DRAIN_MS;
+                    if (shouldYield) {
+                        await yieldToEventLoop();
+                        drainedEventCount = 0;
+                        drainedMeshCount = 0;
+                        drainStartedAt = performance.now();
+                    }
+                }
+            }
+            if (streamError) {
+                throw streamError;
+            }
+            if (!completed) {
+                await new Promise((resolve) => {
+                    resolvePending = resolve;
+                });
+            }
+        }
+        await streamingPromise;
+        if (queueState.coalescedBatchCount > 0) {
+            console.info(`[GeometryProcessor] Coalesced ${queueState.coalescedBatchCount} native batches while JS drained the queue`);
+        }
+        const coordinateInfo = this.coordinateHandler.getFinalCoordinateInfo();
+        yield { type: 'complete', totalMeshes: completedTotalMeshes ?? totalMeshes, coordinateInfo };
+    }
     /**
      * Parse symbolic representations (Plan, Annotation, FootPrint) from IFC content
      * These are pre-authored 2D curves for architectural drawings (door swings, window cuts, etc.)