@ifc-lite/geometry 1.16.4 → 1.16.6

package/README.md

@@ -1,6 +1,6 @@
 # @ifc-lite/geometry
 
-Geometry processing bridge for IFClite. Connects the WASM-based geometry engine to the TypeScript pipeline with streaming mesh processing.
+Streaming geometry processor for IFClite. Converts IFC bytes to renderable mesh batches via Rust + WASM (or Tauri native), with first triangles in 300–500ms and progressive streaming for large models.
 
 ## Installation
 
@@ -8,7 +8,7 @@ Geometry processing bridge for IFClite. Connects the WASM-based geometry engine
 npm install @ifc-lite/geometry
 ```
 
-## Quick Start
+## Process geometry from IFC bytes
 
 ```typescript
 import { GeometryProcessor } from '@ifc-lite/geometry';
@@ -16,22 +16,53 @@ import { GeometryProcessor } from '@ifc-lite/geometry';
 const processor = new GeometryProcessor();
 await processor.init();
 
-const result = await processor.process(ifcBuffer, {
-  onBatch: (batch) => renderer.addMeshes(batch),
-});
+const buffer = new Uint8Array(await file.arrayBuffer());
+const result = await processor.process(buffer);
+
+console.log(`${result.meshes.length} meshes, ${result.totalTriangles} triangles`);
+// Each mesh: { expressId, positions: Float32Array, normals, indices: Uint32Array, color, ifcType }
+```
+
+## Stream geometry (recommended for large models)
+
+```typescript
+for await (const event of processor.processStreaming(buffer)) {
+  if (event.type === 'batch') {
+    renderer.appendMeshes(event.meshes);
+    console.log(`Loaded ${event.totalSoFar} meshes so far`);
+  } else if (event.type === 'complete') {
+    console.log(`Done: ${event.totalMeshes} meshes`);
+  }
+}
+```
+
+The streaming path emits batches every ~100 meshes so the renderer can paint progressively — first triangles typically arrive 300–500ms after `processStreaming()` returns.
+
+## Coordinate handling
+
+```typescript
+import { CoordinateHandler } from '@ifc-lite/geometry';
+
+const result = await processor.process(buffer);
+
+// Models with large world coordinates (geo-referenced) get auto-shifted
+// to keep float precision inside the renderer.
+if (result.coordinateInfo?.hasLargeCoordinates) {
+  const { x, y, z } = result.coordinateInfo.originShift;
+  console.log(`Origin shifted by [${x}, ${y}, ${z}] for renderer precision`);
+}
 ```
 
-## Features
+## Performance
 
-- Streaming geometry processing (100 meshes/batch)
-- First triangles in 300-500ms
-- Up to 5x faster than web-ifc
-- Web Worker support for large files (>50MB)
-- Coordinate system handling and origin shift
+- **First triangles:** 300–500ms (streaming path)
+- **Throughput:** up to 5× faster than `web-ifc` on the same model
+- **Worker support:** files > 50 MB process off-main-thread automatically
+- **Native (Tauri):** `preferNative: true` constructor option enables the native Rust pipeline for desktop builds
 
 ## API
 
-See the [Geometry Guide](../../docs/guide/geometry.md) and [API Reference](../../docs/api/typescript.md#ifc-litegeometry).
+See the [Geometry Guide](https://louistrue.github.io/ifc-lite/guide/geometry/) and [API Reference](https://louistrue.github.io/ifc-lite/api/typescript/#ifc-litegeometry).
 
 ## License
 

package/dist/geometry-coordinate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Coordinate transform utilities and batch-conversion helpers.
+ *
+ * Pure functions that convert WASM mesh/instanced-geometry collections
+ * into plain MeshData arrays, compute streaming batch sizes, and merge
+ * building rotation into coordinate info.
+ */
+import type { MeshData, CoordinateInfo } from './types.js';
+import type { DynamicBatchConfig } from './index.js';
+/**
+ * Return a fixed or heuristic batch size for streaming, given the file
+ * buffer and the caller-supplied config.
+ */
+export declare function getStreamingBatchSize(buffer: Uint8Array, batchConfig: number | DynamicBatchConfig): number;
+/**
+ * Convert a WASM MeshCollection into a plain MeshData array, freeing
+ * each mesh and the collection itself.
+ */
+export declare function convertMeshCollectionToBatch(collection: import('@ifc-lite/wasm').MeshCollection): MeshData[];
+/**
+ * Convert a WASM InstancedMeshCollection into a plain array of
+ * InstancedGeometry objects, freeing the collection wrapper.
+ */
+export declare function convertInstancedCollectionToBatch(collection: import('@ifc-lite/wasm').InstancedMeshCollection): import('@ifc-lite/wasm').InstancedGeometry[];
+/**
+ * Merge an optional building rotation value into a CoordinateInfo object.
+ */
+export declare function withBuildingRotation(coordinateInfo: CoordinateInfo, buildingRotation?: number): CoordinateInfo;
+//# sourceMappingURL=geometry-coordinate.d.ts.map

package/dist/geometry-coordinate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-coordinate.d.ts","sourceRoot":"","sources":["../src/geometry-coordinate.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIrD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,GAAG,kBAAkB,GACvC,MAAM,CAeR;AAID;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,OAAO,gBAAgB,EAAE,cAAc,GAClD,QAAQ,EAAE,CA0BZ;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,OAAO,gBAAgB,EAAE,uBAAuB,GAC3D,OAAO,gBAAgB,EAAE,iBAAiB,EAAE,CAe9C;AAID;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,cAAc,EAC9B,gBAAgB,CAAC,EAAE,MAAM,GACxB,cAAc,CAIhB"}

package/dist/geometry-coordinate.js

@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+// ── Batch-size heuristics ──
+/**
+ * Return a fixed or heuristic batch size for streaming, given the file
+ * buffer and the caller-supplied config.
+ */
+export function 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;
+}
+// ── WASM collection → MeshData[] conversion ──
+/**
+ * Convert a WASM MeshCollection into a plain MeshData array, freeing
+ * each mesh and the collection itself.
+ */
+export function 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;
+}
+/**
+ * Convert a WASM InstancedMeshCollection into a plain array of
+ * InstancedGeometry objects, freeing the collection wrapper.
+ */
+export function 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;
+}
+// ── Coordinate-info helpers ──
+/**
+ * Merge an optional building rotation value into a CoordinateInfo object.
+ */
+export function withBuildingRotation(coordinateInfo, buildingRotation) {
+    return buildingRotation !== undefined
+        ? { ...coordinateInfo, buildingRotation }
+        : coordinateInfo;
+}
+//# sourceMappingURL=geometry-coordinate.js.map

package/dist/geometry-coordinate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-coordinate.js","sourceRoot":"","sources":["../src/geometry-coordinate.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAa/D,8BAA8B;AAE9B;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAAkB,EAClB,WAAwC;IAExC,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,MAAM,UAAU,GAAG,WAAW,CAAC,UAAU;QACvC,CAAC,CAAC,WAAW,CAAC,UAAU;QACxB,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAElC,OAAO,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG;QAC1B,CAAC,CAAC,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG;YACvB,CAAC,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG;gBACxB,CAAC,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG;oBACxB,CAAC,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI;wBACzB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,gDAAgD;AAEhD;;;GAGG;AACH,MAAM,UAAU,4BAA4B,CAC1C,UAAmD;IAEnD,MAAM,KAAK,GAAe,EAAE,CAAC;IAE7B,IAAI,CAAC;QACH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,IAAI;gBAAE,SAAS;YAEpB,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC;oBACT,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;iBACpE,CAAC,CAAC;YACL,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;YAAS,CAAC;QACT,UAAU,CAAC,IAAI,EAAE,CAAC;IACpB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iCAAiC,CAC/C,UAA4D;IAE5D,MAAM,KAAK,GAAiD,EAAE,CAAC;IAE/D,IAAI,CAAC;QACH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACnC,IAAI,QAAQ,EAAE,CAAC;gBACb,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;YAAS,CAAC;QACT,UAAU,CAAC,IAAI,EAAE,CAAC;IACpB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,gCAAgC;AAEhC;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,cAA8B,EAC9B,gBAAyB;IAEzB,OAAO,gBAAgB,KAAK,SAAS;QACnC,CAAC,CAAC,EAAE,GAAG,cAAc,EAAE,gBAAgB,EAAE;QACzC,CAAC,CAAC,cAAc,CAAC;AACrB,CAAC"}

package/dist/geometry-native.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Native Tauri bridge streaming helpers.
+ *
+ * Handles queue coalescing, back-pressure, and event-loop yielding for
+ * the native desktop geometry streaming path.  These are platform-specific
+ * utilities isolated from the main GeometryProcessor.
+ */
+import type { CoordinateHandler } from './coordinate-handler.js';
+import type { MeshData } from './types.js';
+import type { GeometryStats as PlatformGeometryStats, GeometryBatch, NativeBatchTelemetry } from './platform-bridge.js';
+import type { StreamingGeometryEvent } from './index.js';
+export declare const MAX_NATIVE_STREAM_QUEUE_EVENTS = 8;
+export declare const MAX_NATIVE_STREAM_QUEUE_MESHES = 32768;
+export declare const MAX_NATIVE_STREAM_EVENTS_PER_TURN = 4;
+export declare const MAX_NATIVE_STREAM_MESHES_PER_TURN = 8192;
+export declare const MAX_NATIVE_STREAM_DRAIN_MS = 10;
+export type QueuedNativeStreamingEvent = {
+    type: 'batch';
+    meshes: MeshData[];
+    nativeTelemetry?: NativeBatchTelemetry;
+} | {
+    type: 'colorUpdate';
+    updates: Map<number, [number, number, number, number]>;
+};
+export declare function yieldToEventLoop(): Promise<void>;
+/**
+ * Coalesce incoming native events into the queue to reduce per-yield
+ * overhead when the JS main thread cannot keep up with Rust production.
+ */
+export declare function enqueueNativeStreamingEvent(queuedEvents: QueuedNativeStreamingEvent[], event: QueuedNativeStreamingEvent, queueState: {
+    queuedMeshes: number;
+    coalescedBatchCount: number;
+}): void;
+/**
+ * Shared native streaming generator used by both buffer-based and
+ * path-based native geometry streaming.
+ *
+ * @param startStream  Callback that kicks off the native stream and
+ *                     returns a promise resolving when it finishes.
+ * @param totalEstimate  Estimated total for the 'start' event.
+ * @param coordinator    CoordinateHandler for incremental bounds.
+ * @param setLastNativeStats  Callback to persist the latest stats on
+ *                            the owning GeometryProcessor instance.
+ */
+export declare function streamNativeGeometry(startStream: (options: {
+    onBatch: (batch: GeometryBatch) => void;
+    onColorUpdate: (updates: Map<number, [number, number, number, number]>) => void;
+    onComplete: (stats: PlatformGeometryStats) => void;
+    onError: (error: Error) => void;
+}) => Promise<PlatformGeometryStats>, totalEstimate: number, coordinator: CoordinateHandler, setLastNativeStats: (stats: PlatformGeometryStats) => void): AsyncGenerator<StreamingGeometryEvent>;
+//# sourceMappingURL=geometry-native.d.ts.map

package/dist/geometry-native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-native.d.ts","sourceRoot":"","sources":["../src/geometry-native.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,IAAI,qBAAqB,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACxH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAIzD,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,8BAA8B,QAAQ,CAAC;AACpD,eAAO,MAAM,iCAAiC,IAAI,CAAC;AACnD,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAI7C,MAAM,MAAM,0BAA0B,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,oBAAoB,CAAA;CAAE,GAC7E;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC;AAIpF,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhD;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,0BAA0B,EAAE,EAC1C,KAAK,EAAE,0BAA0B,EACjC,UAAU,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAE,GAChE,IAAI,CA6BN;AAED;;;;;;;;;;GAUG;AACH,wBAAuB,oBAAoB,CACzC,WAAW,EAAE,CAAC,OAAO,EAAE;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACxC,aAAa,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC;IAChF,UAAU,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACnD,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACjC,KAAK,OAAO,CAAC,qBAAqB,CAAC,EACpC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,iBAAiB,EAC9B,kBAAkB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,GACzD,cAAc,CAAC,sBAAsB,CAAC,CA8GxC"}

package/dist/geometry-native.js

@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+// ── Queue tuning constants ──
+export const MAX_NATIVE_STREAM_QUEUE_EVENTS = 8;
+export const MAX_NATIVE_STREAM_QUEUE_MESHES = 32768;
+export const MAX_NATIVE_STREAM_EVENTS_PER_TURN = 4;
+export const MAX_NATIVE_STREAM_MESHES_PER_TURN = 8192;
+export const MAX_NATIVE_STREAM_DRAIN_MS = 10;
+// ── Helpers ──
+export function yieldToEventLoop() {
+    const maybeScheduler = globalThis.scheduler;
+    if (typeof maybeScheduler?.yield === 'function') {
+        return maybeScheduler.yield();
+    }
+    return new Promise((resolve) => {
+        globalThis.setTimeout(resolve, 0);
+    });
+}
+/**
+ * Coalesce incoming native events into the queue to reduce per-yield
+ * overhead when the JS main thread cannot keep up with Rust production.
+ */
+export function 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;
+}
+/**
+ * Shared native streaming generator used by both buffer-based and
+ * path-based native geometry streaming.
+ *
+ * @param startStream  Callback that kicks off the native stream and
+ *                     returns a promise resolving when it finishes.
+ * @param totalEstimate  Estimated total for the 'start' event.
+ * @param coordinator    CoordinateHandler for incremental bounds.
+ * @param setLastNativeStats  Callback to persist the latest stats on
+ *                            the owning GeometryProcessor instance.
+ */
+export async function* streamNativeGeometry(startStream, totalEstimate, coordinator, setLastNativeStats) {
+    coordinator.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) => {
+            enqueueNativeStreamingEvent(queuedEvents, { type: 'batch', meshes: batch.meshes, nativeTelemetry: batch.nativeTelemetry }, queueState);
+            wake();
+        },
+        onColorUpdate: (updates) => {
+            enqueueNativeStreamingEvent(queuedEvents, { type: 'colorUpdate', updates: new Map(updates) }, queueState);
+            wake();
+        },
+        onComplete: (stats) => {
+            setLastNativeStats(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.
+            coordinator.processTrustedMeshesIncremental(event.meshes);
+            totalMeshes += event.meshes.length;
+            const coordinateInfo = coordinator.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 = coordinator.getFinalCoordinateInfo();
+    yield { type: 'complete', totalMeshes: completedTotalMeshes ?? totalMeshes, coordinateInfo };
+}
+//# sourceMappingURL=geometry-native.js.map

package/dist/geometry-native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-native.js","sourceRoot":"","sources":["../src/geometry-native.ts"],"names":[],"mappings":"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"}

package/dist/geometry-parallel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Multi-worker parallel geometry processing.
+ *
+ * Spawns Web Workers that each get their own WASM instance and process
+ * disjoint slices of the geometry entity list.  Batches are yielded as
+ * they arrive from any worker, enabling progressive rendering while
+ * utilizing multiple cores.
+ */
+import type { CoordinateHandler } from './coordinate-handler.js';
+import type { StreamingGeometryEvent } from './index.js';
+/**
+ * Run the full pre-pass in a dedicated worker, then fan geometry jobs
+ * out to N workers and yield batches as they complete.
+ *
+ * @param buffer       Raw IFC file bytes
+ * @param coordinator  CoordinateHandler used to accumulate bounds
+ */
+export declare function processParallel(buffer: Uint8Array, coordinator: CoordinateHandler, sharedRtcOffset?: {
+    x: number;
+    y: number;
+    z: number;
+}): AsyncGenerator<StreamingGeometryEvent>;
+//# sourceMappingURL=geometry-parallel.d.ts.map

package/dist/geometry-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-parallel.d.ts","sourceRoot":"","sources":["../src/geometry-parallel.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAuB,eAAe,CACpC,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,iBAAiB,EAC9B,eAAe,CAAC,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,cAAc,CAAC,sBAAsB,CAAC,CA+MxC"}

package/dist/geometry-parallel.js

@@ -0,0 +1,193 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Run the full pre-pass in a dedicated worker, then fan geometry jobs
+ * out to N workers and yield batches as they complete.
+ *
+ * @param buffer       Raw IFC file bytes
+ * @param coordinator  CoordinateHandler used to accumulate bounds
+ */
+export async function* processParallel(buffer, coordinator, sharedRtcOffset) {
+    coordinator.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.ts', 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 = coordinator.getFinalCoordinateInfo();
+        yield { type: 'complete', totalMeshes: 0, coordinateInfo };
+        return;
+    }
+    const { jobs: jobsFlat, totalJobs, unitScale, rtcOffset, needsShift, voidKeys, voidCounts, voidValues, styleIds, styleColors } = prePassResult;
+    // When a shared RTC offset is provided (2nd+ federated model), use it
+    // instead of the per-model RTC. This ensures all models share the same
+    // coordinate origin, giving pixel-perfect federation alignment.
+    const useSharedRtc = sharedRtcOffset != null;
+    const rtcX = useSharedRtc ? sharedRtcOffset.x : (rtcOffset?.[0] ?? 0);
+    const rtcY = useSharedRtc ? sharedRtcOffset.y : (rtcOffset?.[1] ?? 0);
+    const rtcZ = useSharedRtc ? sharedRtcOffset.z : (rtcOffset?.[2] ?? 0);
+    const effectiveNeedsShift = useSharedRtc ? true : needsShift;
+    yield {
+        type: 'rtcOffset',
+        rtcOffset: { x: rtcX, y: rtcY, z: rtcZ },
+        hasRtc: effectiveNeedsShift,
+    };
+    // ── 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.ts', 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: effectiveNeedsShift,
+            voidKeys, voidCounts, voidValues,
+            styleIds, styleColors,
+        });
+    }
+    // Yield batches as they arrive from any worker
+    while (true) {
+        while (batchQueue.length > 0) {
+            const batch = batchQueue.shift();
+            coordinator.processMeshesIncremental(batch);
+            const coordinateInfo = coordinator.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 { /* cleanup — safe to ignore */ }
+            }
+            throw workerError;
+        }
+        if (workersCompleted >= chunks.length && batchQueue.length === 0) {
+            break;
+        }
+        await new Promise((resolve) => {
+            resolveWaiting = resolve;
+        });
+    }
+    const coordinateInfo = coordinator.getFinalCoordinateInfo();
+    yield { type: 'complete', totalMeshes, coordinateInfo };
+}
+//# sourceMappingURL=geometry-parallel.js.map