@ifc-lite/geometry 2.2.0 → 2.4.0

package/dist/geometry-parallel.js

@@ -102,6 +102,13 @@ existingSab, options) {
                     // renderer (transferables; already typed arrays from the worker).
                     ...(m.uvs ? { uvs: m.uvs } : {}),
                     ...(m.texture ? { texture: m.texture } : {}),
+                    // Carry the model-diff fingerprint through the worker boundary
+                    // (issue #924); undefined when hashing is off.
+                    ...(m.geometryHash !== undefined ? { geometryHash: m.geometryHash } : {}),
+                    // #957 follow-up: carry the Model/Types geometry class through the
+                    // worker→main re-map (else the viewer's view-mode filter sees only
+                    // class 0 and the Types view renders nothing).
+                    ...(m.geometryClass !== undefined ? { geometryClass: m.geometryClass } : {}),
                 }));
                 if (meshes.length > 0) {
                     // Update totalMeshes per batch so consumers see a live
@@ -187,6 +194,12 @@ existingSab, options) {
             type: 'set-merge-layers',
             enabled: options?.mergeLayers === true,
         });
+        // Issue #924: forward the geometry-hash tolerance the same way — always
+        // sent so the controller path stays uniform; null is a cheap no-op.
+        worker.postMessage({
+            type: 'set-compute-geometry-hashes',
+            tolerance: options?.geometryHashTolerance ?? null,
+        });
     }
     const sendStreamEnd = () => {
         if (endSentToWorkers)
@@ -292,285 +305,306 @@ existingSab, options) {
     const elapsed = () => Math.round(performance.now() - t0);
     console.log(`[stream] processParallel start, fileSizeMB=${fileSizeMB.toFixed(1)} workerCount=${workerCount}`);
     const prepassWorker = makePrepassWorker();
-    // Forward the consumer-supplied wasm URL to the pre-pass worker so it
-    // doesn't fall back to wasm-bindgen's `import.meta.url` default. The
-    // pre-pass worker uses the same `geometry.worker.js` bundle and the
-    // legacy (non-threaded) wasm, so `wasmUrls.wasm` is the right key.
-    // Skipped entirely when no URL was provided — keeps Vite/webpack
-    // consumers on the bundler-native resolution path.
-    if (options?.wasmUrls?.wasm) {
-        prepassWorker.postMessage({ type: 'init', wasmUrl: options.wasmUrls.wasm });
-    }
-    let chunkArrivals = 0;
-    let totalDispatchedJobs = 0;
-    let firstChunkAt = -1;
-    prepassWorker.onmessage = (e) => {
-        const data = e.data;
-        if (data.type === 'prepass-progress') {
-            eventQueue.push({ type: 'progress', phase: 'prepass' });
-            wake();
-            return;
+    // Wrap the rest of the pipeline so worker teardown runs not only on
+    // normal completion / error / zero-jobs branches, but also when the
+    // consumer abandons the generator via `.return()` / `.throw()` while it
+    // is suspended at a `yield` or the `resolveWaiting` await. The viewer's
+    // `watchedGeometryStream` relies on this `finally` to tear down workers
+    // on break / abort / watchdog (see boundedIteratorReturn). The existing
+    // branch-local `terminate()` calls remain — `terminate()` is idempotent.
+    try {
+        // Forward the consumer-supplied wasm URL to the pre-pass worker so it
+        // doesn't fall back to wasm-bindgen's `import.meta.url` default. The
+        // pre-pass worker uses the same `geometry.worker.js` bundle and the
+        // legacy (non-threaded) wasm, so `wasmUrls.wasm` is the right key.
+        // Skipped entirely when no URL was provided — keeps Vite/webpack
+        // consumers on the bundler-native resolution path.
+        if (options?.wasmUrls?.wasm) {
+            prepassWorker.postMessage({ type: 'init', wasmUrl: options.wasmUrls.wasm });
         }
-        if (data.type === 'prepass-stream') {
-            const evt = data.event;
-            if (evt.type === 'meta') {
-                prepassMeta = {
-                    unitScale: evt.unitScale,
-                    rtcOffset: evt.rtcOffset,
-                    needsShift: evt.needsShift,
-                    buildingRotation: evt.buildingRotation ?? null,
-                };
-                console.log(`[stream] meta @ ${elapsed()}ms unitScale=${prepassMeta.unitScale} rtc=[${(prepassMeta.rtcOffset[0]).toFixed(0)},${(prepassMeta.rtcOffset[1]).toFixed(0)},${(prepassMeta.rtcOffset[2]).toFixed(0)}]`);
-                sendStreamStartIfReady();
+        let chunkArrivals = 0;
+        let totalDispatchedJobs = 0;
+        let firstChunkAt = -1;
+        prepassWorker.onmessage = (e) => {
+            const data = e.data;
+            if (data.type === 'prepass-progress') {
+                eventQueue.push({ type: 'progress', phase: 'prepass' });
                 wake();
+                return;
             }
-            else if (evt.type === 'jobs') {
-                const jobsArr = evt.jobs;
-                const jobCount = Math.floor(jobsArr.length / 3);
-                chunkArrivals++;
-                totalDispatchedJobs += jobCount;
-                if (firstChunkAt < 0) {
-                    firstChunkAt = elapsed();
-                    console.log(`[stream] first jobs chunk @ ${firstChunkAt}ms (${jobCount} jobs)`);
-                }
-                if (chunkArrivals % 10 === 1 || jobCount < 1000) {
-                    console.log(`[stream] chunk #${chunkArrivals} @ ${elapsed()}ms (+${jobCount} jobs, total ${totalDispatchedJobs})`);
+            if (data.type === 'prepass-stream') {
+                const evt = data.event;
+                if (evt.type === 'meta') {
+                    prepassMeta = {
+                        unitScale: evt.unitScale,
+                        rtcOffset: evt.rtcOffset,
+                        needsShift: evt.needsShift,
+                        buildingRotation: evt.buildingRotation ?? null,
+                    };
+                    console.log(`[stream] meta @ ${elapsed()}ms unitScale=${prepassMeta.unitScale} rtc=[${(prepassMeta.rtcOffset[0]).toFixed(0)},${(prepassMeta.rtcOffset[1]).toFixed(0)},${(prepassMeta.rtcOffset[2]).toFixed(0)}]`);
+                    sendStreamStartIfReady();
+                    wake();
                 }
-                dispatchJobsChunk(jobsArr);
-            }
-            else if (evt.type === 'styles') {
-                // Streaming pre-pass resolved styles + voids after its main scan.
-                // Push them into every worker, then drain any chunks that were
-                // held waiting for styles. Workers will process every chunk with
-                // resolved colors — uniform shading across the whole stream.
-                const styleIds = evt.styleIds;
-                const styleColors = evt.styleColors;
-                const voidKeys = evt.voidKeys;
-                const voidCounts = evt.voidCounts;
-                const voidValues = evt.voidValues;
-                console.log(`[stream] styles @ ${elapsed()}ms (${styleIds.length} styled, ${voidKeys.length} void hosts), draining ${queuedChunks.length} queued chunks`);
-                for (const w of workers) {
-                    // Slice each typed array per-worker so each can be in its own
-                    // transfer list without conflict. The slice cost is bounded by
-                    // `styleIds.length * 4` bytes — under 1 MB for ~250K styles.
-                    try {
-                        const sIds = styleIds.slice();
-                        const sColors = styleColors.slice();
-                        const vKeys = voidKeys.slice();
-                        const vCounts = voidCounts.slice();
-                        const vValues = voidValues.slice();
-                        w.postMessage({
-                            type: 'set-styles',
-                            styleIds: sIds,
-                            styleColors: sColors,
-                            voidKeys: vKeys,
-                            voidCounts: vCounts,
-                            voidValues: vValues,
-                        }, [sIds.buffer, sColors.buffer, vKeys.buffer, vCounts.buffer, vValues.buffer]);
+                else if (evt.type === 'jobs') {
+                    const jobsArr = evt.jobs;
+                    const jobCount = Math.floor(jobsArr.length / 3);
+                    chunkArrivals++;
+                    totalDispatchedJobs += jobCount;
+                    if (firstChunkAt < 0) {
+                        firstChunkAt = elapsed();
+                        console.log(`[stream] first jobs chunk @ ${firstChunkAt}ms (${jobCount} jobs)`);
                     }
-                    catch (err) {
-                        console.warn('[stream] set-styles dispatch failed:', err);
+                    if (chunkArrivals % 10 === 1 || jobCount < 1000) {
+                        console.log(`[stream] chunk #${chunkArrivals} @ ${elapsed()}ms (+${jobCount} jobs, total ${totalDispatchedJobs})`);
                     }
+                    dispatchJobsChunk(jobsArr);
                 }
-                stylesReceived = true;
-                // Drain only when ALL gates are open (entity-index too). The
-                // worker's tail-promise serialiser ensures any set-* runs
-                // before any subsequent stream-chunk.
-                drainQueuedChunksIfReady();
-            }
-            else if (evt.type === 'entity-index') {
-                // Pre-pass exported its built entity_index. Forward to every
-                // worker so they skip the ~5 s file re-scan in Rust's lazy
-                // build path. SAB sharing for zero-copy distribution to N
-                // workers — each gets a Uint32Array view over the same buffer.
-                const ids = evt.ids;
-                const starts = evt.starts;
-                const lengths = evt.lengths;
-                console.log(`[stream] entity-index @ ${elapsed()}ms (${ids.length} entries)`);
-                if (typeof SharedArrayBuffer !== 'undefined') {
-                    // Allocate one SAB triple, copy data once, share across all
-                    // workers without postMessage clone cost.
-                    const idsBytes = ids.byteLength;
-                    const startsBytes = starts.byteLength;
-                    const lengthsBytes = lengths.byteLength;
-                    const sabIds = new SharedArrayBuffer(idsBytes);
-                    const sabStarts = new SharedArrayBuffer(startsBytes);
-                    const sabLengths = new SharedArrayBuffer(lengthsBytes);
-                    new Uint32Array(sabIds).set(ids);
-                    new Uint32Array(sabStarts).set(starts);
-                    new Uint32Array(sabLengths).set(lengths);
+                else if (evt.type === 'styles') {
+                    // Streaming pre-pass resolved styles + voids after its main scan.
+                    // Push them into every worker, then drain any chunks that were
+                    // held waiting for styles. Workers will process every chunk with
+                    // resolved colors — uniform shading across the whole stream.
+                    const styleIds = evt.styleIds;
+                    const styleColors = evt.styleColors;
+                    const voidKeys = evt.voidKeys;
+                    const voidCounts = evt.voidCounts;
+                    const voidValues = evt.voidValues;
+                    console.log(`[stream] styles @ ${elapsed()}ms (${styleIds.length} styled, ${voidKeys.length} void hosts), draining ${queuedChunks.length} queued chunks`);
                     for (const w of workers) {
+                        // Slice each typed array per-worker so each can be in its own
+                        // transfer list without conflict. The slice cost is bounded by
+                        // `styleIds.length * 4` bytes — under 1 MB for ~250K styles.
                         try {
+                            const sIds = styleIds.slice();
+                            const sColors = styleColors.slice();
+                            const vKeys = voidKeys.slice();
+                            const vCounts = voidCounts.slice();
+                            const vValues = voidValues.slice();
                             w.postMessage({
-                                type: 'set-entity-index',
-                                ids: new Uint32Array(sabIds),
-                                starts: new Uint32Array(sabStarts),
-                                lengths: new Uint32Array(sabLengths),
-                            });
-                        }
-                        catch (err) {
-                            console.warn('[stream] set-entity-index dispatch failed:', err);
-                        }
-                    }
-                    // Hand the same SAB triple to the parser worker (or any other
-                    // listener) so it can skip its own `scanEntitiesFastBytes` call.
-                    // Each consumer gets its own Uint32Array view over the shared
-                    // buffers — no extra copy.
-                    if (options?.onEntityIndex) {
-                        try {
-                            options.onEntityIndex(new Uint32Array(sabIds), new Uint32Array(sabStarts), new Uint32Array(sabLengths));
+                                type: 'set-styles',
+                                styleIds: sIds,
+                                styleColors: sColors,
+                                voidKeys: vKeys,
+                                voidCounts: vCounts,
+                                voidValues: vValues,
+                            }, [sIds.buffer, sColors.buffer, vKeys.buffer, vCounts.buffer, vValues.buffer]);
                         }
                         catch (err) {
-                            console.warn('[stream] onEntityIndex callback failed:', err);
+                            console.warn('[stream] set-styles dispatch failed:', err);
                         }
                     }
+                    stylesReceived = true;
+                    // Drain only when ALL gates are open (entity-index too). The
+                    // worker's tail-promise serialiser ensures any set-* runs
+                    // before any subsequent stream-chunk.
+                    drainQueuedChunksIfReady();
                 }
-                else {
-                    // SAB unavailable — clone per worker via structured clone.
-                    for (const w of workers) {
-                        try {
-                            w.postMessage({
-                                type: 'set-entity-index',
-                                ids: ids.slice(),
-                                starts: starts.slice(),
-                                lengths: lengths.slice(),
-                            });
+                else if (evt.type === 'entity-index') {
+                    // Pre-pass exported its built entity_index. Forward to every
+                    // worker so they skip the ~5 s file re-scan in Rust's lazy
+                    // build path. SAB sharing for zero-copy distribution to N
+                    // workers — each gets a Uint32Array view over the same buffer.
+                    const ids = evt.ids;
+                    const starts = evt.starts;
+                    const lengths = evt.lengths;
+                    console.log(`[stream] entity-index @ ${elapsed()}ms (${ids.length} entries)`);
+                    if (typeof SharedArrayBuffer !== 'undefined') {
+                        // Allocate one SAB triple, copy data once, share across all
+                        // workers without postMessage clone cost.
+                        const idsBytes = ids.byteLength;
+                        const startsBytes = starts.byteLength;
+                        const lengthsBytes = lengths.byteLength;
+                        const sabIds = new SharedArrayBuffer(idsBytes);
+                        const sabStarts = new SharedArrayBuffer(startsBytes);
+                        const sabLengths = new SharedArrayBuffer(lengthsBytes);
+                        new Uint32Array(sabIds).set(ids);
+                        new Uint32Array(sabStarts).set(starts);
+                        new Uint32Array(sabLengths).set(lengths);
+                        for (const w of workers) {
+                            try {
+                                w.postMessage({
+                                    type: 'set-entity-index',
+                                    ids: new Uint32Array(sabIds),
+                                    starts: new Uint32Array(sabStarts),
+                                    lengths: new Uint32Array(sabLengths),
+                                });
+                            }
+                            catch (err) {
+                                console.warn('[stream] set-entity-index dispatch failed:', err);
+                            }
                         }
-                        catch (err) {
-                            console.warn('[stream] set-entity-index dispatch failed:', err);
+                        // Hand the same SAB triple to the parser worker (or any other
+                        // listener) so it can skip its own `scanEntitiesFastBytes` call.
+                        // Each consumer gets its own Uint32Array view over the shared
+                        // buffers — no extra copy.
+                        if (options?.onEntityIndex) {
+                            try {
+                                options.onEntityIndex(new Uint32Array(sabIds), new Uint32Array(sabStarts), new Uint32Array(sabLengths));
+                            }
+                            catch (err) {
+                                console.warn('[stream] onEntityIndex callback failed:', err);
+                            }
                         }
                     }
-                    if (options?.onEntityIndex) {
-                        try {
-                            options.onEntityIndex(ids.slice(), starts.slice(), lengths.slice());
+                    else {
+                        // SAB unavailable — clone per worker via structured clone.
+                        for (const w of workers) {
+                            try {
+                                w.postMessage({
+                                    type: 'set-entity-index',
+                                    ids: ids.slice(),
+                                    starts: starts.slice(),
+                                    lengths: lengths.slice(),
+                                });
+                            }
+                            catch (err) {
+                                console.warn('[stream] set-entity-index dispatch failed:', err);
+                            }
                         }
-                        catch (err) {
-                            console.warn('[stream] onEntityIndex callback failed:', err);
+                        if (options?.onEntityIndex) {
+                            try {
+                                options.onEntityIndex(ids.slice(), starts.slice(), lengths.slice());
+                            }
+                            catch (err) {
+                                console.warn('[stream] onEntityIndex callback failed:', err);
+                            }
                         }
                     }
+                    entityIndexReceived = true;
+                    drainQueuedChunksIfReady();
                 }
-                entityIndexReceived = true;
-                drainQueuedChunksIfReady();
-            }
-            else if (evt.type === 'complete') {
-                prepassJobsTotal = evt.totalJobs;
-                console.log(`[stream] prepass complete @ ${elapsed()}ms totalJobs=${prepassJobsTotal} chunks=${chunkArrivals}`);
-                // Unconditionally drive the prepass-complete handler here.
-                // The outer loop's `prepassJobsTotal > 0` gate would skip
-                // zero-geometry files (no IFC geometry entities), causing
-                // the generator to wait forever. Calling here ensures
-                // prepassDone flips even when totalJobs === 0.
-                if (!prepassCompleteSeen) {
-                    prepassCompleteSeen = true;
-                    onPrepassComplete();
+                else if (evt.type === 'complete') {
+                    prepassJobsTotal = evt.totalJobs;
+                    console.log(`[stream] prepass complete @ ${elapsed()}ms totalJobs=${prepassJobsTotal} chunks=${chunkArrivals}`);
+                    // Unconditionally drive the prepass-complete handler here.
+                    // The outer loop's `prepassJobsTotal > 0` gate would skip
+                    // zero-geometry files (no IFC geometry entities), causing
+                    // the generator to wait forever. Calling here ensures
+                    // prepassDone flips even when totalJobs === 0.
+                    if (!prepassCompleteSeen) {
+                        prepassCompleteSeen = true;
+                        onPrepassComplete();
+                    }
                 }
+                return;
             }
-            return;
-        }
-        if (data.type === 'error') {
-            prepassError = new Error(data.message);
+            if (data.type === 'error') {
+                prepassError = new Error(data.message);
+                prepassDone = true;
+                prepassWorker.terminate();
+                wake();
+                return;
+            }
+            // The streaming variant doesn't emit `prepass-result` — the streaming
+            // worker exits naturally after the JS callback returns from
+            // `buildPrePassStreaming`. We treat unknown messages as no-ops.
+        };
+        prepassWorker.onerror = (e) => {
+            prepassError = new Error(`Pre-pass worker failed: ${e.message}`);
             prepassDone = true;
             prepassWorker.terminate();
             wake();
-            return;
-        }
-        // The streaming variant doesn't emit `prepass-result` — the streaming
-        // worker exits naturally after the JS callback returns from
-        // `buildPrePassStreaming`. We treat unknown messages as no-ops.
-    };
-    prepassWorker.onerror = (e) => {
-        prepassError = new Error(`Pre-pass worker failed: ${e.message}`);
-        prepassDone = true;
-        prepassWorker.terminate();
-        wake();
-    };
-    // Track when the pre-pass worker finishes by listening for either a
-    // synthesized "complete" event from the Rust side OR a worker exit. The
-    // Rust side currently doesn't post anything after `complete` (it returns
-    // from JS), so we close the worker via terminate-on-complete in the host.
-    // After we see the Rust `complete` event we can sendStreamEnd.
-    const onPrepassComplete = () => {
-        prepassDone = true;
-        // Only signal stream-end to workers if they actually got
-        // stream-start (which gates on `meta`). Zero-geometry files
-        // never trigger meta → workers never start → no stream-end
-        // needed. The dedicated zero-jobs branch in the outer loop
-        // handles their teardown.
-        if (streamStartSentToWorkers) {
-            sendStreamEnd();
-        }
-        prepassWorker.terminate();
-        wake();
-    };
-    // Dispatch the streaming pre-pass.
-    // chunk_size = 50K is a deliberate compromise:
-    //   • small enough that the FIRST chunk (always a tiny one — bounded by
-    //     RTC_SAMPLE_THRESHOLD ≈ 50 jobs from the Rust side) reaches workers
-    //     within ~1.5 s for fast TTFG;
-    //   • large enough that subsequent chunks make few Rust→JS callbacks
-    //     and few worker postMessages — each call into processGeometryBatch
-    //     has fixed setup cost that compounds badly when invoked 30+ times.
-    // Per-chunk fan-out (see `dispatchJobsChunkInternal`) splits each chunk
-    // evenly across all workers so parallelism is preserved at every chunk.
-    prepassWorker.postMessage({ type: 'prepass-streaming', sharedBuffer, chunkSize: 50_000 });
-    // Drain the event queue until the pre-pass and all process workers complete.
-    // The pre-pass `complete` event is captured inside the message handler
-    // (we set prepassJobsTotal there) but the worker stays alive briefly
-    // while the JS callback returns. Detect end-of-stream by:
-    //   a) `prepassJobsTotal > 0` (or zero-jobs file): pre-pass emitted complete
-    //   b) all workers reported `complete`
-    let prepassCompleteSeen = false;
-    while (true) {
-        while (eventQueue.length > 0) {
-            yield eventQueue.shift();
-        }
-        if (workerError) {
-            for (const w of workers) {
+        };
+        // Track when the pre-pass worker finishes by listening for either a
+        // synthesized "complete" event from the Rust side OR a worker exit. The
+        // Rust side currently doesn't post anything after `complete` (it returns
+        // from JS), so we close the worker via terminate-on-complete in the host.
+        // After we see the Rust `complete` event we can sendStreamEnd.
+        const onPrepassComplete = () => {
+            prepassDone = true;
+            // Only signal stream-end to workers if they actually got
+            // stream-start (which gates on `meta`). Zero-geometry files
+            // never trigger meta → workers never start → no stream-end
+            // needed. The dedicated zero-jobs branch in the outer loop
+            // handles their teardown.
+            if (streamStartSentToWorkers) {
+                sendStreamEnd();
+            }
+            prepassWorker.terminate();
+            wake();
+        };
+        // Dispatch the streaming pre-pass.
+        // chunk_size = 50K is a deliberate compromise:
+        //   • small enough that the FIRST chunk (always a tiny one — bounded by
+        //     RTC_SAMPLE_THRESHOLD ≈ 50 jobs from the Rust side) reaches workers
+        //     within ~1.5 s for fast TTFG;
+        //   • large enough that subsequent chunks make few Rust→JS callbacks
+        //     and few worker postMessages — each call into processGeometryBatch
+        //     has fixed setup cost that compounds badly when invoked 30+ times.
+        // Per-chunk fan-out (see `dispatchJobsChunkInternal`) splits each chunk
+        // evenly across all workers so parallelism is preserved at every chunk.
+        prepassWorker.postMessage({ type: 'prepass-streaming', sharedBuffer, chunkSize: 50_000 });
+        // Drain the event queue until the pre-pass and all process workers complete.
+        // The pre-pass `complete` event is captured inside the message handler
+        // (we set prepassJobsTotal there) but the worker stays alive briefly
+        // while the JS callback returns. Detect end-of-stream by:
+        //   a) `prepassJobsTotal > 0` (or zero-jobs file): pre-pass emitted complete
+        //   b) all workers reported `complete`
+        let prepassCompleteSeen = false;
+        while (true) {
+            while (eventQueue.length > 0) {
+                yield eventQueue.shift();
+            }
+            if (workerError) {
+                for (const w of workers) {
+                    try {
+                        w.terminate();
+                    }
+                    catch { /* cleanup — safe to ignore */ }
+                }
                 try {
-                    w.terminate();
+                    prepassWorker.terminate();
                 }
                 catch { /* cleanup — safe to ignore */ }
+                throw workerError;
             }
-            try {
-                prepassWorker.terminate();
+            if (prepassError) {
+                for (const w of workers) {
+                    try {
+                        w.terminate();
+                    }
+                    catch { /* cleanup — safe to ignore */ }
+                }
+                throw prepassError;
             }
-            catch { /* cleanup — safe to ignore */ }
-            throw workerError;
-        }
-        if (prepassError) {
-            for (const w of workers) {
-                try {
-                    w.terminate();
+            // Edge case: pre-pass for a file with zero geometry. The Rust side
+            // emits `complete { totalJobs: 0 }`; meta never fired so workers
+            // never received stream-start. Tear them down explicitly and yield
+            // `complete`. Workers were pre-spawned with `init` so they need an
+            // explicit terminate to exit.
+            if (prepassDone && !streamStartSentToWorkers && prepassJobsTotal === 0) {
+                for (const w of workers) {
+                    try {
+                        w.terminate();
+                    }
+                    catch { /* cleanup — safe to ignore */ }
                 }
-                catch { /* cleanup — safe to ignore */ }
+                const coordinateInfo = coordinator.getFinalCoordinateInfo();
+                yield { type: 'complete', totalMeshes: 0, coordinateInfo };
+                return;
             }
-            throw prepassError;
+            if (prepassDone
+                && streamStartSentToWorkers
+                && workersCompleted >= workers.length
+                && eventQueue.length === 0) {
+                break;
+            }
+            await new Promise((resolve) => { resolveWaiting = resolve; });
         }
-        // Edge case: pre-pass for a file with zero geometry. The Rust side
-        // emits `complete { totalJobs: 0 }`; meta never fired so workers
-        // never received stream-start. Tear them down explicitly and yield
-        // `complete`. Workers were pre-spawned with `init` so they need an
-        // explicit terminate to exit.
-        if (prepassDone && !streamStartSentToWorkers && prepassJobsTotal === 0) {
-            for (const w of workers) {
-                try {
-                    w.terminate();
-                }
-                catch { /* cleanup — safe to ignore */ }
+        const coordinateInfo = coordinator.getFinalCoordinateInfo();
+        yield { type: 'complete', totalMeshes, coordinateInfo };
+    }
+    finally {
+        for (const w of workers) {
+            try {
+                w.terminate();
             }
-            const coordinateInfo = coordinator.getFinalCoordinateInfo();
-            yield { type: 'complete', totalMeshes: 0, coordinateInfo };
-            return;
+            catch { /* cleanup — safe to ignore */ }
         }
-        if (prepassDone
-            && streamStartSentToWorkers
-            && workersCompleted >= workers.length
-            && eventQueue.length === 0) {
-            break;
+        try {
+            prepassWorker.terminate();
         }
-        await new Promise((resolve) => { resolveWaiting = resolve; });
+        catch { /* cleanup — safe to ignore */ }
     }
-    const coordinateInfo = coordinator.getFinalCoordinateInfo();
-    yield { type: 'complete', totalMeshes, coordinateInfo };
 }
 //# sourceMappingURL=geometry-parallel.js.map