rayzee 7.31.0 → 8.0.0

package/src/Processor/SceneProcessor.js

@@ -3,18 +3,29 @@ import { BVHBuilder } from './BVHBuilder.js';
 import { BVHRefitter } from './BVHRefitter.js';
 import { buildBVHParallel, shouldUseParallelBuild } from './ParallelBVHBuilder.js';
 import { TLASBuilder } from './TLASBuilder.js';
-import { InstanceTable } from './InstanceTable.js';
+import { InstanceTable, isIdentity, multiplyAffine } from './InstanceTable.js';
+import { ChunkedRecords, SHARED_MEMORY_AVAILABLE, setChunkObserver } from './ChunkedRecords.js';
+import {
+	MemoryLedger, estimateSceneBytes, probeAddressSpace,
+	PREFLIGHT_MIN_BYTES, PREFLIGHT_SAFETY, SAFE_SCENE_BYTES, MAX_SCENE_BYTES,
+} from './HostMemory.js';
 import { TextureCreator } from './TextureCreator.js';
-import { GeometryExtractor } from './GeometryExtractor.js';
+import { GeometryExtractor, geometryBytesOf } from './GeometryExtractor.js';
 import { EmissiveTriangleBuilder } from './EmissiveTriangleBuilder.js';
 import { updateLoading } from '../Processor/utils.js';
 import { BuildTimer } from './BuildTimer.js';
 import { createLogger, fmt, workerLogLevel } from '../utils/Logger.js';
 import { SRGBColorSpace } from 'three';
-import { TRIANGLE_DATA_LAYOUT, TEXTURE_CONSTANTS, getTextureBucketId, packTextureIndex, planTextureBuckets } from '../EngineDefaults.js';
+import {
+	TRIANGLE_DATA_LAYOUT, TEXTURE_CONSTANTS, getTextureBucketId, packTextureIndex, planTextureBuckets,
+	packNormalOct, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView, TLAS_PLACEMENT_MASK } from '../EngineDefaults.js';
 import { ISSUE_CODES } from '../EngineIssues.js';
 import BVHWorker from './Workers/BVHWorker.js?worker&inline';
 import BVHRefitWorker from './Workers/BVHRefitWorker.js?worker&inline';
+import TLASWorker from './Workers/TLASWorker.js?worker&inline';
+
+// Under this the TLAS build is a few ms; the worker round trip would cost more than it saves.
+const TLAS_WORKER_MIN_ENTRIES = 50_000;
 
 const log = createLogger( 'scene' );
 
