rayzee 5.6.0 → 5.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineEvents.js

@@ -50,4 +50,7 @@ export const EngineEvents = {
 	// Video rendering
 	VIDEO_RENDER_PROGRESS: 'engine:videoRenderProgress',
 	VIDEO_RENDER_COMPLETE: 'engine:videoRenderComplete',
+
+	// Lifecycle
+	DISPOSE: 'engine:dispose',
 };

package/src/Passes/AIUpscaler.js

@@ -104,6 +104,7 @@ export class AIUpscaler extends EventDispatcher {
 		this._worker = null;
 		this._currentModelUrl = null;
 		this._tileId = 0;
+		this._pendingWorkerHandlers = new Set();
 
 		// Alpha channel cache (bilinear-upscaled from source, applied per tile)
 		this._upscaledAlpha = null;
@@ -315,6 +316,7 @@ export class AIUpscaler extends EventDispatcher {
 
 			this._capturedSource = null;
 			this._upscaledAlpha = null;
+			this._backupCanvas = null;
 
 			// Only clean up if abort() hasn't already done it
 			if ( this.state.isUpscaling ) {
@@ -334,6 +336,7 @@ export class AIUpscaler extends EventDispatcher {
 		if ( ! this.state.isUpscaling ) return;
 
 		this.state.abortController?.abort();
+		this._cleanupPendingWorkerHandlers();
 
 		// Restore input visibility and canvas state
 		this.input.style.opacity = '1';
@@ -610,6 +613,7 @@ export class AIUpscaler extends EventDispatcher {
 
 				if ( e.data.id !== id ) return;
 				this._worker.removeEventListener( 'message', handler );
+				this._pendingWorkerHandlers.delete( handler );
 
 				if ( e.data.type === 'inferred' ) {
 
@@ -623,6 +627,7 @@ export class AIUpscaler extends EventDispatcher {
 
 			};
 
+			this._pendingWorkerHandlers.add( handler );
 			this._worker.addEventListener( 'message', handler );
 			this._worker.postMessage(
 				{ type: 'infer', tileData, width, height, id },
@@ -858,9 +863,26 @@ export class AIUpscaler extends EventDispatcher {
 
 	// ─── Disposal ─────────────────────────────────────────────────────────────
 
+	_cleanupPendingWorkerHandlers() {
+
+		if ( this._worker ) {
+
+			for ( const handler of this._pendingWorkerHandlers ) {
+
+				this._worker.removeEventListener( 'message', handler );
+
+			}
+
+		}
+
+		this._pendingWorkerHandlers.clear();
+
+	}
+
 	async dispose() {
 
 		this.abort();
+		this._cleanupPendingWorkerHandlers();
 
 		if ( this._worker ) {
 

package/src/Passes/OIDNDenoiser.js

@@ -87,6 +87,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		// renderer.getArrayBufferAsync because the source is a raw GPUBuffer,
 		// not a Three.js BufferAttribute.
 		this._alphaReadbackBuffer = null;
+		this._alphaReadbackMapped = false;
 
 		// Cached alpha channel from the input color buffer (OIDN discards alpha)
 		this._cachedAlpha = null;
@@ -108,6 +109,9 @@ export class OIDNDenoiser extends EventDispatcher {
 			abortController: null
 		};
 
+		// Track in-flight tile staging buffers so they can be destroyed on abort
+		this._pendingStagingBuffers = new Set();
+
 		this.currentTZAUrl = null;
 		this.unet = null;
 
@@ -514,7 +518,22 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._gpuInputBuffers.albedo?.destroy();
 		this._gpuInputBuffers.normal?.destroy();
 		this._gpuInputPadBuffer?.destroy();
+
+		// Unmap before destroying if a mapAsync resolved but unmap hasn't been called yet.
+		// If mapAsync is still pending, destroy() will reject it — _cacheInputAlpha's
+		// catch handler covers that case.
+		if ( this._alphaReadbackMapped && this._alphaReadbackBuffer ) {
+
+			try {
+
+				this._alphaReadbackBuffer.unmap();
+
+			} catch { /* already unmapped or destroyed */ }
+
+		}
+
 		this._alphaReadbackBuffer?.destroy();
+		this._alphaReadbackMapped = false;
 		this._gpuInputBuffers = { color: null, albedo: null, normal: null };
 		this._gpuInputPadBuffer = null;
 		this._gpuInputPaddedRowBytes = 0;
@@ -550,7 +569,19 @@ export class OIDNDenoiser extends EventDispatcher {
 		enc.copyBufferToBuffer( this._gpuInputBuffers.color, 0, staging, 0, byteSize );
 		device.queue.submit( [ enc.finish() ] );
 
-		await staging.mapAsync( GPUMapMode.READ );
+		this._alphaReadbackMapped = true;
+		try {
+
+			await staging.mapAsync( GPUMapMode.READ );
+
+		} catch {
+
+			// Buffer was destroyed while mapAsync was pending (resize or dispose)
+			this._alphaReadbackMapped = false;
+			return;
+
+		}
+
 		const f32 = new Float32Array( staging.getMappedRange() );
 
 		// Extract alpha channel as uint8 (pre-multiplied is not needed — alpha is 0 or 1)
@@ -563,6 +594,7 @@ export class OIDNDenoiser extends EventDispatcher {
 		}
 
 		staging.unmap();
+		this._alphaReadbackMapped = false;
 
 		this._cachedAlpha = alpha;
 		this._cachedAlphaWidth = width;
@@ -653,6 +685,8 @@ export class OIDNDenoiser extends EventDispatcher {
 						usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
 					} );
 
+					this._pendingStagingBuffers.add( staging );
+
 					// Copy each tile row from its position in the full output buffer
 					const enc = device.createCommandEncoder();
 
@@ -710,8 +744,15 @@ export class OIDNDenoiser extends EventDispatcher {
 
 						staging.unmap();
 						staging.destroy();
+						this._pendingStagingBuffers.delete( staging );
 						this.ctx.putImageData( tileImageData, tile.x, tile.y );
 
+					} ).catch( () => {
+
+						// mapAsync rejected (abort or GPU lost) — destroy the buffer
+						staging.destroy();
+						this._pendingStagingBuffers.delete( staging );
+
 					} );
 
 				}
@@ -745,44 +786,50 @@ export class OIDNDenoiser extends EventDispatcher {
 			usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
 		} );
 
-		// Queue a copy from the oidn output buffer (STORAGE|COPY_SRC) to staging
-		const encoder = device.createCommandEncoder( { label: 'oidn-readback' } );
-		encoder.copyBufferToBuffer( gpuBuffer, 0, stagingBuffer, 0, byteSize );
-		device.queue.submit( [ encoder.finish() ] );
+		try {
+
+			// Queue a copy from the oidn output buffer (STORAGE|COPY_SRC) to staging
+			const encoder = device.createCommandEncoder( { label: 'oidn-readback' } );
+			encoder.copyBufferToBuffer( gpuBuffer, 0, stagingBuffer, 0, byteSize );
+			device.queue.submit( [ encoder.finish() ] );
+
+			await stagingBuffer.mapAsync( GPUMapMode.READ );
+			const float32 = new Float32Array( stagingBuffer.getMappedRange() );
+
+			const imageData = new ImageData( width, height );
+			const exposure = this.getExposure();
+			const saturation = this.getSaturation();
+			const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
+			const alpha = this._cachedAlpha;
 
-		await stagingBuffer.mapAsync( GPUMapMode.READ );
-		const float32 = new Float32Array( stagingBuffer.getMappedRange() );
+			for ( let i = 0, len = float32.length; i < len; i += 4 ) {
 
-		const imageData = new ImageData( width, height );
-		const exposure = this.getExposure();
-		const saturation = this.getSaturation();
-		const tmFn = TONE_MAP_FNS.get( this.getToneMapping() ) || TONE_MAP_FNS.get( ACESFilmicToneMapping );
-		const alpha = this._cachedAlpha;
+				// Exposure + saturation (pre-tonemap, matching Display)
+				let er = float32[ i ] * exposure, eg = float32[ i + 1 ] * exposure, eb = float32[ i + 2 ] * exposure;
+				if ( saturation !== 1.0 ) {
 
-		for ( let i = 0, len = float32.length; i < len; i += 4 ) {
+					_tmOut[ 0 ] = er; _tmOut[ 1 ] = eg; _tmOut[ 2 ] = eb;
+					applySaturation( _tmOut, saturation );
+					er = _tmOut[ 0 ]; eg = _tmOut[ 1 ]; eb = _tmOut[ 2 ];
 
-			// Exposure + saturation (pre-tonemap, matching Display)
-			let er = float32[ i ] * exposure, eg = float32[ i + 1 ] * exposure, eb = float32[ i + 2 ] * exposure;
-			if ( saturation !== 1.0 ) {
+				}
 
-				_tmOut[ 0 ] = er; _tmOut[ 1 ] = eg; _tmOut[ 2 ] = eb;
-				applySaturation( _tmOut, saturation );
-				er = _tmOut[ 0 ]; eg = _tmOut[ 1 ]; eb = _tmOut[ 2 ];
+				tmFn( er, eg, eb, 1.0, _tmOut );
+				imageData.data[ i ] = _tmOut[ 0 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 1 ] = _tmOut[ 1 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 2 ] = _tmOut[ 2 ] ** SRGB_GAMMA * 255 | 0;
+				imageData.data[ i + 3 ] = alpha ? alpha[ i >> 2 ] : 255;
 
 			}
 
-			tmFn( er, eg, eb, 1.0, _tmOut );
-			imageData.data[ i ] = _tmOut[ 0 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 1 ] = _tmOut[ 1 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 2 ] = _tmOut[ 2 ] ** SRGB_GAMMA * 255 | 0;
-			imageData.data[ i + 3 ] = alpha ? alpha[ i >> 2 ] : 255;
+			stagingBuffer.unmap();
+			this.ctx.putImageData( imageData, 0, 0 );
 
-		}
+		} finally {
 
-		stagingBuffer.unmap();
-		stagingBuffer.destroy();
+			stagingBuffer.destroy();
 
-		this.ctx.putImageData( imageData, 0, 0 );
+		}
 
 	}
 
@@ -793,6 +840,9 @@ export class OIDNDenoiser extends EventDispatcher {
 		// Signal abort to current operation
 		this.state.abortController?.abort();
 
+		// Destroy any in-flight tile staging buffers that mapAsync won't resolve
+		this._destroyPendingStagingBuffers();
+
 		// Restore input visibility
 		this.input.style.opacity = '1';
 
@@ -896,11 +946,26 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	}
 
+	_destroyPendingStagingBuffers() {
+
+		for ( const buf of this._pendingStagingBuffers ) {
+
+			buf.destroy();
+
+		}
+
+		this._pendingStagingBuffers.clear();
+
+	}
+
 	dispose() {
 
 		// Abort any ongoing operations
 		this.abort();
 
+		// Destroy any remaining staging buffers
+		this._destroyPendingStagingBuffers();
+
 		// Dispose resources
 		this.unet?.dispose();
 		this._destroyGPUInputBuffers();

package/src/PathTracerApp.js

@@ -36,6 +36,10 @@ import { OverlayManager } from './managers/OverlayManager.js';
 import { AnimationManager } from './managers/AnimationManager.js';
 import { TransformManager } from './managers/TransformManager.js';
 
+// One app per canvas — auto-dispose a prior owner if the caller double-
+// instantiates (StrictMode, HMR, etc.) so its rAF loop can't burn CPU.
+const _appsByCanvas = new WeakMap();
+
 
 /**
  * WebGPU Path Tracer Application.
@@ -67,6 +71,18 @@ export class PathTracerApp extends EventDispatcher {
 
 		super();
 
+		try {
+
+			_appsByCanvas.get( canvas )?.dispose();
+
+		} catch ( err ) {
+
+			console.warn( 'PathTracerApp: prior canvas owner dispose failed', err );
+
+		}
+
+		_appsByCanvas.set( canvas, this );
+
 		this.canvas = canvas;
 		this._autoResize = options.autoResize !== false;
 		this._showStats = options.showStats !== false;
@@ -399,6 +415,7 @@ export class PathTracerApp extends EventDispatcher {
 		if ( this._disposed ) return;
 		this._disposed = true;
 
+		this.dispatchEvent( { type: EngineEvents.DISPOSE } );
 		this.stopAnimation();
 		clearTimeout( this._resizeDebounceTimer );
 		this._resizeDebounceTimer = null;

package/src/Pipeline/RenderPipeline.js

@@ -120,6 +120,9 @@ export class RenderPipeline {
 
 			}
 
+			// Prune stale stats entry for removed stage
+			this.stats.timings.delete( stage.name );
+
 			return true;
 
 		}

package/src/Processor/EquirectHDRInfo.js

@@ -172,6 +172,7 @@ export class EquirectHDRInfo {
 		this.marginalData = new Float32Array( [ 0, 1 ] );
 		this.conditionalData = new Float32Array( [ 0, 0, 1, 1 ] );
 		this.totalSum = 0;
+		this.compensationDelta = 0;
 		this.width = 0;
 		this.height = 0;
 
@@ -205,6 +206,7 @@ export class EquirectHDRInfo {
 		this.marginalData = result.marginalData;
 		this.conditionalData = result.conditionalData;
 		this.totalSum = result.totalSum;
+		this.compensationDelta = result.compensationDelta;
 		this.width = width;
 		this.height = height;
 
@@ -263,6 +265,7 @@ export class EquirectHDRInfo {
 			this.marginalData = result.marginalData;
 			this.conditionalData = result.conditionalData;
 			this.totalSum = result.totalSum;
+			this.compensationDelta = result.compensationDelta;
 			this.width = result.width;
 			this.height = result.height;
 
@@ -285,28 +288,87 @@ export class EquirectHDRInfo {
 	 */
 	static computeCDF( floatData, width, height ) {
 
-		const cdfConditional = new Float32Array( width * height );
+		const numPixels = width * height;
+
+		// Pass 1: compute per-pixel luminance weighted by sin(theta) and raw total sum.
+		// sin(theta) compensates for the equirectangular projection: pixels near the poles
+		// cover less solid angle, so weighting by sin(theta) makes the CDF proportional to
+		// luminance per solid angle rather than luminance per pixel.
+		const pixelWeights = new Float32Array( numPixels );
+		let rawTotalSum = 0.0;
+
+		for ( let y = 0; y < height; y ++ ) {
+
+			const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+
+			for ( let x = 0; x < width; x ++ ) {
+
+				const i = y * width + x;
+				const w = colorToLuminance(
+					floatData[ 4 * i ],
+					floatData[ 4 * i + 1 ],
+					floatData[ 4 * i + 2 ],
+				) * sinTheta;
+				pixelWeights[ i ] = w;
+				rawTotalSum += w;
+
+			}
+
+		}
+
+		// MIS Compensation (Karlík et al. 2019, Eq. 14)
+		// With equal sample allocation (c_I = 0.5): delta = 2*(1 - 0.5)*meanWeight = meanWeight
+		// Subtracting mean sharpens the env map PDF, reducing oversampling
+		// of dim regions already well-covered by BSDF sampling.
+		const meanWeight = rawTotalSum / numPixels;
+		let compensatedTotalSum = 0.0;
+
+		for ( let i = 0; i < numPixels; i ++ ) {
+
+			pixelWeights[ i ] = Math.max( 0, pixelWeights[ i ] - meanWeight );
+			compensatedTotalSum += pixelWeights[ i ];
+
+		}
+
+		// Fall back to raw weights if compensation zeroed everything (uniform env map)
+		const useCompensation = compensatedTotalSum > 0;
+		const totalSumValue = useCompensation ? compensatedTotalSum : rawTotalSum;
+		const compensationDelta = useCompensation ? meanWeight : 0;
+
+		if ( ! useCompensation ) {
+
+			for ( let y = 0; y < height; y ++ ) {
+
+				const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+
+				for ( let x = 0; x < width; x ++ ) {
+
+					const i = y * width + x;
+					pixelWeights[ i ] = colorToLuminance(
+						floatData[ 4 * i ],
+						floatData[ 4 * i + 1 ],
+						floatData[ 4 * i + 2 ],
+					) * sinTheta;
+
+				}
+
+			}
+
+		}
+
+		// Pass 2: build conditional and marginal CDFs from (compensated) weights
+		const cdfConditional = new Float32Array( numPixels );
 		const cdfMarginal = new Float32Array( height );
 
-		let totalSumValue = 0.0;
 		let cumulativeWeightMarginal = 0.0;
 
-		// Build conditional CDFs (per-row distribution)
 		for ( let y = 0; y < height; y ++ ) {
 
 			let cumulativeRowWeight = 0.0;
 			for ( let x = 0; x < width; x ++ ) {
 
 				const i = y * width + x;
-				const r = floatData[ 4 * i ];
-				const g = floatData[ 4 * i + 1 ];
-				const b = floatData[ 4 * i + 2 ];
-
-				// Weight by luminance
-				const weight = colorToLuminance( r, g, b );
-				cumulativeRowWeight += weight;
-				totalSumValue += weight;
-
+				cumulativeRowWeight += pixelWeights[ i ];
 				cdfConditional[ i ] = cumulativeRowWeight;
 
 			}
@@ -323,8 +385,6 @@ export class EquirectHDRInfo {
 			}
 
 			cumulativeWeightMarginal += cumulativeRowWeight;
-
-			// Build marginal CDF (row distribution)
 			cdfMarginal[ y ] = cumulativeWeightMarginal;
 
 		}
@@ -342,7 +402,7 @@ export class EquirectHDRInfo {
 
 		// Create inverted CDF arrays (Float32 directly for storage buffers)
 		const marginalData = new Float32Array( height );
-		const conditionalData = new Float32Array( width * height );
+		const conditionalData = new Float32Array( numPixels );
 
 		// Invert marginal CDF
 		for ( let i = 0; i < height; i ++ ) {
@@ -369,7 +429,7 @@ export class EquirectHDRInfo {
 
 		}
 
-		return { marginalData, conditionalData, totalSum: totalSumValue };
+		return { marginalData, conditionalData, totalSum: totalSumValue, compensationDelta };
 
 	}
 

package/src/Processor/ShaderBuilder.js

@@ -365,6 +365,7 @@ export class ShaderBuilder {
 					envMatrix: stage.environmentMatrix,
 					envCDFBuffer: envCDFStorage,
 					envTotalSum: stage.envTotalSum,
+					envCompensationDelta: stage.envCompensationDelta,
 					envResolution: stage.envResolution,
 					enableEnvironmentLight: stage.enableEnvironment,
 					useEnvMapIS: stage.useEnvMapIS,

package/src/Processor/Workers/CDFWorker.js

@@ -33,16 +33,19 @@ function binarySearchFindClosestIndexOf( array, targetValue, offset, count ) {
 
 function buildCDF( floatData, width, height ) {
 
-	const cdfConditional = new Float32Array( width * height );
-	const cdfMarginal = new Float32Array( height );
+	const numPixels = width * height;
 
-	let totalSumValue = 0.0;
-	let cumulativeWeightMarginal = 0.0;
+	// Pass 1: compute per-pixel luminance weighted by sin(theta) and raw total sum.
+	// sin(theta) compensates for the equirectangular projection: pixels near the poles
+	// cover less solid angle, so weighting by sin(theta) makes the CDF proportional to
+	// luminance per solid angle rather than luminance per pixel.
+	const pixelWeights = new Float32Array( numPixels );
+	let rawTotalSum = 0.0;
 
-	// Build conditional CDFs (per-row distribution)
 	for ( let y = 0; y < height; y ++ ) {
 
-		let cumulativeRowWeight = 0.0;
+		const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+
 		for ( let x = 0; x < width; x ++ ) {
 
 			const i = y * width + x;
@@ -50,11 +53,68 @@ function buildCDF( floatData, width, height ) {
 			const g = floatData[ 4 * i + 1 ];
 			const b = floatData[ 4 * i + 2 ];
 
-			// Luminance (Rec. 709)
-			const weight = 0.2126 * r + 0.7152 * g + 0.0722 * b;
-			cumulativeRowWeight += weight;
-			totalSumValue += weight;
+			// Luminance (Rec. 709) weighted by solid angle factor
+			const w = ( 0.2126 * r + 0.7152 * g + 0.0722 * b ) * sinTheta;
+			pixelWeights[ i ] = w;
+			rawTotalSum += w;
+
+		}
+
+	}
+
+	// MIS Compensation (Karlík et al. 2019, Eq. 14)
+	// With equal sample allocation (c_I = 0.5): delta = 2*(1 - 0.5)*meanWeight = meanWeight
+	// Subtracting mean sharpens the env map PDF, reducing oversampling
+	// of dim regions already well-covered by BSDF sampling.
+	const meanWeight = rawTotalSum / numPixels;
+	let compensatedTotalSum = 0.0;
+
+	for ( let i = 0; i < numPixels; i ++ ) {
+
+		pixelWeights[ i ] = Math.max( 0, pixelWeights[ i ] - meanWeight );
+		compensatedTotalSum += pixelWeights[ i ];
+
+	}
+
+	// Fall back to raw weights if compensation zeroed everything (uniform env map)
+	const useCompensation = compensatedTotalSum > 0;
+	const totalSumValue = useCompensation ? compensatedTotalSum : rawTotalSum;
+	const compensationDelta = useCompensation ? meanWeight : 0;
+
+	if ( ! useCompensation ) {
+
+		// Restore raw sin-weighted luminance
+		for ( let y = 0; y < height; y ++ ) {
+
+			const sinTheta = Math.sin( Math.PI * ( y + 0.5 ) / height );
+
+			for ( let x = 0; x < width; x ++ ) {
 
+				const i = y * width + x;
+				const r = floatData[ 4 * i ];
+				const g = floatData[ 4 * i + 1 ];
+				const b = floatData[ 4 * i + 2 ];
+				pixelWeights[ i ] = ( 0.2126 * r + 0.7152 * g + 0.0722 * b ) * sinTheta;
+
+			}
+
+		}
+
+	}
+
+	// Pass 2: build conditional and marginal CDFs from (compensated) weights
+	const cdfConditional = new Float32Array( numPixels );
+	const cdfMarginal = new Float32Array( height );
+
+	let cumulativeWeightMarginal = 0.0;
+
+	for ( let y = 0; y < height; y ++ ) {
+
+		let cumulativeRowWeight = 0.0;
+		for ( let x = 0; x < width; x ++ ) {
+
+			const i = y * width + x;
+			cumulativeRowWeight += pixelWeights[ i ];
 			cdfConditional[ i ] = cumulativeRowWeight;
 
 		}
@@ -111,7 +171,7 @@ function buildCDF( floatData, width, height ) {
 
 	}
 
-	return { marginalData, conditionalData, totalSum: totalSumValue };
+	return { marginalData, conditionalData, totalSum: totalSumValue, compensationDelta };
 
 }
 
@@ -129,6 +189,7 @@ self.onmessage = function ( e ) {
 				marginalData: result.marginalData,
 				conditionalData: result.conditionalData,
 				totalSum: result.totalSum,
+				compensationDelta: result.compensationDelta,
 				width,
 				height,
 			},

package/src/Stages/ASVGF.js

@@ -832,6 +832,24 @@ export class ASVGF extends RenderStage {
 		this._heatmapComputeNode?.dispose();
 		this._heatmapStorageTex?.dispose();
 		this.heatmapTarget?.dispose();
+
+		// Dispose input TextureNode objects
+		this._colorTexNode?.dispose();
+		this._normalDepthTexNode?.dispose();
+		this._motionTexNode?.dispose();
+		this._readTemporalTexNode?.dispose();
+		this._readPrevNDTexNode?.dispose();
+		this._gradientReadTexNode?.dispose();
+
+		// Dispose heatmap TextureNode objects
+		this._heatmapRawColorTexNode?.dispose();
+		this._heatmapColorTexNode?.dispose();
+		this._heatmapTemporalTexNode?.dispose();
+		this._heatmapNDTexNode?.dispose();
+		this._heatmapMotionTexNode?.dispose();
+		this._heatmapGradientTexNode?.dispose();
+
+		// dispose() also removes the DOM node
 		this.heatmapHelper?.dispose();
 
 	}

package/src/Stages/AdaptiveSampling.js

@@ -483,6 +483,7 @@ export class AdaptiveSampling extends RenderStage {
 		this._heatmapStorageTex?.dispose();
 		this._outputStorageTex?.dispose();
 		this.heatmapTarget?.dispose();
+		this._varianceTexNode?.dispose();
 		this.helper?.dispose();
 
 		this._computeNode = null;
@@ -490,6 +491,7 @@ export class AdaptiveSampling extends RenderStage {
 		this._heatmapStorageTex = null;
 		this._outputStorageTex = null;
 		this.heatmapTarget = null;
+		this._varianceTexNode = null;
 		this.helper = null;
 
 	}

package/src/Stages/AutoExposure.js

@@ -698,6 +698,8 @@ export class AutoExposure extends RenderStage {
 		this._reductionStorageTex?.dispose();
 		this._reductionReadTarget?.dispose();
 		this._readbackBuffer?.dispose();
+		this._inputTexNode?.dispose();
+		this._reductionReadTexNode?.dispose();
 
 	}
 

package/src/Stages/BilateralFilter.js

@@ -321,6 +321,8 @@ export class BilateralFilter extends RenderStage {
 		this._computeNodeB?.dispose();
 		this._storageTexA?.dispose();
 		this._storageTexB?.dispose();
+		this._readTexNode?.dispose();
+		this._normalDepthTexNode?.dispose();
 
 	}
 

package/src/Stages/Display.js

@@ -110,6 +110,7 @@ export class Display extends RenderStage {
 
 	dispose() {
 
+		this._displayTexNode?.dispose();
 		this.displayMaterial?.dispose();
 		// QuadMesh extends Mesh — no dispose method; material already disposed.
 		this.displayQuad = null;