@ifc-lite/geometry 7.6.0 → 7.8.1

package/README.md

@@ -154,6 +154,70 @@ works.
 
 See the [Geometry Guide](https://ifclite.dev/docs/guide/geometry/) and [API Reference](https://ifclite.dev/docs/api/typescript/#ifc-litegeometry).
 
+`GeometryProcessor.planMapConversionNormalization(content)` returns a JSON
+entity-patch plan for opt-in STEP coordinate compatibility export. Initialize
+the processor first and dispose it in `finally`. Canonical Rust validates units,
+placements and representation ownership; unsupported coordinate consumers return
+warnings with no patches. `StepExporter.exportAsync({ normalizeMapGeometry:
+true })` applies this plan after edits using its existing modification ledger.
+See the [exporting guide](https://ifclite.dev/docs/guide/exporting/) for the
+supported subset and warning handling. Third-party platform bridges may expose
+the optional planner capability; the bundled native bridge explicitly refuses it.
+
+## Scan plane segmentation
+
+`@ifc-lite/geometry/scan-segmentation` types the wasm plane and cylinder
+detector for point clouds. Pass xyz metres, either a whole buffer or a reservoir with a `count`.
+Every option is optional; see the
+[segmentation contract](https://ifclite.dev/docs/api/wasm/#scan-plane-segmentation)
+for the defaults.
+
+```ts
+import { segmentScan } from '@ifc-lite/geometry/scan-segmentation';
+
+const api = new IfcAPI(); // after the wasm module is initialised
+const positions = new Float32Array([/* x, y, z, ... in metres */]);
+try {
+  const report = segmentScan(api, { positions }, { scannerPosition: [3, 2, 1.5] });
+  for (const plane of report.planes) {
+    console.log(plane.orientation, plane.normal, plane.d, plane.areaSquareMetres);
+  }
+  for (const cylinder of report.cylinders) {
+    // `faceted` is set for a polygonal column (radius is then the circumradius).
+    console.log(cylinder.orientation, cylinder.axisStart, cylinder.radius, cylinder.length, cylinder.faceted?.faces);
+  }
+} finally {
+  api.free();
+}
+```
+
+## Scan element proposals
+
+`@ifc-lite/geometry/scan-proposals` turns a segmentation report into proposed
+`IfcWall`, `IfcSlab`, `IfcColumn` and pipe elements in the IFC model frame (Z
+up, metres): opposite wall faces pair into walls of measured thickness, floors
+and ceilings into slabs, vertical cylinders into columns. See the
+[proposal contract](https://ifclite.dev/docs/api/wasm/#scan-element-proposals).
+
+```ts
+import { segmentScan } from '@ifc-lite/geometry/scan-segmentation';
+import { proposeScanElements } from '@ifc-lite/geometry/scan-proposals';
+
+const api = new IfcAPI(); // after the wasm module is initialised
+const positions = new Float32Array([/* x, y, z, ... Y-up metres */]);
+try {
+  const report = segmentScan(api, { positions }, { upAxis: [0, 1, 0] });
+  // Y-up (x, y, z) -> IFC Z-up (x, -z, y), row-major.
+  const scanToModel = [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1];
+  const { proposals } = proposeScanElements(api, report, { scanToModel, schema: 'IFC4' });
+  for (const p of proposals) {
+    console.log(p.id, p.ifcClass, p.basis, p.confidence.toFixed(2), p.geometry);
+  }
+} finally {
+  api.free();
+}
+```
+
 ## License
 
 [MPL-2.0](../../LICENSE)

package/dist/domain-export-call.d.ts

@@ -0,0 +1,4 @@
+import type { IfcAPI } from '@ifc-lite/wasm';
+/** Shared initialization/error boundary for canonical domain exports. */
+export declare function runDomainExport<T>(api: IfcAPI | null, operation: string, content: Uint8Array, run: (api: IfcAPI) => T, onError: (error: unknown) => void): T;
+//# sourceMappingURL=domain-export-call.d.ts.map

package/dist/domain-export-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-export-call.d.ts","sourceRoot":"","sources":["../src/domain-export-call.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI7C,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACrH,CAAC,CASH"}

package/dist/domain-export-call.js

@@ -0,0 +1,19 @@
+/* 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/. */
+import { createLogger } from '@ifc-lite/data';
+const log = createLogger('Geometry');
+/** Shared initialization/error boundary for canonical domain exports. */
+export function runDomainExport(api, operation, content, run, onError) {
+    if (!api)
+        throw new Error('IFC-Lite not initialized. Call init() first.');
+    try {
+        return run(api);
+    }
+    catch (error) {
+        log.error(`Failed to ${operation}`, error, { operation, data: { contentLength: content.length } });
+        onError(error);
+        throw error;
+    }
+}
+//# sourceMappingURL=domain-export-call.js.map

package/dist/domain-export-call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-export-call.js","sourceRoot":"","sources":["../src/domain-export-call.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;AAErC,yEAAyE;AACzE,MAAM,UAAU,eAAe,CAC7B,GAAkB,EAAE,SAAiB,EAAE,OAAmB,EAAE,GAAuB,EAAE,OAAiC;IAEtH,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAC1E,IAAI,CAAC;QACH,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,GAAG,CAAC,KAAK,CAAC,aAAa,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QACnG,OAAO,CAAC,KAAK,CAAC,CAAC;QACf,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

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

@@ -1,6 +1,8 @@
 import type { TessellationQuality } from './types.js';
 import type { BatchSizingConfig } from './batch-sizing.js';
 import type { StallPhaseHandle } from './stall-phase.js';
+import type { LoadTrace } from '@ifc-lite/load-trace';
+import type { GeometryWorkerPool } from './geometry-worker-pool.js';
 export interface ProcessParallelOptions {
     /** Fresh per-load fingerprint cell shared only with the matching parser. */
     sourceFingerprint?: SharedArrayBuffer;
@@ -121,5 +123,18 @@ export interface ProcessParallelOptions {
      * covers, not this issue's pre-worker class.
      */
     stallPhaseHandle?: StallPhaseHandle;
+    /**
+     * Issue #6956 — the caller's load trace. The pool records `geometry.pool`,
+     * `geometry.firstBatch`, the shard scan/stitch and pre-pass phases on it, and
+     * asks its workers to post their own spans back. Omitted ⇒ nothing recorded.
+     */
+    trace?: LoadTrace;
+    /**
+     * Lease the workers a host prewarmed for this load from this pool (#7036)
+     * instead of spawning them; any it lacks are spawned. Every worker still
+     * serves only this load and is terminated by it. Omitted, every worker is
+     * spawned here, as before.
+     */
+    workerPool?: GeometryWorkerPool;
 }
 //# sourceMappingURL=geometry-parallel-options.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geometry-parallel-options.d.ts","sourceRoot":"","sources":["../src/geometry-parallel-options.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,CACd,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,wBAAwB;IACzE,oBAAoB,CAAC,EAAE,MAAM,KAC1B,IAAI,CAAC;IACV;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5E;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC"}
+{"version":3,"file":"geometry-parallel-options.d.ts","sourceRoot":"","sources":["../src/geometry-parallel-options.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,CACd,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,wBAAwB;IACzE,oBAAoB,CAAC,EAAE,MAAM,KAC1B,IAAI,CAAC;IACV;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACjD;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5E;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC"}

package/dist/geometry-parallel.d.ts

@@ -22,53 +22,8 @@
 import type { ProcessParallelOptions } from './geometry-parallel-options.js';
 import type { CoordinateHandler } from './coordinate-handler.js';
 import type { StreamingGeometryEvent } from './index.js';
-/**
- * Prepass class-byte layout, mirroring the `PREPASS_CLASS_*` definitions in
- * `rust/processing/src/shard_classes.rs` (the source of truth — these are
- * pinned to it by `prepass-class-spans.test.ts`).
- *
- * The producer packs a named code in the LOW bits and composes FLAG bits on
- * top (`PREPASS_CLASS_FLAG_GEOMETRY_JOB` 0x80, `..._FLAG_TYPE_CANDIDATE`
- * 0x40), so a consumer must mask before comparing — the Rust consumer does
- * (`gpu_meshes/prepass_discovery.rs`), and so does {@link extractPrepassSpanLists}.
- */
-export declare const PREPASS_CLASS_CODE_MASK = 63;
-/** `IFCSTYLEDITEM`. */
-export declare const PREPASS_CLASS_STYLED_ITEM = 4;
-/** `IFCINDEXEDCOLOURMAP`. */
-export declare const PREPASS_CLASS_INDEXED_COLOUR_MAP = 5;
-/** `IFCMATERIALDEFINITIONREPRESENTATION`. */
-export declare const PREPASS_CLASS_MATERIAL_DEF_REPR = 6;
-/** `IFCRELASSOCIATESMATERIAL`. */
-export declare const PREPASS_CLASS_REL_ASSOCIATES_MATERIAL = 7;
-/** `IFCRELVOIDSELEMENT`. */
-export declare const PREPASS_CLASS_REL_VOIDS = 8;
-/** `IFCRELFILLSELEMENT`. */
-export declare const PREPASS_CLASS_REL_FILLS = 9;
-/** `IFCRELAGGREGATES`. */
-export declare const PREPASS_CLASS_REL_AGGREGATES = 10;
-/**
- * Build one `(id, start, length)` span list per host-consumed prepass class
- * from the stitched shard columns, in FILE ORDER. Every comparison goes
- * through {@link PREPASS_CLASS_CODE_MASK}, so a record that carries a flag bit
- * alongside its named code still lands in its list instead of being dropped.
- * Returns exact-size arrays (one entry per class in `HOST_SPAN_CLASSES`,
- * empty when the file has none).
- */
-export declare function extractPrepassSpanLists(classes: Uint8Array, ids: Uint32Array, starts: Uint32Array, lengths: Uint32Array): Map<number, Uint32Array>;
-/**
- * Plan content-affinity routing for one chunk: assign each job (by index) to a
- * worker bucket so that every job sharing an affinity key lands on the SAME
- * worker — across the whole stream, since `keyToWorker` is the caller's sticky
- * map. New keys are handed out round-robin from `startWorker`, so each worker
- * owns roughly `1/workerCount` of the distinct keys (≈ distinct geometries, the
- * dominant meshing cost). Pure: mutates only the passed `keyToWorker` and returns
- * the advanced round-robin cursor. (#1130 follow-up — see `affinity_key` in Rust.)
- */
-export declare function planAffinityRouting(affinity: Uint32Array, totalJobs: number, workerCount: number, keyToWorker: Map<number, number>, startWorker: number): {
-    buckets: number[][];
-    nextWorker: number;
-};
+export { GeometryWorkerPool, DEFAULT_POOL_LIMITS, FRESH_WORKER_HEAP_BYTES } from './geometry-worker-pool.js';
+export { PREPASS_CLASS_CODE_MASK, PREPASS_CLASS_STYLED_ITEM, PREPASS_CLASS_INDEXED_COLOUR_MAP, PREPASS_CLASS_MATERIAL_DEF_REPR, PREPASS_CLASS_REL_ASSOCIATES_MATERIAL, PREPASS_CLASS_REL_VOIDS, PREPASS_CLASS_REL_FILLS, PREPASS_CLASS_REL_AGGREGATES, extractPrepassSpanLists, planAffinityRouting, } from './prepass-routing.js';
 export type { ProcessParallelOptions } from './geometry-parallel-options.js';
 export declare function processParallel(buffer: Uint8Array, coordinator: CoordinateHandler, sharedRtcOffset?: {
     x: number;

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

@@ -1 +1 @@
-{"version":3,"file":"geometry-parallel.d.ts","sourceRoot":"","sources":["../src/geometry-parallel.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAG7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAyBzD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAC5C,uBAAuB;AACvB,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,6BAA6B;AAC7B,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAClD,6CAA6C;AAC7C,eAAO,MAAM,+BAA+B,IAAI,CAAC;AACjD,kCAAkC;AAClC,eAAO,MAAM,qCAAqC,IAAI,CAAC;AACvD,4BAA4B;AAC5B,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,4BAA4B;AAC5B,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,0BAA0B;AAC1B,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAa/C;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,WAAW,GACnB,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAmB1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,WAAW,EAAE,MAAM,GAClB;IAAE,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAc7C;AA4FD,YAAY,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAI7E,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;AACrD,gFAAgF;AAChF,WAAW,CAAC,EAAE,iBAAiB,EAC/B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAAC,sBAAsB,CAAC,CA83CxC"}
+{"version":3,"file":"geometry-parallel.d.ts","sourceRoot":"","sources":["../src/geometry-parallel.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAazD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAgB7G,OAAO,EACL,uBAAuB,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,+BAA+B,EACrH,qCAAqC,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,4BAA4B,EACrH,uBAAuB,EAAE,mBAAmB,GAC7C,MAAM,sBAAsB,CAAC;AAuD9B,YAAY,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAM7E,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;AACrD,gFAAgF;AAChF,WAAW,CAAC,EAAE,iBAAiB,EAC/B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,cAAc,CAAC,sBAAsB,CAAC,CAu4CxC"}

package/dist/geometry-parallel.js

@@ -3,7 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 import { postGeometryWorkerInit } from './geometry-worker-init.js';
 import { mergeGeometryDiagnostics } from './diagnostics.js';
-import { computeWorkerCount } from './worker-count.js';
+import { planLoadWorkerCount } from './worker-count.js';
+import { readBatchSizingOverride, readShardScanFlag, readVisibilityFilterOverride } from './perf-flags.js';
 import { notifyIfWasmAssetUnavailable, notifyIfWorkerScriptUnavailable } from './wasm-asset-error.js';
 import { restashWasmPanicLocation } from './wasm-panic-forward.js';
 import { mergeShardStyleSlices } from './shard-style-merge.js';
@@ -12,138 +13,14 @@ import { mergeShardStyleSlices } from './shard-style-merge.js';
 // (and vice versa) instead of fetching the same binary a second time.
 import { compileSharedWasmModule } from './wasm-shared-module.js';
 import { stitchShards } from './shard-stitch.js';
+import { spawnGeometryWorker } from './geometry-worker-pool.js';
+export { GeometryWorkerPool, DEFAULT_POOL_LIMITS, FRESH_WORKER_HEAP_BYTES } from './geometry-worker-pool.js';
+import { NOOP_LOAD_TRACE, accountWorkerMessages, countCopy, enableWorkerTrace, isTraceSpansMessage } from '@ifc-lite/load-trace';
 import { resolveRtcFrame } from './rtc-frame.js';
 import { emptyStylesPrepassEvent, frozenStallPhase, GateTracker, PhaseBoundTimers, preWorkerPhaseFailureDiagnostics, } from './stall-phase.js';
 import { SkippedHungElementsCollector, startHungJobMonitor, WorkerJobLedger, } from './hung-job-recovery.js';
-/**
- * Prepass class-byte layout, mirroring the `PREPASS_CLASS_*` definitions in
- * `rust/processing/src/shard_classes.rs` (the source of truth — these are
- * pinned to it by `prepass-class-spans.test.ts`).
- *
- * The producer packs a named code in the LOW bits and composes FLAG bits on
- * top (`PREPASS_CLASS_FLAG_GEOMETRY_JOB` 0x80, `..._FLAG_TYPE_CANDIDATE`
- * 0x40), so a consumer must mask before comparing — the Rust consumer does
- * (`gpu_meshes/prepass_discovery.rs`), and so does {@link extractPrepassSpanLists}.
- */
-export const PREPASS_CLASS_CODE_MASK = 0x3f;
-/** `IFCSTYLEDITEM`. */
-export const PREPASS_CLASS_STYLED_ITEM = 4;
-/** `IFCINDEXEDCOLOURMAP`. */
-export const PREPASS_CLASS_INDEXED_COLOUR_MAP = 5;
-/** `IFCMATERIALDEFINITIONREPRESENTATION`. */
-export const PREPASS_CLASS_MATERIAL_DEF_REPR = 6;
-/** `IFCRELASSOCIATESMATERIAL`. */
-export const PREPASS_CLASS_REL_ASSOCIATES_MATERIAL = 7;
-/** `IFCRELVOIDSELEMENT`. */
-export const PREPASS_CLASS_REL_VOIDS = 8;
-/** `IFCRELFILLSELEMENT`. */
-export const PREPASS_CLASS_REL_FILLS = 9;
-/** `IFCRELAGGREGATES`. */
-export const PREPASS_CLASS_REL_AGGREGATES = 10;
-/** The classes the host builds span lists for (every other code is ignored). */
-const HOST_SPAN_CLASSES = [
-    PREPASS_CLASS_STYLED_ITEM,
-    PREPASS_CLASS_INDEXED_COLOUR_MAP,
-    PREPASS_CLASS_MATERIAL_DEF_REPR,
-    PREPASS_CLASS_REL_ASSOCIATES_MATERIAL,
-    PREPASS_CLASS_REL_VOIDS,
-    PREPASS_CLASS_REL_FILLS,
-    PREPASS_CLASS_REL_AGGREGATES,
-];
-/**
- * Build one `(id, start, length)` span list per host-consumed prepass class
- * from the stitched shard columns, in FILE ORDER. Every comparison goes
- * through {@link PREPASS_CLASS_CODE_MASK}, so a record that carries a flag bit
- * alongside its named code still lands in its list instead of being dropped.
- * Returns exact-size arrays (one entry per class in `HOST_SPAN_CLASSES`,
- * empty when the file has none).
- */
-export function extractPrepassSpanLists(classes, ids, starts, lengths) {
-    // Sized by the code mask rather than by the highest class the host consumes:
-    // a masked code is always < 64, so a class added on the Rust side cannot
-    // write out of bounds here (typed arrays discard such writes silently).
-    const counts = new Uint32Array(PREPASS_CLASS_CODE_MASK + 1);
-    for (let i = 0; i < classes.length; i++)
-        counts[classes[i] & PREPASS_CLASS_CODE_MASK]++;
-    const slots = new Map();
-    for (const k of HOST_SPAN_CLASSES)
-        slots.set(k, { arr: new Uint32Array(counts[k] * 3), w: 0 });
-    for (let i = 0; i < classes.length; i++) {
-        const slot = slots.get(classes[i] & PREPASS_CLASS_CODE_MASK);
-        if (!slot)
-            continue;
-        slot.arr[slot.w] = ids[i];
-        slot.arr[slot.w + 1] = starts[i];
-        slot.arr[slot.w + 2] = lengths[i];
-        slot.w += 3;
-    }
-    const spans = new Map();
-    for (const [k, slot] of slots)
-        spans.set(k, slot.arr);
-    return spans;
-}
-/**
- * Plan content-affinity routing for one chunk: assign each job (by index) to a
- * worker bucket so that every job sharing an affinity key lands on the SAME
- * worker — across the whole stream, since `keyToWorker` is the caller's sticky
- * map. New keys are handed out round-robin from `startWorker`, so each worker
- * owns roughly `1/workerCount` of the distinct keys (≈ distinct geometries, the
- * dominant meshing cost). Pure: mutates only the passed `keyToWorker` and returns
- * the advanced round-robin cursor. (#1130 follow-up — see `affinity_key` in Rust.)
- */
-export function planAffinityRouting(affinity, totalJobs, workerCount, keyToWorker, startWorker) {
-    const buckets = Array.from({ length: workerCount }, () => []);
-    let nextWorker = startWorker % workerCount;
-    for (let j = 0; j < totalJobs; j++) {
-        const key = affinity[j];
-        let w = keyToWorker.get(key);
-        if (w === undefined) {
-            w = nextWorker;
-            nextWorker = (nextWorker + 1) % workerCount;
-            keyToWorker.set(key, w);
-        }
-        buckets[w].push(j);
-    }
-    return { buckets, nextWorker };
-}
-/**
- * Optional runtime override for the geometry worker's adaptive batch sizing
- * (#1097), read off `globalThis` on the host thread. A zero-cost escape hatch
- * for hardware-specific tuning / field-debugging the watchdog↔throughput
- * trade-off without a rebuild; unset ⇒ the worker uses DEFAULT_BATCH_SIZING.
- * Validation/merge happens in the worker via `resolveBatchSizing`.
- */
-function readBatchSizingOverride() {
-    const g = globalThis;
-    const v = g.__IFC_LITE_BATCH_SIZING;
-    return v && typeof v === 'object' ? v : undefined;
-}
-/**
- * Optional load-time visibility filter (#1097), read off `globalThis` on the
- * host thread (tuning / benchmarking escape hatch). `{ disabledTypes,
- * skipTypeGeometry }` skip the matching geometry jobs at the prepass so they're
- * never decoded/meshed/uploaded. Unset ⇒ load everything.
- */
-function readVisibilityFilterOverride() {
-    const g = globalThis;
-    const v = g.__IFC_LITE_VISIBILITY_FILTER;
-    return v && typeof v === 'object' ? v : undefined;
-}
-/**
- * SPIKE flag: shard the entity-index scan across the idle geometry workers and
- * deliver the stitched index early, instead of waiting for the pre-pass
- * worker's single-threaded post-scan `entity-index` emission. Read off
- * `globalThis.__IFC_LITE_SHARD_SCAN` (benchmark A/B knob). Truthy ⇒ on.
- */
-function readShardScanFlag() {
-    const g = globalThis;
-    const v = g.__IFC_LITE_SHARD_SCAN;
-    // ON by default; 0/'0'/false is the kill switch (same convention as the
-    // other #1682 load/render knobs).
-    if (v === 0 || v === '0' || v === false)
-        return false;
-    return true;
-}
+export { PREPASS_CLASS_CODE_MASK, PREPASS_CLASS_STYLED_ITEM, PREPASS_CLASS_INDEXED_COLOUR_MAP, PREPASS_CLASS_MATERIAL_DEF_REPR, PREPASS_CLASS_REL_ASSOCIATES_MATERIAL, PREPASS_CLASS_REL_VOIDS, PREPASS_CLASS_REL_FILLS, PREPASS_CLASS_REL_AGGREGATES, extractPrepassSpanLists, planAffinityRouting, } from './prepass-routing.js';
+import { PREPASS_CLASS_STYLED_ITEM, PREPASS_CLASS_INDEXED_COLOUR_MAP, PREPASS_CLASS_MATERIAL_DEF_REPR, PREPASS_CLASS_REL_ASSOCIATES_MATERIAL, PREPASS_CLASS_REL_VOIDS, PREPASS_CLASS_REL_FILLS, PREPASS_CLASS_REL_AGGREGATES, extractPrepassSpanLists, planAffinityRouting, } from './prepass-routing.js';
 /**
  * Terminate a pool worker on a teardown path that is already unwinding.
  *
@@ -182,10 +59,15 @@ function entityIndexSetup(columns) {
     };
 }
 let nextSourceSessionId = 0;
+/** A load above this size terminates the prewarmed workers it did not lease (#7036). */
+const LARGE_LOAD_POOL_DRAIN_MB = 64;
 export async function* processParallel(buffer, coordinator, sharedRtcOffset, 
 /** Optional pre-allocated SAB the caller already shares with another worker. */
 existingSab, options) {
     const sourceSessionId = `geometry-source-${++nextSourceSessionId}`;
+    // #6956: spans for this pool; worker spans hang under `geometry.pool`.
+    const trace = options?.trace ?? NOOP_LOAD_TRACE;
+    let poolSpan = -1, tracedWorkers = 0;
     coordinator.reset();
     yield { type: 'start', totalEstimate: buffer.length / 1000 };
     yield { type: 'model-open', modelID: 0 };
@@ -210,12 +92,18 @@ existingSab, options) {
     }
     else {
         sharedBuffer = new SharedArrayBuffer(buffer.byteLength);
-        new Uint8Array(sharedBuffer).set(buffer);
+        new Uint8Array(sharedBuffer).set(countCopy('source.geometrySab', buffer));
     }
     // N independent WASM-instance workers, each running
     // `geometry.worker.js` (one `@ifc-lite/wasm` instance per worker).
-    const makeGeometryWorker = () => new Worker(new URL('./geometry.worker.js', import.meta.url), { type: 'module' });
-    const makePrepassWorker = () => new Worker(new URL('./geometry.worker.js', import.meta.url), { type: 'module' });
+    // #6957: `accountWorkerMessages` counts each pool's messages per direction (identity when counters are off).
+    // #7036: lease the workers a host prewarmed when this load was requested
+    // (spawned beside the file read); spawn the rest. Either way a worker serves
+    // this load only and is terminated by it, exactly as before.
+    const pool = options?.workerPool ?? null, poolKey = options?.wasmUrls?.wasm ?? '';
+    const acquireWorker = (role, thread) => enableWorkerTrace(pool ? pool.acquire(role, poolKey).worker : accountWorkerMessages(spawnGeometryWorker(), role), trace, thread);
+    const makeGeometryWorker = () => acquireWorker('geometry', `geom-${tracedWorkers++}`);
+    const makePrepassWorker = () => acquireWorker('prepass', 'prepass');
     // Shared aggregator state used by every worker callback below.
     const eventQueue = [];
     let resolveWaiting = null;
@@ -274,7 +162,7 @@ existingSab, options) {
     let entityIndexDeliveredEarly = false;
     const shardResults = [];
     let shardResultsRemaining = 0;
-    let shardScanDispatchedAt = -1;
+    let shardScanDispatchedAt = -1, shardScanSpan = -1;
     // #4902: settles once, normally or via the bounded-wait timeout below.
     let shardScanSettled = false;
     let stylesSlicesSettled = false;
@@ -316,6 +204,10 @@ existingSab, options) {
             workerSpoke = true;
             ledger.onHeard(workerIndex, performance.now());
             const msg = e.data;
+            if (isTraceSpansMessage(msg)) {
+                trace.merge(msg.payload, poolSpan);
+                return;
+            }
             if (msg.type === 'ready') {
                 console.log(`[stream] worker[${workerIndex}] WASM ready @ ${elapsed()}ms`);
                 return;
@@ -394,6 +286,11 @@ existingSab, options) {
                 }
                 if (msg.diagnostics)
                     diagnostics = mergeGeometryDiagnostics(diagnostics, msg.diagnostics);
+                // An in-call heartbeat (no seq) past the absolute call bound no longer
+                // counts as liveness, so with recovery off the consumer watchdog still
+                // bounds a call that reports progress forever (MAX_GEOMETRY_CALL_MS).
+                if (typeof msg.seq !== 'number' && ledger.callOverCap(workerIndex, performance.now()))
+                    return;
                 eventQueue.push({ type: 'progress', phase: 'workers' });
                 wake();
                 return;
@@ -405,6 +302,7 @@ existingSab, options) {
             if (msg.type === 'batch') {
                 if (firstBatchByWorker[workerIndex] === undefined) {
                     firstBatchByWorker[workerIndex] = elapsed();
+                    trace.milestone('geometry.firstBatch');
                     console.log(`[stream] worker[${workerIndex}] first batch @ ${elapsed()}ms (${msg.meshes?.length ?? 0} meshes)`);
                 }
                 // The worker already emits `MeshData`-shaped objects (see the worker's
@@ -521,18 +419,8 @@ existingSab, options) {
     // totalJobs estimate; use file-size proxy. The memory-budget cap in
     // `computeWorkerCount` keeps an over-estimate harmless, and still bounds an
     // explicit `workerCountOverride` so the A/B knob can't OOM the tab.
-    const cores = typeof navigator !== 'undefined' ? (navigator.hardwareConcurrency ?? 2) : 2;
-    const deviceMemoryGB = typeof navigator !== 'undefined'
-        ? (navigator.deviceMemory ?? 8) : 8;
     const fileSizeMB = buffer.byteLength / (1024 * 1024);
-    const estimatedJobs = Math.max(1, Math.ceil(fileSizeMB * 100));
-    const workerCountResult = computeWorkerCount({
-        fileSizeMB,
-        cores,
-        deviceMemoryGB,
-        totalJobs: estimatedJobs,
-        workerCountOverride: options?.workerCountOverride,
-    });
+    const { cores, ...workerCountResult } = planLoadWorkerCount(fileSizeMB, options?.workerCountOverride);
     const workerCount = workerCountResult.count;
     // Await the ONE shared compile (started up-front) so every worker instantiates
     // the SAME module via `initSync` instead of recompiling the binary N+1 times.
@@ -788,6 +676,8 @@ existingSab, options) {
     // Step-by-step timing so we can tell exactly where time goes.
     const t0 = performance.now();
     const elapsed = () => Math.round(performance.now() - t0);
+    trace.setAttrs({ workerCount });
+    poolSpan = trace.begin('geometry.pool', { workerCount });
     const overrideNote = options?.workerCountOverride != null
         ? ` (override=${options.workerCountOverride}, bound=${workerCountResult.reason})`
         : ` (cores=${cores}, bound=${workerCountResult.reason})`;
@@ -807,6 +697,7 @@ existingSab, options) {
     // record the parser will not find" but "every record after it is missing".
     malformedRecordCount) => {
         console.log(`[stream] entity-index (${source}) @ ${elapsed()}ms (${ids.length} entries)`);
+        trace.milestone('geometry.entityIndex');
         if (typeof SharedArrayBuffer !== 'undefined') {
             // Sharded-stitch columns arrive already SAB-backed (stitchShards writes
             // its exact-size output into SABs) — share them as-is. The serial
@@ -874,8 +765,9 @@ existingSab, options) {
             return;
         shardScanSettled = true;
         gateTracker.markShardScanDone();
+        trace.end(shardScanSpan);
         const shards = shardResults;
-        const stitched = stitchShards(shards);
+        const stitched = trace.span('shard.stitch', () => stitchShards(shards), undefined, poolSpan);
         if (!stitched) {
             console.warn('[stream][shard] stitch fallback triggered (handoff not found) — serial pre-pass');
             startPrepass(false);
@@ -1020,6 +912,7 @@ existingSab, options) {
         shardResults.length = n;
         shardResultsRemaining = n;
         shardScanDispatchedAt = elapsed();
+        shardScanSpan = trace.begin('geometry.shardScan', { shards: n }, poolSpan);
         gateTracker.markShardScanStarted();
         console.log(`[stream][shard] dispatching ${n} shard scans over ${(len / (1024 * 1024)).toFixed(1)}MB @ ${shardScanDispatchedAt}ms`);
         for (let i = 0; i < n; i++) {
@@ -1039,6 +932,7 @@ existingSab, options) {
             shardScanSettled = true;
             gateTracker.markShardScanDone();
             console.warn(`[stream][shard] ${shardResultsRemaining}/${n} shard scan(s) silent — falling back to the serial pre-pass (#4902)`);
+            trace.end(shardScanSpan, { fallback: true });
             diagnostics = mergeGeometryDiagnostics(diagnostics, preWorkerPhaseFailureDiagnostics('shard-scan-timeout'));
             // Replace every worker still silent on scan-shard BEFORE continuing:
             // `scan-shard` is a synchronous WASM call, so a missing reply means
@@ -1052,6 +946,9 @@ existingSab, options) {
         });
     }
     const prepassWorker = makePrepassWorker();
+    // #7036: idle workers this large load did not lease would only add to its peak.
+    if (pool && fileSizeMB > LARGE_LOAD_POOL_DRAIN_MB)
+        pool.drain('large-load');
     // 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
@@ -1111,6 +1008,10 @@ existingSab, options) {
         prepassWorker.onmessage = (e) => {
             prepassSpoke = true;
             const data = e.data;
+            if (isTraceSpansMessage(data)) {
+                trace.merge(data.payload, poolSpan);
+                return;
+            }
             if (data.type === 'prepass-progress') {
                 eventQueue.push({ type: 'progress', phase: 'prepass' });
                 wake();
@@ -1164,6 +1065,7 @@ existingSab, options) {
                     const materialColorCounts = evt.materialColorCounts ?? new Uint32Array(0);
                     const materialColors = evt.materialColors ?? new Uint8Array(0);
                     console.log(`[stream] styles @ ${elapsed()}ms (${styleIds.length} styled, ${voidKeys.length} void hosts), draining ${queuedChunks.length} queued chunks`);
+                    trace.milestone('prepass.styles');
                     broadcastSetup((w) => {
                         // Slice each typed array per-worker so each can be in its own
                         // transfer list without conflict. The slice cost is bounded by
@@ -1290,6 +1192,7 @@ existingSab, options) {
                 else if (evt.type === 'complete') {
                     prepassJobsTotal = evt.totalJobs;
                     console.log(`[stream] prepass complete @ ${elapsed()}ms totalJobs=${prepassJobsTotal} chunks=${chunkArrivals}`);
+                    trace.milestone('prepass.complete');
                     // Unconditionally drive the prepass-complete handler here.
                     // The outer loop's `prepassJobsTotal > 0` gate would skip
                     // zero-geometry files (no IFC geometry entities), causing
@@ -1501,6 +1404,7 @@ existingSab, options) {
         };
     }
     finally {
+        trace.end(poolSpan);
         phaseBoundTimers.clearAll();
         // Re-seat the caller's handle to a frozen snapshot (#4979 review): the
         // live reader closes over `gateTracker`, and transitively this whole