@@ -35,6 +46,9 @@ export class SceneProcessor {
      * @param {string} [options.textureQuality='adaptive'] - Texture quality mode
      * @param {boolean} [options.enableTextureCache=true] - Enable texture caching
      * @param {import('../EngineIssues.js').IssueLog} [options.issues] - forwarded to TextureCreator
+     * @param {number} [options.maxSceneBytes] - refuse a scene estimated above this many CPU
+     *   bytes. Defaults to {@link MAX_SCENE_BYTES}; past it the renderer process dies rather
+     *   than throwing, so there is nothing to catch. Raise it to try a bigger scene anyway.
      */
 	constructor( options = {} ) {
 
@@ -49,6 +63,7 @@ export class SceneProcessor {
 			maxTextureSize: TEXTURE_CONSTANTS.DEFAULT_MAX_TEXTURE_SIZE, // longest-edge cap for material textures
 			enableTextureCache: true,
 			maxConcurrentTextureTasks: Math.min( navigator.hardwareConcurrency || 4, 6 ),
+			maxSceneBytes: MAX_SCENE_BYTES,
 			// Treelet optimization configuration
 			// Keep: `_buildBVH` sends `enabled: value !== false`, so undefined re-enables treelets.
 			enableTreeletOptimization: false,
@@ -61,7 +76,8 @@ export class SceneProcessor {
 		};
 
 		// Initialize geometry data containers
-		this.triangleData = null; // Efficient format (Float32Array)
+		this.triangleData = null; // uint lanes; this.triangleFloats views the same memory
+		this.triangleFloats = null;
 		this.triangleCount = 0; // Number of triangles
 		this.materials = [];
 		this.maps = [];
@@ -87,12 +103,14 @@ export class SceneProcessor {
 		this.bvhRoot = null;
 
 		// Raw data for storage buffers
+		this.bvh = null;
 		this.bvhData = null;
+		this.bvhIndexChunks = null;
+		this.bvhIndex = null;
 		this.materialData = null;
 
 		// Two-level BVH (TLAS/BLAS) support
 		this.instanceTable = null; // Per-mesh BLAS metadata
-		this.originalToBvhMap = null; // Uint32Array: original tri index → BVH-order index (global, for legacy compat)
 		this._refitWorker = null;
 		this._refitSharedBuffers = null; // SharedArrayBuffer refs for zero-copy refit
 		this._rebuildGeneration = 0; // Monotonic counter to discard stale background rebuilds
@@ -118,11 +136,18 @@ export class SceneProcessor {
 		this.isProcessing = false;
 		this.processingStage = null;
 
+		// What the build spent, by phase, and what the preflight expected it to spend.
+		this.memory = new MemoryLedger();
+		this.memoryPreflight = null;
+
 		// Performance tracking
 		this.performanceMetrics = {
 			textureCreationTime: 0,
 			geometryExtractionTime: 0,
 			bvhBuildTime: 0,
+			blasBuildTime: 0,
+			tlasBuildTime: 0,
+			bvhAssembleTime: 0,
 			totalProcessingTime: 0
 		};
 
@@ -170,6 +195,8 @@ export class SceneProcessor {
 
 		// Create TLAS builder for two-level BVH
 		this.tlasBuilder = new TLASBuilder();
+		this._tlasWorker = null;
+		this._tlasWorkerFailed = false;
 
 	}
 
@@ -185,6 +212,191 @@ export class SceneProcessor {
 
 	}
 
+	/**
+	 * Price the scene before the build starts spending, and say so if it is over what a healthy
+	 * session can place.
+	 *
+	 * Estimate only — no allocation. Probing the whole scene up front was measurably worse than
+	 * not checking: the probe's peak lands on top of the parse's, and a 9 GB probe taken while
+	 * the parser still held 3.6 GB doubled a 40M load from 135 s to 268 s. The allocation test
+	 * belongs at the step that actually runs out, which is
+	 * {@link SceneProcessor#_checkAssemblyHeadroom}.
+	 *
+	 * The geometry figure reads before `_compressAttributes` halves normals and colours, so it
+	 * runs ~7% high on a typical scene. That direction is the safe one.
+	 * @private
+	 */
+	_preflightMemory( object ) {
+
+		const maxBytes = this.config.maxSceneBytes ?? MAX_SCENE_BYTES;
+		const survey = this.geometryExtractor.surveyScene( object );
+		const estimate = estimateSceneBytes( survey );
+		const report = {
+			...survey, estimate,
+			safeBytes: SAFE_SCENE_BYTES, maxBytes,
+			fits: estimate.total <= SAFE_SCENE_BYTES,
+		};
+		this.memoryPreflight = report;
+
+		if ( estimate.total < PREFLIGHT_MIN_BYTES ) return report;
+
+		log.debug( fmt.list( [
+			`memory preflight: ${fmt.mb( estimate.total )} estimated`,
+			`triangles ${fmt.mb( estimate.triangles )} · bvh ${fmt.mb( estimate.bvh )} · geometry ${fmt.mb( estimate.geometry )}`,
+			`${fmt.n( survey.triangles )} tris · ${fmt.n( survey.placements )} placements`,
+		] ) );
+
+		// Past the hard line the renderer process dies rather than throwing, so there is nothing
+		// to catch and nothing to degrade to. Refusing with a reason is the only useful answer.
+		if ( estimate.total > maxBytes ) {
+
+			const message = `Scene needs about ${fmt.mb( estimate.total )} of CPU memory, past the ${fmt.mb( maxBytes )} `
+				+ 'a browser tab can hold — loading it would crash the tab rather than fail. '
+				+ `Reduce the scene (it has ${fmt.n( survey.triangles )} triangles), or raise maxSceneBytes to try anyway.`;
+
+			this.config.issues?.record(
+				ISSUE_CODES.SCENE_MEMORY_BUDGET, message, { ...survey, estimate, maxBytes }
+			);
+			throw new Error( message );
+
+		}
+
+		if ( ! report.fits ) {
+
+			this.config.issues?.warn(
+				ISSUE_CODES.SCENE_MEMORY_BUDGET,
+				`Scene needs about ${fmt.mb( estimate.total )} of CPU memory, above the ${fmt.mb( SAFE_SCENE_BYTES )} a fresh browser `
+					+ 'session can usually place. It may still load, but a long-running session will probably fail during BVH assembly; '
+					+ 'restarting the browser recovers the address space.',
+				{ ...survey, estimate, safeBytes: SAFE_SCENE_BYTES }
+			);
+
+		}
+
+		return report;
+
+	}
+
+	/**
+	 * Test the one allocation that has failed every time: the combined BVH.
+	 *
+	 * By this point the archive and the parser's scratch are gone and the BLASes are about to be
+	 * handed over chunk by chunk, so the probe is small (the BVH's own size plus headroom, ~2 GB
+	 * at 40M rather than the whole scene's 9 GB) and it is asking the question at the moment the
+	 * answer matters. A failure here is still only a warning — the build is allowed to try.
+	 * @private
+	 */
+	_checkAssemblyHeadroom( totalNodes ) {
+
+		const need = totalNodes * 64;
+		if ( need < PREFLIGHT_MIN_BYTES ) return true;
+
+		// Same flavour the store uses: shared and non-shared buffers need not come from one pool.
+		const probe = probeAddressSpace( Math.ceil( need * PREFLIGHT_SAFETY ), { shared: SHARED_MEMORY_AVAILABLE } );
+		if ( this.memoryPreflight ) this.memoryPreflight.assemblyProbed = probe.placed;
+
+		if ( probe.exhausted ) {
+
+			this.config.issues?.warn(
+				ISSUE_CODES.SCENE_MEMORY_BUDGET,
+				`BVH assembly needs ${fmt.mb( need )} but only ${fmt.mb( probe.placed )} could be allocated. `
+					+ 'Restarting the browser usually recovers the address space.',
+				{ totalNodes, need, placeable: probe.placed }
+			);
+
+		}
+
+		return ! probe.exhausted;
+
+	}
+
+	/**
+	 * Byte sizes of the CPU structures alive right now. Anything already released is absent,
+	 * which is the point: this is what the peak is made of, not what was ever allocated.
+	 * @private
+	 */
+	_liveMemoryParts() {
+
+		const table = this.instanceTable;
+		const parts = {
+			triangles: this.triangles?.byteLength ?? 0,
+			bvh: this.bvh?.byteLength ?? 0,
+			geometry: this._geometryBytes ?? this.memoryPreflight?.geometryBytes ?? 0,
+			placements: table?.world?.byteLength ?? 0,
+			blasScratch: 0,
+			orderMaps: 0,
+		};
+
+		if ( table ) {
+
+			for ( const blas of table.blasData.values() ) parts.blasScratch += blas?.byteLength ?? 0;
+			for ( const m of table.bvhToOriginal.values() ) parts.orderMaps += m?.byteLength ?? 0;
+			for ( const m of table.originalToBvhMap.values() ) parts.orderMaps += m?.byteLength ?? 0;
+
+		}
+
+		return parts;
+
+	}
+
+	/**
+	 * World-space bounds of everything in the BVH, as `{ min: [x,y,z], max: [x,y,z] }`.
+	 *
+	 * ⚠️ Node 0 is not "the root's box". A BVH inner node stores its two CHILDREN's boxes —
+	 * `[Amin, Aidx, Amax, _, Bmin, Bidx, Bmax, _]` — so the first six floats are one subtree,
+	 * not the scene. Reading them as the scene box is wrong and looks plausible: the two halves
+	 * legitimately rebalance between a build and a refit, so the number moves while the actual
+	 * bounds are unchanged. Verified against the union of all 3.7M placement AABBs at 40M.
+	 *
+	 * @returns {?{min: number[], max: number[]}} null before a BVH is built
+	 */
+	sceneBounds() {
+
+		if ( ! this.bvh || this.bvh.recordCount === 0 ) return null;
+
+		const chunk = this.bvh.chunkFor( 0 );
+		const base = this.bvh.baseOf( 0 );
+		const min = [], max = [];
+
+		for ( let k = 0; k < 3; k ++ ) {
+
+			min.push( Math.min( chunk[ base + k ], chunk[ base + 8 + k ] ) );
+			max.push( Math.max( chunk[ base + 4 + k ], chunk[ base + 12 + k ] ) );
+
+		}
+
+		return { min, max };
+
+	}
+
+	/** @private */
+	_sampleMemory( label ) {
+
+		this.memory.sample( label, this._liveMemoryParts() );
+
+	}
+
+	/** One line on what the build actually cost, and whether the preflight called it right. @private */
+	_logMemoryReport() {
+
+		const { allocatedBytes, peakLiveBytes, byPhase } = this.memory;
+		if ( allocatedBytes === 0 ) return;
+
+		const phases = Object.keys( byPhase )
+			.filter( name => byPhase[ name ].allocated > 0 )
+			.map( name => `${name} ${fmt.mb( byPhase[ name ].allocated )}` );
+
+		const predicted = this.memoryPreflight?.estimate?.total;
+
+		log.debug( fmt.list( [
+			`memory: peak live ${fmt.mb( peakLiveBytes )}`,
+			`allocated ${fmt.mb( allocatedBytes )}`,
+			predicted ? `predicted ${fmt.mb( predicted )}` : null,
+			phases.join( ' · ' ),
+		] ) );
+
+	}
+
 	/**
      * Build the BVH from a 3D object/scene
      * @param {Object3D} object - Three.js object to process
@@ -200,6 +412,10 @@ export class SceneProcessor {
 
 		this.isProcessing = true;
 		this.processingStage = 'init';
+		this.memory.reset();
+		this._geometryBytes = 0;
+		// Module-global by design: one build at a time, and `isProcessing` above enforces it.
+		setChunkObserver( bytes => this.memory.alloc( bytes ) );
 
 		const timer = new BuildTimer( object.name ?? '', { namespace: 'scene' } );
 
@@ -209,12 +425,21 @@ export class SceneProcessor {
 			this._reset();
 			this._log( 'Starting scene processing' );
 
+			// Step 0: will this scene fit in the address space this process has left?
+			this.memory.mark( 'preflight' );
+			this._preflightMemory( object );
+
 			// Step 1: Extract geometry (0-20%)
 			this.processingStage = 'extraction';
+			this.memory.mark( 'extraction' );
 			timer.start( 'Geometry extraction' );
 			await this._extractGeometry( object );
 			timer.end( 'Geometry extraction' );
 			this.performanceMetrics.geometryExtractionTime = timer.getDuration( 'Geometry extraction' );
+			// The preflight figure was taken before `_compressAttributes` halved normals and
+			// colours; every sample from here on should use what the mirror actually holds.
+			this._geometryBytes = geometryBytesOf( object );
+			this._sampleMemory( 'after extraction' );
 
 			// Step 2: BVH + textures in parallel (20-95%)
 			// Texture creation only needs GeometryExtractor output (materials + texture maps)
@@ -257,9 +482,9 @@ export class SceneProcessor {
 			// Only fall back to main-thread flattening if bvhData wasn't produced.
 			this.processingStage = 'finalize';
 			timer.start( 'BVH data packing' );
-			if ( this.bvhRoot && ! this.bvhData ) {
+			if ( this.bvhRoot && ! this.bvh ) {
 
-				this.bvhData = this.textureCreator.createBVHRawData( this.bvhRoot );
+				this._setBVHData( this.textureCreator.createBVHRawData( this.bvhRoot ) );
 
 			}
 
@@ -283,12 +508,16 @@ export class SceneProcessor {
 			log.error( 'processing failed:', error );
 			updateLoading( {
 				status: `Error: ${error.message}`,
+				failed: true,
 				progress: 100
 			} );
 			throw error;
 
 		} finally {
 
+			setChunkObserver( null );
+			this._sampleMemory( `at ${this.processingStage}` );
+			this._logMemoryReport();
 			this.isProcessing = false;
 
 		}
@@ -319,10 +548,17 @@ export class SceneProcessor {
 			// Extract geometry data
 			const extractedData = this.geometryExtractor.extract( object );
 
-			this.triangleData = extractedData.triangleData;
-			this.triangleCount = extractedData.triangleCount;
+			this._setTriangleData( extractedData.triangleData );
+			this.triangleCount = assertBVHIndexFits( extractedData.triangleCount, 'triangle count' );
+			// Callers build refit buffers by walking meshes, which counts a shared geometry
+			// once per placement; storage counts it once.
+			this.expandedTriangleCount = extractedData.expandedTriangleCount ?? extractedData.triangleCount;
+			this.instanceSource = extractedData.instanceSource || null;
+			this.instanceMatrices = extractedData.instanceMatrices || null;
+			this.instanceCount = extractedData.instanceCount || 0;
+			this.bakeInverse = extractedData.bakeInverse || null;
 
-			this._log( `Using Float32Array format: ${this.triangleCount} triangles, ${( this.triangleData.byteLength / ( 1024 * 1024 ) ).toFixed( 2 )}MB` );
+			this._log( `Using Float32Array format: ${this.triangleCount} triangles, ${( this.triangles.byteLength / ( 1024 * 1024 ) ).toFixed( 2 )}MB` );
 
 			// Store other extracted data
 			this.materials = extractedData.materials;
@@ -365,6 +601,7 @@ export class SceneProcessor {
 			log.error( 'geometry extraction failed:', error );
 			updateLoading( {
 				status: `Extraction error: ${error.message}`,
+				failed: true,
 				progress: 25
 			} );
 			throw error;
@@ -391,11 +628,11 @@ export class SceneProcessor {
 		}
 
 		this._log( 'Building two-level BVH (TLAS/BLAS)' );
+		this.memory.mark( 'blas' );
 		const startTime = performance.now();
 
 		try {
 
-			const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 			const ranges = this.meshTriangleRanges;
 
 			if ( ! ranges || ranges.length === 0 ) {
@@ -406,9 +643,18 @@ export class SceneProcessor {
 
 			// ── Step 1: Build per-mesh BLASes ──
 
+			// One entry per PLACEMENT, not per object: an InstancedMesh contributes a matrix per
+			// instance while the scene graph still holds one object. The extractor hands over the
+			// transforms as one contiguous pool, which the table adopts rather than copying.
+			const pooled = this.instanceCount > 0;
+			const meshCount = pooled ? this.instanceCount : ranges.length;
+			const instSource = this.instanceSource;
+			const worldPool = pooled ? this.instanceMatrices : null;
+			const sourceOf = m => ( pooled ? instSource[ m ] : m );
+
 			this.instanceTable = new InstanceTable();
-			this.instanceTable.allocate( ranges.length );
-			const meshCount = ranges.length;
+			this.instanceTable.allocate( meshCount, ranges.length, worldPool, pooled ? instSource : null );
+			this.instanceTable.tplBakeInverse = this.bakeInverse;
 
 			const originalTreeletEnabled = this.config.enableTreeletOptimization;
 			const LARGE_MESH_THRESHOLD = 200000;
@@ -417,10 +663,25 @@ export class SceneProcessor {
 			const poolTasks = [];
 			const parallelTasks = [];
 
+			// Placements that reuse another's triangles reuse its BLAS too — the whole point of
+			// storing geometry in object space. Only the first placement of a range is built.
+			const aliasOf = new Map();
+			const ownerOfRange = new Map();
+
 			for ( let m = 0; m < meshCount; m ++ ) {
 
-				const range = ranges[ m ];
-				if ( range.count === 0 ) continue;
+				const range = ranges[ sourceOf( m ) ];
+				if ( ! range || range.count === 0 ) continue;
+
+				const owner = ownerOfRange.get( range.start );
+				if ( owner !== undefined ) {
+
+					aliasOf.set( m, owner );
+					continue;
+
+				}
+
+				ownerOfRange.set( range.start, m );
 
 				if ( range.count >= LARGE_MESH_THRESHOLD && shouldUseParallelBuild( range.count ) ) {
 
@@ -459,52 +720,58 @@ export class SceneProcessor {
 			};
 
 			const totalTasks = poolTasks.length + parallelTasks.length;
+			let doneTasks = 0;
+			const reportBLASProgress = () => {
 
-			// Build all meshes via bounded worker pool (main thread stays free)
-			const poolPromise = this._buildBLASesWithPool( poolTasks, workerOpts, ( done ) => {
-
+				doneTasks ++;
 				updateLoading( {
-					status: `Building BLAS ${done + parallelTasks.length}/${totalTasks}...`,
-					progress: 25 + Math.floor( ( done / totalTasks ) * 45 )
+					status: `Building BLAS ${doneTasks}/${totalTasks}...`,
+					progress: 25 + Math.floor( ( doneTasks / totalTasks ) * 45 )
 				} );
 
-			} );
+			};
 
-			// Very large meshes use multi-worker parallel builder concurrently
-			const parallelPromises = parallelTasks.map( ( { m, range } ) => {
+			// Build all meshes via bounded worker pool (main thread stays free)
+			const poolPromise = this._buildBLASesWithPool( poolTasks, workerOpts, reportBLASProgress );
 
-				const meshTriData = this.triangleData.slice(
-					range.start * FPT,
-					( range.start + range.count ) * FPT
-				);
+			// One at a time: each build already spreads over every core and pins ~200 bytes per
+			// triangle of SharedArrayBuffer until it finishes. This is a memory bound, not a core one.
+			const parallelResults = [];
+			const parallelPromise = ( async () => {
 
-				return buildBVHParallel( meshTriData, this.config.bvhDepth, null, {
-					maxLeafSize: this.bvhBuilder.maxLeafSize,
-					numBins: this.bvhBuilder.numBins,
-					maxBins: this.bvhBuilder.maxBins,
-					minBins: this.bvhBuilder.minBins,
-					...workerOpts
-				} ).then( result => ( { m, range, result } ) );
+				for ( const { m, range } of parallelTasks ) {
 
-			} );
+					const meshTriData = this.triangles.copyOf( range.start, range.count );
 
-			// Await both paths concurrently
-			const [ poolResults, parallelResults ] = await Promise.all( [
-				poolPromise,
-				Promise.all( parallelPromises )
-			] );
+					const result = await buildBVHParallel( meshTriData, this.config.bvhDepth, null, {
+						maxLeafSize: this.bvhBuilder.maxLeafSize,
+						numBins: this.bvhBuilder.numBins,
+						maxBins: this.bvhBuilder.maxBins,
+						minBins: this.bvhBuilder.minBins,
+						...workerOpts
+					} );
 
-			// Store all results, summing per-mesh split stats for one aggregate BVH line
-			const blasStats = { sah: 0, objMed: 0, spatMed: 0, failed: 0, treeletsImproved: 0, treeletsProcessed: 0 };
+					if ( result.reorderedTriangles ) {
 
-			for ( const { m, range, result } of [ ...poolResults, ...parallelResults ] ) {
+						this.triangles.setRecords( range.start, result.reorderedTriangles );
+						delete result.reorderedTriangles;
 
-				if ( result.reorderedTriangles ) {
+					}
 
-					this.triangleData.set( result.reorderedTriangles, range.start * FPT );
+					parallelResults.push( { m, range, result } );
+					reportBLASProgress();
 
 				}
 
+			} )();
+
+			const [ poolResults ] = await Promise.all( [ poolPromise, parallelPromise ] );
+
+			// Store all results, summing per-mesh split stats for one aggregate BVH line
+			const blasStats = { sah: 0, objMed: 0, spatMed: 0, failed: 0, treeletsImproved: 0, treeletsProcessed: 0 };
+
+			for ( const { m, range, result } of [ ...poolResults, ...parallelResults ] ) {
+
 				const st = result.splitStats;
 				if ( st ) {
 
@@ -524,50 +791,94 @@ export class SceneProcessor {
 					triCount: range.count,
 					originalToBvhMap: result.originalToBvh || null,
 					bvhData: result.bvhData,
+					matrixWorld: pooled ? worldPool : ( this.meshes?.[ m ]?.matrixWorld?.elements ?? null ),
+					matrixOffset: pooled ? m * 16 : 0,
+					expandedStart: range.expandedStart,
+					sourceMesh: sourceOf( m ),
 				} );
 
 			}
 
+			for ( const [ m, owner ] of aliasOf ) {
+
+				this.instanceTable.setAlias(
+					m, owner,
+					pooled ? worldPool : ( this.meshes?.[ m ]?.matrixWorld?.elements ?? null ),
+					ranges[ sourceOf( m ) ].expandedStart,
+					sourceOf( m ),
+					pooled ? m * 16 : 0
+				);
+
+			}
+
 			updateLoading( { status: 'Built all BLASes', progress: 70 } );
 
+			this.performanceMetrics.blasBuildTime = performance.now() - startTime;
+
 			// ── Step 2: Assemble BVH buffer ──
 
 			updateLoading( { status: "Building TLAS...", progress: 72 } );
+			this._sampleMemory( 'BLASes built' );
+			this.memory.mark( 'tlas' );
+			const tlasStart = performance.now();
 
-			const validEntries = this.instanceTable.entries.filter( e => e !== null );
+			const table = this.instanceTable;
 
 			// Always build a TLAS — even for a single mesh — so the BLAS-pointer leaf
 			// carries packed per-mesh visibility in its slot [2]. The 1-node TLAS
 			// overhead (one extra leaf fetch per ray) is negligible and eliminates
 			// a dedicated visibility storage buffer binding.
-			this.instanceTable.computeAABBs( this.triangleData );
-			const { root: tlasRoot, nodeCount: tlasNodeCount } = this.tlasBuilder.build( validEntries );
+			this.instanceTable.computeAABBs( this.triangles );
 
-			this.instanceTable.assignOffsets( tlasNodeCount );
+			// Node count is exact up front (every leaf holds one entry), so BLAS offsets can be
+			// assigned before the build and the TLAS is written in a single pass.
+			this.instanceTable.assignOffsets( TLASBuilder.nodeCountFor( table.count ) );
 			const totalNodes = this.instanceTable.totalNodeCount;
 
-			const tlasData = this.tlasBuilder.flatten( tlasRoot, validEntries );
+			let tlasData = await this._buildTLAS( table );
+			this.performanceMetrics.tlasBuildTime = performance.now() - tlasStart;
 
 			// Assemble combined buffer: [TLAS][BLAS_0][BLAS_1]...[BLAS_M]
-			this.bvhData = new Float32Array( totalNodes * 16 );
-			this.bvhData.set( tlasData );
-
-			for ( const entry of validEntries ) {
-
-				const destOffset = entry.blasOffset * 16;
-				this.bvhData.set( entry.bvhData, destOffset );
-				this._offsetBLASInPlace( destOffset, entry.bvhData.length / 16, entry.blasOffset, entry.triOffset );
+			this.memory.mark( 'assemble' );
+			const assembleStart = performance.now();
+			// Chunked for the same reason triangles are: 64 B a node puts the 2 GB array cap at
+			// 33.4M nodes, which a large instanced scene reaches well before the GPU's 4 GB.
+			// Lazy, and walked in template order so offsets ascend: chunks are allocated as the fill
+			// reaches them and each BLAS is released as it lands, never both fully resident.
+			this._checkAssemblyHeadroom( totalNodes );
+			this._setBVHData( ChunkedRecords.lazy( totalNodes, 16, Float32Array, undefined, SHARED_MEMORY_AVAILABLE ) );
+			this.bvh.setRecords( 0, tlasData );
+			// Hundreds of megabytes at millions of placements, and the chunks below need the room
+			// more than a later refit needs the cache.
+			tlasData = null;
+			this.tlasBuilder.releaseFlattenBuffer();
+
+			// Sample ~32 times across the fill rather than per template: this is where every
+			// allocation failure so far has landed, and the live total moves in both directions
+			// as chunks are taken and BLASes released.
+			const sampleEvery = Math.max( 1, Math.ceil( table.templateCount / 32 ) );
+
+			for ( let t = 0; t < table.templateCount; t ++ ) {
+
+				const blas = table.blasData.get( t ); // only owning templates hold one
+				if ( ! blas ) continue;
+
+				const blasOffset = table.tplBlasOffset[ t ];
+				this.bvh.setRecords( blasOffset, blas );
+				this._offsetBLASInPlace( blasOffset, blas.length / 16, blasOffset, table.tplTriOffset[ t ] );
+				table.blasData.delete( t );
+
+				if ( t % sampleEvery === 0 ) this._sampleMemory( `assembling ${t}/${table.templateCount}` );
 
 			}
 
-			this._buildGlobalOriginalToBvhMap();
-
-			for ( const entry of validEntries ) {
+			this._setBVHData( this.bvh.materializeAll() );
 
-				entry.originalToBvhMap = null;
-				entry.bvhData = null;
+			this._buildBvhToOriginalMaps();
+			this.performanceMetrics.bvhAssembleTime = performance.now() - assembleStart;
 
-			}
+			table.originalToBvhMap.clear();
+			table.blasData.clear();
 
 			this.bvhRoot = true;
 			this._disposeRefitWorker();
@@ -576,8 +887,8 @@ export class SceneProcessor {
 			// One aggregate line for the whole two-level build; the workers' per-mesh
 			// detail sits a level below at `debug`.
 			log.debug( fmt.list( [
-				`${fmt.n( validEntries.length )} BLASes + TLAS`,
-				`${fmt.n( this.bvhData.length / 16 )} nodes`,
+				`${fmt.n( table.setCount )} BLASes + TLAS`,
+				`${fmt.n( this.bvh.recordCount )} nodes`,
 				`SAH ${fmt.n( blasStats.sah )} · objMed ${blasStats.objMed} · spatMed ${blasStats.spatMed} · failed ${blasStats.failed}`,
 				blasStats.treeletsProcessed ? `treelets ${blasStats.treeletsImproved}/${blasStats.treeletsProcessed} improved` : null,
 				fmt.ms( duration ),
@@ -593,6 +904,7 @@ export class SceneProcessor {
 			log.error( 'BVH build failed:', error );
 			updateLoading( {
 				status: `BVH error: ${error.message}`,
+				failed: true,
 				progress: 75
 			} );
 			throw error;
@@ -605,20 +917,24 @@ export class SceneProcessor {
 	 * Adjust BLAS node indices in-place within the combined bvhData buffer.
 	 * @private
 	 */
-	_offsetBLASInPlace( destFloat, nodeCount, nodeOffset, triOffset ) {
+	_offsetBLASInPlace( startNode, nodeCount, nodeOffset, triOffset ) {
+
+		const idx = this.bvhIndexChunks;
 
 		for ( let i = 0; i < nodeCount; i ++ ) {
 
-			const o = destFloat + i * 16;
+			const n = startNode + i;
+			const chunk = idx.chunkFor( n );
+			const o = idx.baseOf( n );
 
-			if ( this.bvhData[ o + 3 ] === - 1 ) {
+			if ( chunk[ o + 3 ] === BVH_LEAF_MARKERS.TRIANGLE_LEAF ) {
 
-				this.bvhData[ o ] += triOffset;
+				chunk[ o ] += triOffset;
 
 			} else {
 
-				this.bvhData[ o + 3 ] += nodeOffset;
-				this.bvhData[ o + 7 ] += nodeOffset;
+				chunk[ o + 3 ] += nodeOffset;
+				chunk[ o + 7 ] += nodeOffset;
 
 			}
 
@@ -640,7 +956,6 @@ export class SceneProcessor {
 
 		if ( tasks.length === 0 ) return Promise.resolve( [] );
 
-		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const poolSize = Math.min( tasks.length, this.config.maxConcurrentTextureTasks || 4 );
 		const results = [];
 		let nextTask = 0;
@@ -663,10 +978,7 @@ export class SceneProcessor {
 				}
 
 				const { m, range } = tasks[ nextTask ++ ];
-				const meshTriData = this.triangleData.slice(
-					range.start * FPT,
-					( range.start + range.count ) * FPT
-				);
+				const meshTriData = this.triangles.copyOf( range.start, range.count );
 
 				// Disable treelet for tiny meshes
 				const triCount = range.count;
@@ -709,12 +1021,16 @@ export class SceneProcessor {
 				if ( data.progress !== undefined ) return; // Ignore progress messages
 
 				const { m, range } = worker._currentTask;
+
+				// Write back now: holding one copy per mesh until the pool drains is the whole
+				// triangle buffer over again, ~3 GB at 40M.
+				if ( data.triangles ) this.triangles.setRecords( range.start, data.triangles );
+
 				results.push( {
 					m,
 					range,
 					result: {
 						bvhData: data.bvhData,
-						reorderedTriangles: data.triangles || null,
 						originalToBvh: data.originalToBvh || null,
 						splitStats: data.treeletStats || null,
 					}
@@ -764,43 +1080,38 @@ export class SceneProcessor {
 	}
 
 	/**
-	 * Build global originalToBvhMap and per-mesh bvhToOriginal maps.
-	 * The inverse map enables cache-friendly sequential writes during position updates.
+	 * Build the per-template bvhToOriginal maps: stored-order index → the caller's triangle index.
+	 * Only this direction is kept — every reader walks stored order, so the forward map was a
+	 * second copy of the same permutation (114 MB at 30M triangles) that nothing needed.
 	 * @private
 	 */
-	_buildGlobalOriginalToBvhMap() {
+	_buildBvhToOriginalMaps() {
 
-		this.originalToBvhMap = new Uint32Array( this.triangleCount );
+		const table = this.instanceTable;
+		for ( let m = 0; m < table.count; m ++ ) {
 
-		for ( const entry of this.instanceTable.entries ) {
+			// Aliases read the owner's map straight out of the table; nothing to store.
+			if ( ! table.isSet[ m ] || ! table.isOwner( m ) ) continue;
 
-			if ( ! entry ) continue;
+			const t = table.sourceMesh[ m ];
+			const triCount = table.tplTriCount[ t ];
+			const originalToBvh = table.originalToBvhMap.get( t );
 
 			// Build per-mesh bvhToOriginal (inverse map for sequential writes)
-			const bvhToOrig = new Uint32Array( entry.triCount );
-
-			if ( entry.originalToBvhMap ) {
-
-				for ( let i = 0; i < entry.triCount; i ++ ) {
+			const bvhToOrig = new Uint32Array( triCount );
 
-					const bvhLocal = entry.originalToBvhMap[ i ];
-					this.originalToBvhMap[ entry.triOffset + i ] = entry.triOffset + bvhLocal;
-					bvhToOrig[ bvhLocal ] = i;
+			if ( originalToBvh ) {
 
-				}
+				for ( let i = 0; i < triCount; i ++ ) bvhToOrig[ originalToBvh[ i ] ] = i;
 
 			} else {
 
-				for ( let i = 0; i < entry.triCount; i ++ ) {
-
-					this.originalToBvhMap[ entry.triOffset + i ] = entry.triOffset + i;
-					bvhToOrig[ i ] = i;
-
-				}
+				for ( let i = 0; i < triCount; i ++ ) bvhToOrig[ i ] = i;
 
 			}
 
-			entry.bvhToOriginal = bvhToOrig;
+			table.bvhToOriginal.set( t, bvhToOrig );
+			table.originalToBvhMap.delete( t ); // consumed; the caller clears the rest anyway
 
 		}
 
@@ -931,11 +1242,27 @@ export class SceneProcessor {
 		this._linearTexPacked = new Map();
 
 		let bucketOverflowReported = false;
+		let undecodedReported = false;
 
 		// Assign one texture to its (bucket, layer) within a pool; dedup by source uuid.
 		const assign = ( tex, lists, dedup, flat, shapes ) => {
 
-			if ( ! tex || ! tex.image ) return - 1;
+			if ( ! tex ) return - 1;
+
+			// A map whose image has not landed yet is indistinguishable here from no map at
+			// all, and the material would render untextured with nothing in the log.
+			if ( ! tex.image ) {
+
+				if ( ! undecodedReported ) this.config.issues?.record(
+					ISSUE_CODES.TEXTURE_BUILD_FAILED,
+					'a material map had not finished decoding when the scene was packed; it renders untextured',
+					{ texture: tex.name || tex.source?.uuid || tex.uuid }
+				);
+				undecodedReported = true;
+				return - 1;
+
+			}
+
 			const bucket = getTextureBucketId( tex.image.width, tex.image.height, shapes );
 			const uuid = tex.source?.uuid ?? tex.uuid;
 			const seen = dedup[ bucket ].get( uuid );
@@ -1033,9 +1360,10 @@ export class SceneProcessor {
 	_buildEmissiveData() {
 
 		this.emissiveTriangleCount = this.emissiveTriangleBuilder.extractEmissiveTriangles(
-			this.triangleData,
+			this.triangles,
 			this.materials,
-			this.triangleCount
+			this.triangleCount,
+			this.instanceTable ?? null
 		);
 
 		this.emissiveTriangleData = this.emissiveTriangleBuilder.createEmissiveRawData();
@@ -1088,7 +1416,7 @@ export class SceneProcessor {
 
 		// Reset all containers
 		this.triangles = [];
-		this.triangleData = null;
+		this._setTriangleData( null );
 		this.triangleCount = 0;
 		this.materials = [];
 		this.meshTriangleRanges = null;
@@ -1113,7 +1441,10 @@ export class SceneProcessor {
 		this.cameras = [];
 		this.spheres = [];
 		this.bvhRoot = null;
+		this.bvh = null;
 		this.bvhData = null;
+		this.bvhIndexChunks = null;
+		this.bvhIndex = null;
 		this.instanceTable = null;
 		this.lightBVHNodeData = null;
 		this.lightBVHNodeCount = 0;
@@ -1124,6 +1455,9 @@ export class SceneProcessor {
 			textureCreationTime: 0,
 			geometryExtractionTime: 0,
 			bvhBuildTime: 0,
+			blasBuildTime: 0,
+			tlasBuildTime: 0,
+			bvhAssembleTime: 0,
 			totalProcessingTime: 0
 		};
 
@@ -1270,9 +1604,9 @@ export class SceneProcessor {
 			cameraCount: this.cameras.length,
 			processingComplete: this.processingStage === 'complete',
 			hasBVH: !! this.bvhRoot,
-			hasTextures: !! this.materialData && !! this.bvhData,
+			hasTextures: !! this.materialData && !! this.bvh,
 			useFloat32Array: this.config.useFloat32Array,
-			triangleDataSize: this.triangleData ? ( this.triangleData.byteLength / ( 1024 * 1024 ) ).toFixed( 2 ) + 'MB' : '0MB'
+			triangleDataSize: this.triangles ? ( this.triangles.byteLength / ( 1024 * 1024 ) ).toFixed( 2 ) + 'MB' : '0MB'
 		};
 
 		// Add performance metrics
@@ -1333,45 +1667,115 @@ export class SceneProcessor {
 	// ===== BVH REFIT (Animation Support) =====
 
 	/**
-	 * Refit BVH with updated vertex positions (same topology — no triangle add/remove).
-	 * O(N) bottom-up AABB update instead of full O(N log N) SAH rebuild.
-	 *
-	 * @param {Float32Array} newPositions - 9 floats per triangle (ax,ay,az, bx,by,bz, cx,cy,cz) in original mesh order
-	 * @returns {Promise<{ refitTimeMs: number }>}
+	 * Make sure a store's chunks live in shared memory. Already-shared chunks are left alone; a
+	 * page without cross-origin isolation falls back to copying, which is the old cost.
+	 * @private
 	 */
-	async refitBVH( newPositions, newNormals ) {
+	_adoptSharedChunks( field, LaneType ) {
 
-		if ( ! this.bvhData || ! this.triangleData || ! this.originalToBvhMap ) {
+		const records = this[ field ];
+		if ( records.shared ) return;
 
-			throw new Error( 'No BVH data available for refit. Run buildBVH() first.' );
+		const chunks = records.chunks.map( c => {
 
-		}
+			const view = new LaneType( new SharedArrayBuffer( c.byteLength ) );
+			view.set( c );
+			return view;
 
-		// The worker reads triCount * 9 floats unconditionally, and the shared position buffer
-		// is sized from the FIRST call's argument — so a short array reads past its end and
-		// writes NaN into triangleData and every AABB above it, with no error anywhere. A
-		// caller that misses a mesh (the hidden ground disk is easy to miss) sees the scene
-		// silently vanish instead of a thrown exception, so check the length up front.
-		const expectedFloats = this.triangleCount * 9;
+		} );
 
-		if ( newPositions?.length !== expectedFloats ) {
+		const adopted = ChunkedRecords.adopt(
+			chunks, records.recordCount, records.lanesPerRecord, records.recordsPerChunk
+		);
 
-			throw new Error(
-				`SceneProcessor.refitBVH: expected ${expectedFloats} position floats ` +
-				`(${this.triangleCount} triangles × 9), got ${newPositions?.length ?? 'none'}. ` +
-				'Positions must cover every triangle in the scene, meshes in this.meshes order.'
-			);
+		if ( field === 'bvh' ) this._setBVHData( adopted );
+		else this._setTriangleData( adopted );
+
+	}
+
+	/**
+	 * Normalize a caller's positions or normals into a per-mesh reader. A full-scene array is
+	 * handed back as views into itself, so the old contract costs nothing extra; a callback lets a
+	 * caller build one mesh at a time and never hold 9 floats × every triangle at once — 1,030 MB
+	 * at 30M triangles, which is past what a renderer can allocate.
+	 * @private
+	 */
+	_meshSource( source, what ) {
+
+		if ( source == null ) return null;
+
+		const table = this.instanceTable;
+
+		if ( typeof source === 'function' ) {
+
+			// The table is keyed by placement and one instanced mesh holds several, so a raw
+			// placement index is not something the caller can look up. Hand back the mesh.
+			return i => {
+
+				const mesh = table.sourceMesh[ i ];
+				const got = source( mesh, table.triCountOf( i ) );
+				const want = table.triCountOf( i ) * 9;
+				if ( got && got.length !== want ) {
+
+					throw new Error(
+						`SceneProcessor: ${what}s for mesh ${mesh} must be ${want} floats ` +
+						`(${table.triCountOf( i )} triangles × 9), got ${got.length}.`
+					);
+
+				}
+
+				return got ?? null;
+
+			};
 
 		}
 
-		if ( newNormals && newNormals.length !== expectedFloats ) {
+		// A short array reads past its end and writes NaN through every AABB above it with no
+		// error anywhere, so the scene just vanishes. Check once here instead.
+		const expected = ( this.expandedTriangleCount ?? this.triangleCount ) * 9;
+		if ( source.length !== expected ) {
 
 			throw new Error(
-				`SceneProcessor.refitBVH: expected ${expectedFloats} normal floats, got ${newNormals.length}.`
+				`SceneProcessor: expected ${expected} ${what} floats (${expected / 9} triangles × 9, ` +
+				`full scene), got ${source.length}. Pass a per-mesh callback instead to avoid ` +
+				'building one array for the whole scene.'
 			);
 
 		}
 
+		return i => {
+
+			const from = table.expandedStartOf( i ) * 9;
+			return source.subarray( from, from + table.triCountOf( i ) * 9 );
+
+		};
+
+	}
+
+	/**
+	 * Refit BVH with updated vertex positions (same topology — no triangle add/remove).
+	 * O(N) bottom-up AABB update instead of full O(N log N) SAH rebuild.
+	 *
+	 * @param {Float32Array|function(number, number): Float32Array} newPositions - either 9 floats
+	 *   per triangle for the whole scene (meshes in `this.meshes` order), or a callback given a
+	 *   mesh index and its triangle count that returns just that mesh's 9-floats-per-triangle
+	 *   slice. Prefer the callback: the scene-wide form is 1,030 MB at 30M triangles.
+	 * @param {Float32Array|function(number, number): Float32Array} [newNormals] - same two shapes
+	 * @returns {Promise<{ refitTimeMs: number }>}
+	 */
+	async refitBVH( newPositions, newNormals ) {
+
+		if ( ! this.bvh || ! this.triangles || ! this.instanceTable ) {
+
+			throw new Error( 'No BVH data available for refit. Run buildBVH() first.' );
+
+		}
+
+		const positionsFor = this._meshSource( newPositions, 'position' );
+		const normalsFor = this._meshSource( newNormals, 'normal' );
+
+		if ( ! positionsFor ) throw new Error( 'SceneProcessor.refitBVH: positions are required.' );
+
 		// Lazy-create worker
 		if ( ! this._refitWorker ) {
 
@@ -1379,55 +1783,55 @@ export class SceneProcessor {
 
 		}
 
-		// First call: set up SharedArrayBuffers for zero-copy communication.
-		// Worker writes into shared bvh/tri data; main thread reads them for GPU upload.
-		// Race-free because _animRefitInFlight guard prevents overlapping calls.
+		// First call: move triangles and nodes into shared memory so the worker refits them in
+		// place. Positions never cross the boundary — they are scattered into the triangle records
+		// below, one mesh at a time, so nothing scene-sized is allocated on either side.
 		if ( ! this._refitSharedBuffers ) {
 
-			const sharedBvhBuf = new SharedArrayBuffer( this.bvhData.byteLength );
-			const sharedTriBuf = new SharedArrayBuffer( this.triangleData.byteLength );
-			const sharedPosBuf = new SharedArrayBuffer( newPositions.byteLength );
+			// Both stores are built on SharedArrayBuffer when the page allows it, so the worker
+			// takes them as they are. Copying instead would duplicate the two largest structures
+			// in the scene — 3,968 MB at 30M triangles, which is where this used to fail.
+			this._adoptSharedChunks( 'bvh', Float32Array );
+			this._adoptSharedChunks( 'triangles', Uint32Array );
 
-			const sharedBvhData = new Float32Array( sharedBvhBuf );
-			const sharedTriData = new Float32Array( sharedTriBuf );
+			const sharedBvhBufs = this.bvh.chunks.map( c => c.buffer );
+			const sharedTriBufs = this.triangles.chunks.map( c => c.buffer );
+			this._refitSharedBuffers = { bvhBufs: sharedBvhBufs, triBufs: sharedTriBufs };
 
-			sharedBvhData.set( this.bvhData );
-			sharedTriData.set( this.triangleData );
+			this._refitWorker.postMessage( {
+				type: 'init',
+				sharedBvhBufs,
+				bvhRecordCount: this.bvh.recordCount,
+				bvhRecordsPerChunk: this.bvh.recordsPerChunk,
+				sharedTriBufs,
+				triRecordCount: this.triangles.recordCount,
+				triLanesPerRecord: this.triangles.lanesPerRecord,
+				triRecordsPerChunk: this.triangles.recordsPerChunk,
+			} );
 
-			// Replace local refs with shared views
-			this.bvhData = sharedBvhData;
-			this.triangleData = sharedTriData;
+		}
 
-			// Build bvhToOriginal map (inverse of originalToBvh) for cache-friendly
-			// sequential writes in the worker's updateTrianglePositions.
-			const triCount = this.originalToBvhMap.length;
-			const bvhToOriginal = new Uint32Array( triCount );
-			for ( let i = 0; i < triCount; i ++ ) {
+		// Scatter straight into the shared triangle records, mesh by mesh, so the caller's slice
+		// can be released as soon as it is read. Callers hand over world space; triangles are
+		// stored per instance, so each mesh comes back through its own inverse.
+		const table = this.instanceTable;
+		for ( let i = 0; i < table.count; i ++ ) {
 
-				bvhToOriginal[ this.originalToBvhMap[ i ] ] = i;
+			if ( ! table.isSet[ i ] || ! table.isOwner( i ) ) continue;
 
-			}
+			const p = positionsFor( i );
+			if ( ! p ) continue;
+			this._updateMeshTrianglePositions( i, p );
 
-			this._refitSharedBuffers = {
-				bvhBuf: sharedBvhBuf,
-				triBuf: sharedTriBuf,
-				posBuf: sharedPosBuf,
-				posView: new Float32Array( sharedPosBuf ),
-			};
+			// Smooth normals overwrite the face normals just computed, so they follow per mesh.
+			if ( normalsFor ) {
 
-			// Send shared buffers + immutable index map to worker (cached there)
-			this._refitWorker.postMessage( {
-				type: 'init',
-				sharedBvhBuf,
-				sharedTriBuf,
-				sharedPosBuf,
-				bvhToOriginal,
-			}, [ bvhToOriginal.buffer ] );
+				const n = normalsFor( i );
+				if ( n ) this._patchMeshSmoothNormals( i, n );
 
-		}
+			}
 
-		// Write new positions into shared buffer (main thread → worker, zero-copy)
-		this._refitSharedBuffers.posView.set( newPositions );
+		}
 
 		return new Promise( ( resolve, reject ) => {
 
@@ -1436,14 +1840,6 @@ export class SceneProcessor {
 				const msg = e.data;
 				if ( msg.type === 'refitComplete' ) {
 
-					// bvhData/triangleData already updated via shared memory.
-					// If smooth normals provided, overwrite the face normals the worker computed.
-					if ( newNormals ) {
-
-						this._patchSmoothNormals( newNormals );
-
-					}
-
 					resolve( { refitTimeMs: msg.refitTimeMs } );
 
 				} else if ( msg.type === 'error' ) {
@@ -1465,9 +1861,18 @@ export class SceneProcessor {
 	 * Overwrite face normals in triangleData with smooth vertex normals (full scene).
 	 * @private
 	 */
-	_patchSmoothNormals( normals ) {
+	_patchSmoothNormals( normalsFor ) {
+
+		const table = this.instanceTable;
+		if ( ! table ) return;
 
-		this._patchNormalsRange( normals, 0, this.originalToBvhMap.length );
+		for ( let i = 0; i < table.count; i ++ ) {
+
+			if ( ! table.isSet[ i ] || ! table.isOwner( i ) ) continue;
+			const n = normalsFor( i );
+			if ( n ) this._patchMeshSmoothNormals( i, n );
+
+		}
 
 	}
 
@@ -1475,39 +1880,38 @@ export class SceneProcessor {
 	 * Refit specific BLASes and rebuild TLAS after object transform or per-mesh animation.
 	 * Runs on the main thread (fast for per-mesh updates).
 	 *
-	 * @param {number[]} affectedMeshIndices - Indices into meshTriangleRanges / instanceTable.entries
+	 * @param {number[]} affectedMeshIndices - Indices into `this.meshes`, the same space
+	 *   {@link updateMeshTransforms} takes
 	 * @param {Float32Array} newPositions - 9 floats per triangle in original mesh order (full scene)
 	 * @param {Float32Array} [newNormals] - Optional smooth normals (9 floats per tri)
 	 * @returns {{ refitTimeMs: number }}
 	 */
-	refitBLASes( affectedMeshIndices, newPositions, newNormals ) {
-
-		if ( ! this.instanceTable || ! this.bvhData || ! this.triangleData ) {
+	/**
+	 * The placement holding a mesh's triangles. The instance table is keyed by placement and one
+	 * instanced mesh contributes several, so every entry point taking mesh indices converts here.
+	 *
+	 * @param {number} meshIndex
+	 * @returns {number} placement index, or -1 when the mesh placed nothing
+	 * @private
+	 */
+	_placementOf( meshIndex ) {
 
-			throw new Error( 'No TLAS/BLAS data available. Run buildBVH() first.' );
+		return this.instanceTable?.placementRunOf( meshIndex )?.start ?? - 1;
 
-		}
+	}
 
-		// Indexed by absolute triangle, so a short buffer reads undefined → NaN bounds for the
-		// affected meshes with no error. Same silent-corruption trap as refitBVH.
-		const expectedFloats = this.triangleCount * 9;
+	refitBLASes( affectedMeshIndices, newPositions, newNormals ) {
 
-		if ( newPositions?.length !== expectedFloats ) {
+		if ( ! this.instanceTable || ! this.bvh || ! this.triangles ) {
 
-			throw new Error(
-				`SceneProcessor.refitBLASes: expected ${expectedFloats} position floats ` +
-				`(${this.triangleCount} triangles × 9, full scene), got ${newPositions?.length ?? 'none'}.`
-			);
+			throw new Error( 'No TLAS/BLAS data available. Run buildBVH() first.' );
 
 		}
 
-		if ( newNormals && newNormals.length !== expectedFloats ) {
-
-			throw new Error(
-				`SceneProcessor.refitBLASes: expected ${expectedFloats} normal floats, got ${newNormals.length}.`
-			);
+		const positionsFor = this._meshSource( newPositions, 'position' );
+		const normalsFor = this._meshSource( newNormals, 'normal' );
 
-		}
+		if ( ! positionsFor ) throw new Error( 'SceneProcessor.refitBLASes: positions are required.' );
 
 		const start = performance.now();
 
@@ -1519,31 +1923,49 @@ export class SceneProcessor {
 		}
 
 		// Step 1: Update triangle positions and refit each affected BLAS
-		for ( const meshIdx of affectedMeshIndices ) {
+		const table = this.instanceTable;
+
+		for ( const meshIndex of affectedMeshIndices ) {
 
-			const entry = this.instanceTable.entries[ meshIdx ];
-			if ( ! entry ) continue;
+			const placement = this._placementOf( meshIndex );
+			if ( placement < 0 || ! table.isSet[ placement ] ) continue;
 
-			// Update triangle positions within this mesh's range
-			this._updateMeshTrianglePositions( entry, newPositions );
+			// Triangles are shared between placements of one geometry, so writing this mesh's
+			// vertices would move every other copy with them. Anything that deforms is extracted
+			// with triangles of its own, so reaching here means the wrong mesh was handed over.
+			if ( ! table.isOwner( placement ) ) {
 
-			// Patch smooth normals for this mesh if provided
-			if ( newNormals ) {
+				const owner = table.tplOwner[ table.sourceMesh[ placement ] ];
+				this.config.issues?.record(
+					ISSUE_CODES.REFIT_SHARED_GEOMETRY,
+					`mesh ${meshIndex} shares its triangles with another placement; deforming it would move every copy, so it was skipped`,
+					{ meshIndex, owner: table.sourceMesh[ owner ] ?? owner }
+				);
+				continue;
+
+			}
 
-				this._patchMeshSmoothNormals( entry, newNormals );
+			const p = positionsFor( placement );
+			if ( ! p ) continue;
+			this._updateMeshTrianglePositions( placement, p );
+
+			if ( normalsFor ) {
+
+				const n = normalsFor( placement );
+				if ( n ) this._patchMeshSmoothNormals( placement, n );
 
 			}
 
 			// Refit this BLAS's nodes
 			this._blasRefitter.refitRange(
-				this.bvhData,
-				this.triangleData,
-				entry.blasOffset,
-				entry.blasNodeCount
+				this.bvh,
+				this.triangles,
+				table.blasOffsetOf( placement ),
+				table.blasNodeCountOf( placement )
 			);
 
 			// Recompute this mesh's AABB for TLAS rebuild
-			this.instanceTable.recomputeAABB( meshIdx, this.bvhData, this.triangleData );
+			this.instanceTable.recomputeAABB( placement, this.bvh, this.triangles );
 
 		}
 
@@ -1554,6 +1976,121 @@ export class SceneProcessor {
 
 	}
 
+	/**
+	 * Move objects without touching their geometry: the placements a mesh contributed get new
+	 * transforms, the TLAS leaves get the matching world-to-object matrices, and the TLAS boxes
+	 * are refit. Triangles, BLASes and the GPU triangle buffer are all left alone.
+	 *
+	 * This is what a gizmo drag wants. {@link refitBLASes} exists for geometry that actually
+	 * deformed; used for a rigid move it would bake the new world positions into triangles that
+	 * a second placement of the same geometry may be sharing, and drag that one along too.
+	 *
+	 * @param {number[]} meshIndices - indices into `this.meshes`
+	 * @returns {{ refitTimeMs: number, placements: number }}
+	 */
+	updateMeshTransforms( meshIndices ) {
+
+		if ( ! this.instanceTable || ! this.bvh ) {
+
+			throw new Error( 'No TLAS/BLAS data available. Run buildBVH() first.' );
+
+		}
+
+		const start = performance.now();
+		const table = this.instanceTable;
+		const composed = this._transformScratch ??= new Float32Array( 16 );
+		let moved = 0;
+
+		for ( const meshIndex of meshIndices ) {
+
+			const mesh = this.meshes?.[ meshIndex ];
+			const run = table.placementRunOf( meshIndex );
+			if ( ! mesh || ! run ) continue;
+
+			mesh.updateMatrixWorld( true );
+			const world = mesh.matrixWorld.elements;
+			const instances = mesh.isInstancedMesh ? this._ownInstanceMatrices( mesh ) : null;
+			// Baked triangles hold the pose they were extracted at; the leaf only carries the delta.
+			const bakeInverse = table.tplBakeInverse?.get( table.sourceMesh[ run.start ] ) ?? null;
+
+			for ( let k = 0; k < run.count; k ++ ) {
+
+				const p = run.start + k;
+				if ( ! table.isSet[ p ] ) continue;
+
+				if ( instances ) {
+
+					multiplyAffine( world, instances, k * 16, composed );
+					table.setPlacementMatrix( p, composed );
+
+				} else if ( bakeInverse ) {
+
+					multiplyAffine( world, bakeInverse, 0, composed );
+					table.setPlacementMatrix( p, composed );
+
+				} else {
+
+					table.setPlacementMatrix( p, world );
+
+				}
+
+				this._writeLeafMatrix( p );
+				moved ++;
+
+			}
+
+		}
+
+		this._refitTLAS();
+
+		return { refitTimeMs: performance.now() - start, placements: moved };
+
+	}
+
+	/**
+	 * An InstancedMesh's own instance matrices, split off the placement pool if they still alias it.
+	 *
+	 * The extractor points a host-at-origin InstancedMesh straight at the pool, since world and
+	 * instance matrices hold identical bytes there. Composing a moved host back into the pool would
+	 * overwrite the matrices it just read, so the next move would compose onto its own result.
+	 * @private
+	 */
+	_ownInstanceMatrices( mesh ) {
+
+		const attr = mesh.instanceMatrix;
+		if ( ! attr?.array ) return null;
+
+		if ( attr.array.buffer === this.instanceTable.world.buffer ) {
+
+			attr.array = attr.array.slice();
+			attr.needsUpdate = true;
+
+		}
+
+		return attr.array;
+
+	}
+
+	/** Refresh one TLAS leaf's world-to-object matrix from the table. @private */
+	_writeLeafMatrix( placement ) {
+
+		const node = this.instanceTable.tlasLeafIndex[ placement ];
+		if ( node < 0 ) return;
+
+		TLASBuilder.writeLeafMatrix(
+			this.bvh.chunkFor( node ), this.bvhIndexChunks.chunkFor( node ), this.bvh.baseOf( node ),
+			this.instanceTable.world, placement
+		);
+
+	}
+
+	/** The TLAS occupies the front of the BVH buffer and is the only part a move rewrites. */
+	computeTLASDirtyRange() {
+
+		return { offset: 0, count: this.instanceTable.tlasNodeCount * 16 };
+
+	}
+
 	/**
 	 * Computes the dirty buffer ranges for a set of affected mesh BLASes.
 	 * Used for partial GPU upload after per-mesh refit instead of full buffer copy.
@@ -1568,13 +2105,14 @@ export class SceneProcessor {
 		const triRanges = [];
 		const bvhRanges = [];
 
-		for ( const meshIdx of affectedMeshIndices ) {
+		for ( const meshIndex of affectedMeshIndices ) {
 
-			const entry = this.instanceTable.entries[ meshIdx ];
-			if ( ! entry ) continue;
+			const table = this.instanceTable;
+			const placement = this._placementOf( meshIndex );
+			if ( placement < 0 || ! table.isSet[ placement ] ) continue;
 
-			triRanges.push( { offset: entry.triOffset * FPT, count: entry.triCount * FPT } );
-			bvhRanges.push( { offset: entry.blasOffset * FPN, count: entry.blasNodeCount * FPN } );
+			triRanges.push( { offset: table.triOffsetOf( placement ) * FPT, count: table.triCountOf( placement ) * FPT } );
+			bvhRanges.push( { offset: table.blasOffsetOf( placement ) * FPN, count: table.blasNodeCountOf( placement ) * FPN } );
 
 		}
 
@@ -1597,23 +2135,23 @@ export class SceneProcessor {
 	 */
 	uploadToPathTracer( pathTracer, lightManager, meshScene, environmentTexture ) {
 
-		if ( ! this.triangleData ) {
+		if ( ! this.triangles ) {
 
 			log.error( 'failed to get triangle data' );
 			return false;
 
 		}
 
-		pathTracer.setTriangleData( this.triangleData, this.triangleCount );
+		pathTracer.setTriangleData( this.triangles, this.triangleCount );
 
-		if ( ! this.bvhData ) {
+		if ( ! this.bvh ) {
 
 			log.error( 'failed to get BVH data' );
 			return false;
 
 		}
 
-		pathTracer.setBVHData( this.bvhData );
+		pathTracer.setBVHData( this.bvh );
 		pathTracer.setInstanceTable( this.instanceTable );
 
 		if ( this.materialData ) {
@@ -1686,7 +2224,7 @@ export class SceneProcessor {
 
 		const changed = this.emissiveTriangleBuilder.updateMaterialEmissive(
 			materialIndex, mat,
-			this.triangleData, this.materials, this.triangleCount,
+			this.triangles, this.materials, this.triangleCount,
 		);
 
 		if ( ! changed ) return null;
@@ -1739,64 +2277,194 @@ export class SceneProcessor {
 
 	}
 
+	/**
+	 * Copy world-space positions into `dst`, each mesh's range carried into its own space.
+	 * @private
+	 */
+	/**
+	 * Build the TLAS, off the main thread when a worker is available.
+	 *
+	 * The worker returns structure only; leaf payloads are filled here. On any failure the
+	 * synchronous path runs instead, so a blocked or unavailable worker costs responsiveness,
+	 * never a scene.
+	 * @private
+	 */
+	async _buildTLAS( table ) {
+
+		const n = table.count;
+
+		// Below this the build is a few ms and the round trip costs more than it saves.
+		if ( n >= TLAS_WORKER_MIN_ENTRIES && ! this._tlasWorkerFailed ) {
+
+			try {
+
+				// The worker needs a buffer it can own, and world bounds are derived anyway.
+				const aabbs = new Float64Array( n * 6 );
+				table.writeWorldAABBs( aabbs );
+				const { tlasData, nodeCount } = await this._runTLASWorker( aabbs, n );
+				TLASBuilder.fillLeaves( tlasData, nodeCount, table );
+				return tlasData;
+
+			} catch ( error ) {
+
+				this._tlasWorkerFailed = true;
+				log.warn( `TLAS worker unavailable (${error.message}); building on the main thread` );
+
+			}
+
+		}
+
+		return this.tlasBuilder.build( table ).data;
+
+	}
+
+	/** @private */
+	_runTLASWorker( aabbs, count ) {
+
+		if ( ! this._tlasWorker ) this._tlasWorker = new TLASWorker();
+		const worker = this._tlasWorker;
+
+		return new Promise( ( resolve, reject ) => {
+
+			const done = ( event ) => {
+
+				worker.removeEventListener( 'message', done );
+				worker.removeEventListener( 'error', failed );
+				if ( event.data?.error ) reject( new Error( event.data.error ) );
+				else resolve( event.data );
+
+			};
+
+			const failed = ( event ) => {
+
+				worker.removeEventListener( 'message', done );
+				worker.removeEventListener( 'error', failed );
+				reject( new Error( event.message || 'worker error' ) );
+
+			};
+
+			worker.addEventListener( 'message', done );
+			worker.addEventListener( 'error', failed );
+			worker.postMessage(
+				{ aabbs: aabbs.buffer, count, logLevel: workerLogLevel() },
+				[ aabbs.buffer ]
+			);
+
+		} );
+
+	}
+
+	/** Keep the f32 view in step with the uint record buffer. @private */
+	/** Keep the chunked BVH and its u32 index view in step. @private */
+	_setBVHData( data ) {
+
+		const records = ! data ? null
+			: ( data instanceof ChunkedRecords
+				? data
+				: ChunkedRecords.adopt( [ data ], data.length / 16, 16, data.length / 16 ) );
+
+		this.bvh = records;
+		this.bvhIndexChunks = records ? records.viewAs( Uint32Array ) : null;
+		// Null once the BVH needs more than one chunk; hot paths use `bvh` / `bvhIndexChunks`.
+		this.bvhData = records ? records.single : null;
+		this.bvhIndex = this.bvhIndexChunks ? this.bvhIndexChunks.single : null;
+
+	}
+
+	_setTriangleData( data ) {
+
+		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
+		const records = ! data ? null
+			: ( data instanceof ChunkedRecords
+				? data
+				: ChunkedRecords.adopt( [ data ], data.length / FPT, FPT, data.length / FPT ) );
+
+		this.triangles = records;
+		this.triangleFloatChunks = records ? records.viewAs( Float32Array ) : null;
+		// Null once the scene needs more than one chunk; everything hot goes through
+		// `triangles` / `triangleFloatChunks` instead.
+		this.triangleData = records ? records.single : null;
+		this.triangleFloats = this.triangleFloatChunks ? this.triangleFloatChunks.single : null;
+
+	}
+
 	/**
 	 * Update triangle positions for a single mesh entry.
 	 * Iterates in BVH order for sequential writes (cache-friendly), random reads from newPositions.
 	 * @private
 	 */
-	_updateMeshTrianglePositions( entry, newPositions ) {
+	_updateMeshTrianglePositions( i, meshPositions ) {
 
-		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const PA = TRIANGLE_DATA_LAYOUT.POSITION_A_OFFSET;
 		const PB = TRIANGLE_DATA_LAYOUT.POSITION_B_OFFSET;
 		const PC = TRIANGLE_DATA_LAYOUT.POSITION_C_OFFSET;
-		const NA = TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET;
-		const NB = TRIANGLE_DATA_LAYOUT.NORMAL_B_OFFSET;
-		const NC = TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET;
-
-		const bvhToOrig = entry.bvhToOriginal;
-
-		for ( let bvhLocal = 0; bvhLocal < entry.triCount; bvhLocal ++ ) {
-
-			const origLocal = bvhToOrig[ bvhLocal ];
-			const dst = ( entry.triOffset + bvhLocal ) * FPT;
-			const src = ( entry.triOffset + origLocal ) * 9;
-
-			const ax = newPositions[ src ];
-			const ay = newPositions[ src + 1 ];
-			const az = newPositions[ src + 2 ];
-			const bx = newPositions[ src + 3 ];
-			const by = newPositions[ src + 4 ];
-			const bz = newPositions[ src + 5 ];
-			const cx = newPositions[ src + 6 ];
-			const cy = newPositions[ src + 7 ];
-			const cz = newPositions[ src + 8 ];
-
-			this.triangleData[ dst + PA ] = ax;
-			this.triangleData[ dst + PA + 1 ] = ay;
-			this.triangleData[ dst + PA + 2 ] = az;
-			this.triangleData[ dst + PB ] = bx;
-			this.triangleData[ dst + PB + 1 ] = by;
-			this.triangleData[ dst + PB + 2 ] = bz;
-			this.triangleData[ dst + PC ] = cx;
-			this.triangleData[ dst + PC + 1 ] = cy;
-			this.triangleData[ dst + PC + 2 ] = cz;
+		const NA = TRIANGLE_DATA_LAYOUT.NORMAL_A_PACKED_OFFSET;
+		const NB = TRIANGLE_DATA_LAYOUT.NORMAL_B_PACKED_OFFSET;
+		const NC = TRIANGLE_DATA_LAYOUT.NORMAL_C_PACKED_OFFSET;
+		const tri = this.triangles, triF = this.triangleFloatChunks;
+		const table = this.instanceTable;
+
+		const bvhToOrig = table.bvhToOriginalOf( i );
+		const triOffset = table.triOffsetOf( i ), triCount = table.triCountOf( i );
+
+		// Callers hand over world-space positions, which is the only space they can build
+		// one in; triangles are stored per instance, so they come back through the inverse.
+		const m = table.matrixInverseOf( i );
+		const identity = isIdentity( m );
+
+		for ( let bvhLocal = 0; bvhLocal < triCount; bvhLocal ++ ) {
+
+			const origLocal = bvhToOrig ? bvhToOrig[ bvhLocal ] : bvhLocal;
+			const t = triOffset + bvhLocal;
+			const f = triF.chunkFor( t ), u = tri.chunkFor( t );
+			const dst = tri.baseOf( t );
+			const src = origLocal * 9;
+
+			let ax = meshPositions[ src ];
+			let ay = meshPositions[ src + 1 ];
+			let az = meshPositions[ src + 2 ];
+			let bx = meshPositions[ src + 3 ];
+			let by = meshPositions[ src + 4 ];
+			let bz = meshPositions[ src + 5 ];
+			let cx = meshPositions[ src + 6 ];
+			let cy = meshPositions[ src + 7 ];
+			let cz = meshPositions[ src + 8 ];
+
+			if ( ! identity ) {
+
+				const px = ( x, y, z ) => m[ 0 ] * x + m[ 4 ] * y + m[ 8 ] * z + m[ 12 ];
+				const py = ( x, y, z ) => m[ 1 ] * x + m[ 5 ] * y + m[ 9 ] * z + m[ 13 ];
+				const pz = ( x, y, z ) => m[ 2 ] * x + m[ 6 ] * y + m[ 10 ] * z + m[ 14 ];
+				const a = [ px( ax, ay, az ), py( ax, ay, az ), pz( ax, ay, az ) ];
+				const b = [ px( bx, by, bz ), py( bx, by, bz ), pz( bx, by, bz ) ];
+				const c = [ px( cx, cy, cz ), py( cx, cy, cz ), pz( cx, cy, cz ) ];
+				ax = a[ 0 ]; ay = a[ 1 ]; az = a[ 2 ];
+				bx = b[ 0 ]; by = b[ 1 ]; bz = b[ 2 ];
+				cx = c[ 0 ]; cy = c[ 1 ]; cz = c[ 2 ];
+
+			}
+
+			f[ dst + PA ] = ax;
+			f[ dst + PA + 1 ] = ay;
+			f[ dst + PA + 2 ] = az;
+			f[ dst + PB ] = bx;
+			f[ dst + PB + 1 ] = by;
+			f[ dst + PB + 2 ] = bz;
+			f[ dst + PC ] = cx;
+			f[ dst + PC + 1 ] = cy;
+			f[ dst + PC + 2 ] = cz;
 
 			const abx = bx - ax, aby = by - ay, abz = bz - az;
 			const acx = cx - ax, acy = cy - ay, acz = cz - az;
-			const nx = aby * acz - abz * acy;
-			const ny = abz * acx - abx * acz;
-			const nz = abx * acy - aby * acx;
-
-			this.triangleData[ dst + NA ] = nx;
-			this.triangleData[ dst + NA + 1 ] = ny;
-			this.triangleData[ dst + NA + 2 ] = nz;
-			this.triangleData[ dst + NB ] = nx;
-			this.triangleData[ dst + NB + 1 ] = ny;
-			this.triangleData[ dst + NB + 2 ] = nz;
-			this.triangleData[ dst + NC ] = nx;
-			this.triangleData[ dst + NC + 1 ] = ny;
-			this.triangleData[ dst + NC + 2 ] = nz;
+			const packed = packNormalOct(
+				aby * acz - abz * acy,
+				abz * acx - abx * acz,
+				abx * acy - aby * acx
+			);
+
+			u[ dst + NA ] = packed;
+			u[ dst + NB ] = packed;
+			u[ dst + NC ] = packed;
 
 		}
 
@@ -1806,9 +2474,13 @@ export class SceneProcessor {
 	 * Patch smooth normals for a single mesh's triangles.
 	 * @private
 	 */
-	_patchMeshSmoothNormals( entry, normals ) {
+	_patchMeshSmoothNormals( i, meshNormals ) {
 
-		this._patchNormalsRange( normals, entry.triOffset, entry.triCount );
+		const table = this.instanceTable;
+		this._patchNormalsRange(
+			meshNormals, table.triOffsetOf( i ), table.triCountOf( i ),
+			table.matrixWorldOf( i ), table.bvhToOriginalOf( i )
+		);
 
 	}
 
@@ -1816,29 +2488,47 @@ export class SceneProcessor {
 	 * Shared normal-patching loop for a range of triangles.
 	 * @private
 	 */
-	_patchNormalsRange( normals, startOrig, count ) {
+	_patchNormalsRange( normals, triOffset, count, matrixWorld, bvhToOrig ) {
 
-		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
-		const NA = TRIANGLE_DATA_LAYOUT.NORMAL_A_OFFSET;
-		const NB = TRIANGLE_DATA_LAYOUT.NORMAL_B_OFFSET;
-		const NC = TRIANGLE_DATA_LAYOUT.NORMAL_C_OFFSET;
-
-		for ( let i = 0; i < count; i ++ ) {
-
-			const orig = startOrig + i;
-			const bvhIdx = this.originalToBvhMap[ orig ];
-			const dst = bvhIdx * FPT;
-			const src = orig * 9;
-
-			this.triangleData[ dst + NA ] = normals[ src ];
-			this.triangleData[ dst + NA + 1 ] = normals[ src + 1 ];
-			this.triangleData[ dst + NA + 2 ] = normals[ src + 2 ];
-			this.triangleData[ dst + NB ] = normals[ src + 3 ];
-			this.triangleData[ dst + NB + 1 ] = normals[ src + 4 ];
-			this.triangleData[ dst + NB + 2 ] = normals[ src + 5 ];
-			this.triangleData[ dst + NC ] = normals[ src + 6 ];
-			this.triangleData[ dst + NC + 1 ] = normals[ src + 7 ];
-			this.triangleData[ dst + NC + 2 ] = normals[ src + 8 ];
+		const NA = TRIANGLE_DATA_LAYOUT.NORMAL_A_PACKED_OFFSET;
+		const NB = TRIANGLE_DATA_LAYOUT.NORMAL_B_PACKED_OFFSET;
+		const NC = TRIANGLE_DATA_LAYOUT.NORMAL_C_PACKED_OFFSET;
+
+		// Callers supply world-space normals. Traversal takes object normals out through the
+		// transpose of world-to-object, so coming the other way is the transpose of
+		// object-to-world — not its inverse, which is what a position would use.
+		const m = matrixWorld;
+		const plain = ! m || isIdentity( m );
+		const slots = [ NA, NB, NC ];
+
+		// Walked in stored order so the writes stay sequential; the inverse map is the only
+		// permutation kept, so the read is the scattered side.
+		for ( let k = 0; k < count; k ++ ) {
+
+			const bvhIdx = triOffset + k;
+			const u = this.triangles.chunkFor( bvhIdx );
+			const dst = this.triangles.baseOf( bvhIdx );
+			const src = ( bvhToOrig ? bvhToOrig[ k ] : k ) * 9;
+
+			for ( let v = 0; v < 3; v ++ ) {
+
+				const s = src + v * 3;
+				const nx = normals[ s ], ny = normals[ s + 1 ], nz = normals[ s + 2 ];
+				let ox = nx, oy = ny, oz = nz;
+
+				if ( ! plain ) {
+
+					ox = m[ 0 ] * nx + m[ 1 ] * ny + m[ 2 ] * nz;
+					oy = m[ 4 ] * nx + m[ 5 ] * ny + m[ 6 ] * nz;
+					oz = m[ 8 ] * nx + m[ 9 ] * ny + m[ 10 ] * nz;
+					const len = Math.hypot( ox, oy, oz ) || 1;
+					ox /= len; oy /= len; oz /= len;
+
+				}
+
+				u[ dst + slots[ v ] ] = packNormalOct( ox, oy, oz );
+
+			}
 
 		}
 
@@ -1861,66 +2551,50 @@ export class SceneProcessor {
 
 		}
 
-		// Build blasOffset → entry lookup (avoids O(M) .find() per leaf)
-		if ( ! this._blasOffsetMap ) {
-
-			this._blasOffsetMap = new Map();
-
-		}
-
-		this._blasOffsetMap.clear();
-		for ( const entry of this.instanceTable.entries ) {
-
-			if ( ! entry ) continue;
-			this._blasOffsetMap.set( entry.blasOffset, entry );
-
-		}
+		const table = this.instanceTable;
 
 		// Bottom-up pass: reverse iteration over TLAS nodes
 		for ( let i = tlasNodeCount - 1; i >= 0; i -- ) {
 
-			const o = i * FPN;
-			const marker = this.bvhData[ o + 3 ];
+			const idxChunk = this.bvhIndexChunks.chunkFor( i );
+			const fChunk = this.bvh.chunkFor( i );
+			const o = this.bvh.baseOf( i );
+			const marker = idxChunk[ o + 3 ];
 
-			if ( marker === - 2 ) {
+			if ( marker === BVH_LEAF_MARKERS.BLAS_POINTER_LEAF ) {
 
-				// BLAS-pointer leaf: read AABB from instance table
-				const blasRoot = this.bvhData[ o ];
-				const entry = this._blasOffsetMap.get( blasRoot );
-				if ( entry && entry.worldAABB ) {
+				// Slot [1] is this leaf's own placement. Keying off slot [0] instead collapsed
+				// every placement of a shared geometry onto one box, so all but one copy sat
+				// outside its own bounds and rays walked straight past it.
+				const entryIndex = idxChunk[ o + 1 ] & TLAS_PLACEMENT_MASK;
+				if ( entryIndex < table.count ) {
 
-					const b = i * 6;
-					this._tlasBounds[ b ] = entry.worldAABB.minX;
-					this._tlasBounds[ b + 1 ] = entry.worldAABB.minY;
-					this._tlasBounds[ b + 2 ] = entry.worldAABB.minZ;
-					this._tlasBounds[ b + 3 ] = entry.worldAABB.maxX;
-					this._tlasBounds[ b + 4 ] = entry.worldAABB.maxY;
-					this._tlasBounds[ b + 5 ] = entry.worldAABB.maxZ;
+					table.writeWorldAABB( entryIndex, this._tlasBounds, i * 6 );
 
 				}
 
-			} else if ( marker >= 0 ) {
+			} else if ( marker < BVH_LEAF_MARKERS.TRIANGLE_LEAF ) {
 
 				// Inner node: union of children bounds, update bvhData in-place
-				const leftIdx = this.bvhData[ o + 3 ];
-				const rightIdx = this.bvhData[ o + 7 ];
+				const leftIdx = marker;
+				const rightIdx = idxChunk[ o + 7 ];
 				const lb = leftIdx * 6;
 				const rb = rightIdx * 6;
 				const bounds = this._tlasBounds;
 
-				this.bvhData[ o ] = bounds[ lb ];
-				this.bvhData[ o + 1 ] = bounds[ lb + 1 ];
-				this.bvhData[ o + 2 ] = bounds[ lb + 2 ];
-				this.bvhData[ o + 4 ] = bounds[ lb + 3 ];
-				this.bvhData[ o + 5 ] = bounds[ lb + 4 ];
-				this.bvhData[ o + 6 ] = bounds[ lb + 5 ];
+				fChunk[ o ] = bounds[ lb ];
+				fChunk[ o + 1 ] = bounds[ lb + 1 ];
+				fChunk[ o + 2 ] = bounds[ lb + 2 ];
+				fChunk[ o + 4 ] = bounds[ lb + 3 ];
+				fChunk[ o + 5 ] = bounds[ lb + 4 ];
+				fChunk[ o + 6 ] = bounds[ lb + 5 ];
 
-				this.bvhData[ o + 8 ] = bounds[ rb ];
-				this.bvhData[ o + 9 ] = bounds[ rb + 1 ];
-				this.bvhData[ o + 10 ] = bounds[ rb + 2 ];
-				this.bvhData[ o + 12 ] = bounds[ rb + 3 ];
-				this.bvhData[ o + 13 ] = bounds[ rb + 4 ];
-				this.bvhData[ o + 14 ] = bounds[ rb + 5 ];
+				fChunk[ o + 8 ] = bounds[ rb ];
+				fChunk[ o + 9 ] = bounds[ rb + 1 ];
+				fChunk[ o + 10 ] = bounds[ rb + 2 ];
+				fChunk[ o + 12 ] = bounds[ rb + 3 ];
+				fChunk[ o + 13 ] = bounds[ rb + 4 ];
+				fChunk[ o + 14 ] = bounds[ rb + 5 ];
 
 				const b = i * 6;
 				bounds[ b ] = Math.min( bounds[ lb ], bounds[ rb ] );
@@ -1946,18 +2620,14 @@ export class SceneProcessor {
 	 */
 	scheduleBackgroundRebuild( meshIndices, onSwap ) {
 
-		if ( ! this.instanceTable || ! this.triangleData ) return;
+		if ( ! this.instanceTable || ! this.triangles ) return;
 
-		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		this._rebuildGeneration ++;
 		const generation = this._rebuildGeneration;
 
 		const dispatchRebuild = ( meshIdx, entry, worker ) => {
 
-			const meshTriData = this.triangleData.slice(
-				entry.triOffset * FPT,
-				( entry.triOffset + entry.triCount ) * FPT
-			);
+			const meshTriData = this.triangles.copyOf( entry.triOffset, entry.triCount );
 
 			this._pendingRebuilds.set( meshIdx, worker );
 
@@ -1998,6 +2668,13 @@ export class SceneProcessor {
 				triangleByteLength: meshTriData.byteLength,
 				triangleCount: entry.triCount,
 				depth: this.config.bvhDepth,
+				// Without these the worker builds at its own defaults (leaf size 8 against the
+				// scene's 4), producing a tree of a different size that the swap below rejects —
+				// so every rebuild was thrown away.
+				maxLeafSize: this.bvhBuilder.maxLeafSize,
+				numBins: this.bvhBuilder.numBins,
+				maxBins: this.bvhBuilder.maxBins,
+				minBins: this.bvhBuilder.minBins,
 				reportProgress: false,
 				sharedReorderBuffer: null,
 				treeletOptimization: {
@@ -2016,16 +2693,20 @@ export class SceneProcessor {
 
 		};
 
-		for ( const meshIdx of meshIndices ) {
+		for ( const meshIndex of meshIndices ) {
 
-			const entry = this.instanceTable.entries[ meshIdx ];
-			if ( ! entry ) continue;
+			const placement = this._placementOf( meshIndex );
+			if ( placement < 0 ) continue;
+			const entry = this.instanceTable.entryAt( placement );
+			// A placement that borrows another's BLAS must not rebuild it: the work is the
+			// owner's, and two placements would dispatch the same rebuild twice.
+			if ( ! entry || ! this.instanceTable.isOwner( placement ) ) continue;
 
 			// Cancel any in-flight rebuild for this mesh
-			const existing = this._pendingRebuilds.get( meshIdx );
+			const existing = this._pendingRebuilds.get( placement );
 			if ( existing ) existing.terminate();
 
-			dispatchRebuild( meshIdx, entry, new BVHWorker() );
+			dispatchRebuild( placement, entry, new BVHWorker() );
 
 		}
 
@@ -2041,59 +2722,62 @@ export class SceneProcessor {
 		const newBvhData = workerData.bvhData;
 		const newNodeCount = newBvhData.length / FPN;
 
-		// Node count must match — refit doesn't change topology, rebuild shouldn't either
-		// for the same triangle set. If it differs, the buffer layout is invalid.
-		if ( newNodeCount !== entry.blasNodeCount ) {
+		// The rebuilt tree only has to fit the range the build reserved. Demanding an exact match
+		// was too strict: the triangles have moved, so the splits land differently and the count
+		// legitimately drifts. Anything past the reserved range would overwrite the next BLAS.
+		if ( newNodeCount > entry.blasNodeCount ) {
 
-			log.warn( `background rebuild node count mismatch for mesh ${meshIdx} (${newNodeCount} vs ${entry.blasNodeCount}), skipping swap` );
+			log.warn( `background rebuild does not fit for mesh ${meshIdx} (${newNodeCount} nodes vs ${entry.blasNodeCount} reserved), skipping swap` );
 			return;
 
 		}
 
 		// Write rebuilt BLAS nodes into the combined buffer at the entry's offset
-		const destOffset = entry.blasOffset * FPN;
-		this.bvhData.set( newBvhData, destOffset );
-		this._offsetBLASInPlace( destOffset, newNodeCount, entry.blasOffset, entry.triOffset );
+		this.bvh.setRecords( entry.blasOffset, newBvhData );
+		this._offsetBLASInPlace( entry.blasOffset, newNodeCount, entry.blasOffset, entry.triOffset );
 
 		// Write reordered triangles back into global array
-		const FPT = TRIANGLE_DATA_LAYOUT.FLOATS_PER_TRIANGLE;
 		const reorderedTris = workerData.triangles;
 		if ( reorderedTris ) {
 
-			this.triangleData.set( reorderedTris, entry.triOffset * FPT );
+			this.triangles.setRecords( entry.triOffset, reorderedTris );
 
 		}
 
-		// Update per-mesh maps
+		// The live tree is whatever the rebuild produced; any reserved nodes past it are dead and
+		// nothing reaches them, but a later refit would walk them as garbage.
+		this.instanceTable.setBlasNodeCount( meshIdx, newNodeCount );
+
+		// The rebuild reordered the triangles, so the map from stored order back to the caller's
+		// order has to follow. `entryAt()` hands back a snapshot, so writing it there was lost and
+		// the next refit scattered every position through the previous permutation.
+		//
+		// The worker was handed the triangles already in stored order, so its permutation is
+		// relative to that, not to the caller's order. Overwriting rather than composing would
+		// discard how the original build shuffled them.
 		const newOrigToBvh = workerData.originalToBvh;
 		if ( newOrigToBvh ) {
 
-			// Update global originalToBvhMap for this mesh's range
-			for ( let i = 0; i < entry.triCount; i ++ ) {
-
-				this.originalToBvhMap[ entry.triOffset + i ] = entry.triOffset + newOrigToBvh[ i ];
-
-			}
-
-			// Update per-mesh bvhToOriginal
+			const prev = this.instanceTable.bvhToOriginalOf( meshIdx );
 			const bvhToOrig = new Uint32Array( entry.triCount );
 			for ( let i = 0; i < entry.triCount; i ++ ) {
 
-				bvhToOrig[ newOrigToBvh[ i ] ] = i;
+				bvhToOrig[ newOrigToBvh[ i ] ] = prev ? prev[ i ] : i;
 
 			}
 
-			entry.bvhToOriginal = bvhToOrig;
+			this.instanceTable.setBvhToOriginal( meshIdx, bvhToOrig );
 
 		}
 
 		// Recompute AABB and refit TLAS
-		this.instanceTable.recomputeAABB( meshIdx, this.bvhData, this.triangleData );
+		this.instanceTable.recomputeAABB( meshIdx, this.bvh, this.triangles );
 		this._refitTLAS();
 
 		this._log( `Background BLAS rebuild complete for mesh ${meshIdx}` );
 
-		onSwap?.();
+		// The caller asked in mesh indices and gets one back, not the placement used here.
+		onSwap?.( this.instanceTable.sourceMesh[ meshIdx ] ?? meshIdx );
 
 	}
 
@@ -2130,6 +2814,18 @@ export class SceneProcessor {
 
 	}
 
+	/** @private */
+	_disposeTLASWorker() {
+
+		if ( this._tlasWorker ) {
+
+			this._tlasWorker.terminate();
+			this._tlasWorker = null;
+
+		}
+
+	}
+
 	/**
      * Completely dispose of all resources
      * Call this when the instance is no longer needed
@@ -2138,8 +2834,9 @@ export class SceneProcessor {
 
 		this._log( 'Disposing resources' );
 
-		// Dispose refit worker
+		// Dispose workers
 		this._disposeRefitWorker();
+		this._disposeTLASWorker();
 
 		// Dispose textures
 		this._disposeTextures();