@ifc-lite/geometry 1.16.4 → 1.16.6

package/dist/index.js

@@ -28,6 +28,10 @@ import { IfcLiteMeshCollector } from './ifc-lite-mesh-collector.js';
 import { BufferBuilder } from './buffer-builder.js';
 import { CoordinateHandler } from './coordinate-handler.js';
 import { createPlatformBridge, isTauri } from './platform-bridge.js';
+// Extracted sub-modules
+import { getStreamingBatchSize, convertMeshCollectionToBatch, convertInstancedCollectionToBatch, withBuildingRotation } from './geometry-coordinate.js';
+import { streamNativeGeometry } from './geometry-native.js';
+import { processParallel } from './geometry-parallel.js';
 /**
  * Calculate dynamic batch size based on batch number
  */
@@ -42,20 +46,8 @@ 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);
-    });
-}
+// QueuedNativeStreamingEvent, native stream constants, and yieldToEventLoop
+// have been extracted to ./geometry-native.ts
 export class GeometryProcessor {
     static largeFileByteStreamingThreshold = 256 * 1024 * 1024;
     bridge = null;
@@ -185,67 +177,9 @@ 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;
-    }
+    // getStreamingBatchSize, convertMeshCollectionToBatch,
+    // convertInstancedCollectionToBatch, and withBuildingRotation have been
+    // extracted to ./geometry-coordinate.ts and are used as free functions.
     async *processStreamingBytes(buffer, batchConfig) {
         if (!this.bridge) {
             throw new Error('WASM bridge not initialized');
@@ -266,17 +200,20 @@ export class GeometryProcessor {
         }
         const buildingRotation = prePass.buildingRotation ?? undefined;
         if (!prePass.jobs || prePass.totalJobs === 0) {
-            const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+            const coordinateInfo = withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
             yield { type: 'complete', totalMeshes: 0, coordinateInfo };
             return;
         }
-        const batchSize = this.getStreamingBatchSize(buffer, batchConfig);
+        const batchSize = getStreamingBatchSize(buffer, batchConfig);
+        // Cap at ~30 batches max to avoid excessive per-batch overhead
+        const maxBatches = 30;
+        const effectiveBatchSize = Math.max(batchSize, Math.ceil(prePass.totalJobs / maxBatches));
         let totalMeshes = 0;
-        for (let startJob = 0; startJob < prePass.totalJobs; startJob += batchSize) {
-            const endJob = Math.min(startJob + batchSize, prePass.totalJobs);
+        for (let startJob = 0; startJob < prePass.totalJobs; startJob += effectiveBatchSize) {
+            const endJob = Math.min(startJob + effectiveBatchSize, 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);
+            const batch = convertMeshCollectionToBatch(collection);
             if (batch.length === 0) {
                 await new Promise(resolve => setTimeout(resolve, 0));
                 continue;
@@ -285,7 +222,7 @@ export class GeometryProcessor {
             totalMeshes += batch.length;
             const currentCoordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
             const coordinateInfo = currentCoordinateInfo
-                ? this.withBuildingRotation(currentCoordinateInfo, buildingRotation)
+                ? withBuildingRotation(currentCoordinateInfo, buildingRotation)
                 : null;
             yield {
                 type: 'batch',
@@ -295,7 +232,8 @@ export class GeometryProcessor {
             };
             await new Promise(resolve => setTimeout(resolve, 0));
         }
-        const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+        api.clearPrePassCache?.();
+        const coordinateInfo = withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
         yield { type: 'complete', totalMeshes, coordinateInfo };
     }
     async *processInstancedStreamingBytes(buffer, batchSize) {
@@ -307,17 +245,20 @@ export class GeometryProcessor {
         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);
+            const coordinateInfo = 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);
+        // Cap at ~30 batches max to avoid excessive per-batch overhead
+        const maxBatches = 30;
+        const effectiveBatchSize = Math.max(batchSize, Math.ceil(prePass.totalJobs / maxBatches));
+        for (let startJob = 0; startJob < prePass.totalJobs; startJob += effectiveBatchSize) {
+            const endJob = Math.min(startJob + effectiveBatchSize, 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);
+            const batch = convertInstancedCollectionToBatch(collection);
             if (batch.length === 0) {
                 await new Promise(resolve => setTimeout(resolve, 0));
                 continue;
@@ -348,7 +289,7 @@ export class GeometryProcessor {
             totalInstances += batch.reduce((sum, geometry) => sum + geometry.instance_count, 0);
             const currentCoordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
             const coordinateInfo = currentCoordinateInfo
-                ? this.withBuildingRotation(currentCoordinateInfo, buildingRotation)
+                ? withBuildingRotation(currentCoordinateInfo, buildingRotation)
                 : null;
             yield {
                 type: 'batch',
@@ -358,7 +299,8 @@ export class GeometryProcessor {
             };
             await new Promise(resolve => setTimeout(resolve, 0));
         }
-        const coordinateInfo = this.withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
+        api.clearPrePassCache?.();
+        const coordinateInfo = withBuildingRotation(this.coordinateHandler.getFinalCoordinateInfo(), buildingRotation);
         yield { type: 'complete', totalGeometries, totalInstances, coordinateInfo };
     }
     /**
@@ -368,7 +310,11 @@ export class GeometryProcessor {
      * @param entityIndex Optional entity index for priority-based loading
      * @param batchConfig Dynamic batch configuration or fixed batch size
      */
-    async *processStreaming(buffer, _entityIndex, batchConfig = 25) {
+    async *processStreaming(buffer, _entityIndex, batchConfig = 25, 
+    // TODO: sharedRtcOffset is accepted but not yet threaded through to the
+    // WASM streaming collector. The WASM layer detects its own RTC offset
+    // per-model; federation-level override requires collector API changes.
+    sharedRtcOffset) {
         // Initialize if needed
         if (this.isNative) {
             if (!this.platformBridge) {
@@ -386,7 +332,7 @@ export class GeometryProcessor {
         await new Promise(resolve => setTimeout(resolve, 0));
         if (this.isNative && this.platformBridge) {
             yield { type: 'model-open', modelID: 0 };
-            // NATIVE PATH - Use Tauri streaming
+            // NATIVE PATH - Use Tauri streaming (simpler queue without coalescing)
             console.time('[GeometryProcessor] native-streaming');
             const queuedEvents = [];
             let resolvePending = null;
@@ -469,7 +415,7 @@ export class GeometryProcessor {
             const collector = new IfcLiteMeshCollector(this.bridge.getApi(), content);
             let totalMeshes = 0;
             let extractedBuildingRotation = undefined;
-            const wasmBatchSize = this.getStreamingBatchSize(buffer, batchConfig);
+            const wasmBatchSize = getStreamingBatchSize(buffer, batchConfig);
             // Use WASM batches directly for maximum throughput
             for await (const item of collector.collectMeshesStreaming(wasmBatchSize)) {
                 // Handle color update events
@@ -518,7 +464,7 @@ export class GeometryProcessor {
         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);
+        yield* streamNativeGeometry((options) => this.platformBridge.processGeometryStreamingPath(path, options, cacheKey), estimatedBytes > 0 ? estimatedBytes / 1000 : 0, this.coordinateHandler, (stats) => { this.lastNativeStats = stats; });
     }
     async *processStreamingCache(cacheKey) {
         if (!this.isNative) {
@@ -530,7 +476,7 @@ export class GeometryProcessor {
         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);
+        yield* streamNativeGeometry((options) => this.platformBridge.processGeometryStreamingCache(cacheKey, options), 0, this.coordinateHandler, (stats) => { this.lastNativeStats = stats; });
     }
     /**
      * Process IFC file with streaming instanced geometry output for progressive rendering
@@ -558,7 +504,7 @@ export class GeometryProcessor {
         // 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));
+        const byteBatchSize = Math.max(effectiveBatchSize, getStreamingBatchSize(buffer, batchSize));
         if (buffer.length >= GeometryProcessor.largeFileByteStreamingThreshold) {
             yield* this.processInstancedStreamingBytes(buffer, byteBatchSize);
             return;
@@ -621,181 +567,12 @@ export class GeometryProcessor {
      *
      * @param buffer IFC file buffer
      */
-    async *processParallel(buffer) {
+    async *processParallel(buffer, sharedRtcOffset) {
         // Initialize if needed
         if (!this.bridge?.isInitialized()) {
             await this.init();
         }
-        this.coordinateHandler.reset();
-        yield { type: 'start', totalEstimate: buffer.length / 1000 };
-        yield { type: 'model-open', modelID: 0 };
-        // Copy file bytes into SharedArrayBuffer for zero-copy sharing with workers
-        const sharedBuffer = new SharedArrayBuffer(buffer.byteLength);
-        new Uint8Array(sharedBuffer).set(buffer);
-        // ── PHASE 1: Full pre-pass in worker ──
-        const makeWorker = () => new Worker(new URL('./geometry.worker.js', import.meta.url), { type: 'module' });
-        const prePassResult = await new Promise((resolve, reject) => {
-            const w = makeWorker();
-            w.onmessage = (e) => {
-                if (e.data.type === 'prepass-result') {
-                    w.terminate();
-                    resolve(e.data.result);
-                }
-                else if (e.data.type === 'error') {
-                    w.terminate();
-                    reject(new Error(e.data.message));
-                }
-            };
-            w.onerror = (e) => { w.terminate(); reject(new Error(e.message)); };
-            w.postMessage({ type: 'prepass', sharedBuffer });
-        });
-        if (!prePassResult || !prePassResult.jobs || prePassResult.totalJobs === 0) {
-            const coordinateInfo = this.coordinateHandler.getFinalCoordinateInfo();
-            yield { type: 'complete', totalMeshes: 0, coordinateInfo };
-            return;
-        }
-        const { jobs: jobsFlat, totalJobs, unitScale, rtcOffset, needsShift, voidKeys, voidCounts, voidValues, styleIds, styleColors } = prePassResult;
-        const rtcX = rtcOffset?.[0] ?? 0;
-        const rtcY = rtcOffset?.[1] ?? 0;
-        const rtcZ = rtcOffset?.[2] ?? 0;
-        // ── PHASE 2: Dynamic worker provisioning based on device capability ──
-        const cores = typeof navigator !== 'undefined' ? (navigator.hardwareConcurrency ?? 2) : 2;
-        const deviceMemoryGB = typeof navigator !== 'undefined' ? (navigator.deviceMemory ?? 8) : 8;
-        const fileSizeGB = buffer.byteLength / (1024 * 1024 * 1024);
-        // Determine optimal workers:
-        // - Desktop (16+ cores, 16+ GB): up to 8 workers
-        // - Laptop (8 cores, 8 GB): 2-4 workers (avoid thermal throttling on fanless)
-        // - Low-end (4 cores, 4 GB): 1-2 workers
-        // - Large files need more memory per worker, so fewer workers
-        let maxWorkers;
-        if (cores >= 16 && deviceMemoryGB >= 16) {
-            maxWorkers = Math.min(8, Math.floor(cores / 2));
-        }
-        else if (cores >= 8 && deviceMemoryGB >= 8) {
-            // MacBook Air M-series: 8 cores but fanless → throttles with too many workers
-            // Use 3 workers: enough parallelism without severe throttling
-            maxWorkers = fileSizeGB > 0.5 ? 2 : 3;
-        }
-        else {
-            maxWorkers = Math.max(1, Math.min(2, Math.floor(cores / 2)));
-        }
-        const workerCount = Math.min(maxWorkers, totalJobs);
-        const jobsPerWorker = Math.ceil(totalJobs / workerCount);
-        const chunks = [];
-        for (let i = 0; i < workerCount; i++) {
-            const start = i * jobsPerWorker;
-            const end = Math.min(start + jobsPerWorker, totalJobs);
-            if (start < end)
-                chunks.push([start, end]);
-        }
-        // Queue-based async generator: workers push batches, generator yields them
-        const batchQueue = [];
-        let resolveWaiting = null;
-        let workersCompleted = 0;
-        let totalMeshes = 0;
-        let workerError = null;
-        const workers = [];
-        for (let i = 0; i < chunks.length; i++) {
-            const [jobStart, jobEnd] = chunks[i];
-            if (jobStart >= jobEnd) {
-                workersCompleted++;
-                continue;
-            }
-            const workerJobs = jobsFlat.slice(jobStart * 3, jobEnd * 3);
-            const worker = new Worker(new URL('./geometry.worker.js', import.meta.url), { type: 'module' });
-            workers.push(worker);
-            worker.onmessage = (e) => {
-                const msg = e.data;
-                if (msg.type === 'batch') {
-                    // Convert transferable data back to MeshData[]
-                    const meshes = msg.meshes.map((m) => ({
-                        expressId: m.expressId,
-                        ifcType: m.ifcType,
-                        positions: m.positions instanceof Float32Array ? m.positions : new Float32Array(m.positions),
-                        normals: m.normals instanceof Float32Array ? m.normals : new Float32Array(m.normals),
-                        indices: m.indices instanceof Uint32Array ? m.indices : new Uint32Array(m.indices),
-                        color: m.color,
-                    }));
-                    if (meshes.length > 0) {
-                        batchQueue.push(meshes);
-                        if (resolveWaiting) {
-                            resolveWaiting();
-                            resolveWaiting = null;
-                        }
-                    }
-                }
-                else if (msg.type === 'complete') {
-                    totalMeshes += msg.totalMeshes;
-                    workersCompleted++;
-                    worker.terminate();
-                    if (resolveWaiting) {
-                        resolveWaiting();
-                        resolveWaiting = null;
-                    }
-                }
-                else if (msg.type === 'error') {
-                    workerError = new Error(`Geometry worker error: ${msg.message}`);
-                    workersCompleted++;
-                    worker.terminate();
-                    if (resolveWaiting) {
-                        resolveWaiting();
-                        resolveWaiting = null;
-                    }
-                }
-            };
-            worker.onerror = (e) => {
-                workerError = new Error(`Geometry worker failed: ${e.message}`);
-                workersCompleted++;
-                worker.terminate();
-                if (resolveWaiting) {
-                    resolveWaiting();
-                    resolveWaiting = null;
-                }
-            };
-            // Send work — sharedBuffer is zero-copy, typed arrays are transferred
-            worker.postMessage({
-                type: 'process',
-                sharedBuffer,
-                jobsFlat: workerJobs,
-                unitScale,
-                rtcX, rtcY, rtcZ,
-                needsShift,
-                voidKeys, voidCounts, voidValues,
-                styleIds, styleColors,
-            });
-        }
-        // Yield batches as they arrive from any worker
-        while (true) {
-            while (batchQueue.length > 0) {
-                const batch = batchQueue.shift();
-                this.coordinateHandler.processMeshesIncremental(batch);
-                const coordinateInfo = this.coordinateHandler.getCurrentCoordinateInfo();
-                yield {
-                    type: 'batch',
-                    meshes: batch,
-                    totalSoFar: totalMeshes,
-                    coordinateInfo: coordinateInfo || undefined,
-                };
-            }
-            if (workerError) {
-                // Terminate remaining workers
-                for (const w of workers) {
-                    try {
-                        w.terminate();
-                    }
-                    catch { /* ignore */ }
-                }
-                throw workerError;
-            }
-            if (workersCompleted >= chunks.length && batchQueue.length === 0) {
-                break;
-            }
-            await new Promise((resolve) => {
-                resolveWaiting = resolve;
-            });
-        }
-        const coordinateInfo = this.coordinateHandler.getFinalCoordinateInfo();
-        yield { type: 'complete', totalMeshes, coordinateInfo };
+        yield* processParallel(buffer, this.coordinateHandler, sharedRtcOffset);
     }
     /**
      * Adaptive processing: Choose sync or streaming based on file size
@@ -840,6 +617,9 @@ export class GeometryProcessor {
                 const collector = new IfcLiteMeshCollector(this.bridge.getApi(), content);
                 allMeshes = collector.collectMeshes();
             }
+            // NOTE: The sync path (<2MB) does not support sharedRtcOffset override.
+            // Infrastructure models with large coordinates are always >2MB and use
+            // the parallel/streaming paths where shared RTC is properly threaded.
             // Process coordinate shifts
             this.coordinateHandler.processMeshesIncremental(allMeshes);
             const coordinateInfo = this.coordinateHandler.getFinalCoordinateInfo();
@@ -859,10 +639,10 @@ export class GeometryProcessor {
                 && typeof navigator !== 'undefined'
                 && (navigator.hardwareConcurrency ?? 1) > 1;
             if (useParallel) {
-                yield* this.processParallel(buffer);
+                yield* this.processParallel(buffer, options.sharedRtcOffset);
             }
             else {
-                yield* this.processStreaming(buffer, options.entityIndex, batchConfig);
+                yield* this.processStreaming(buffer, options.entityIndex, batchConfig, options.sharedRtcOffset);
             }
         }
     }
@@ -878,125 +658,8 @@ export class GeometryProcessor {
     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 };
-    }
+    // enqueueNativeStreamingEvent and streamNativeGeometry have been
+    // extracted to ./geometry-native.ts
     /**
      * Parse symbolic representations (Plan, Annotation, FootPrint) from IFC content
      * These are pre-authored 2D curves for architectural drawings (door swings, window cuts, etc.)