rayzee 7.23.0 → 7.23.1

package/package.json

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

package/src/PathTracerApp.js

@@ -63,6 +63,21 @@ const _appsByCanvas = new WeakMap();
 
 const log = createLogger( 'engine' );
 
+/**
+ * Attaches the device-lost handler at module scope so the reaction closure captures only
+ * `holder` — an arrow written inside a method would share that method's context and pin
+ * the app through `this`. See _initRenderer().
+ */
+function attachDeviceLostHandler( device, holder ) {
+
+	device.lost.then( ( info ) => {
+
+		if ( holder.app ) holder.app._handleDeviceLost( info );
+
+	} );
+
+}
+
 export class PathTracerApp extends EventDispatcher {
 
 	/**
@@ -169,6 +184,8 @@ export class PathTracerApp extends EventDispatcher {
 		this._trackedListeners = [];
 		this._disposed = false;
 		this._deviceLost = false;
+		this._gpuDevice = null;
+		this._deviceLostHolder = null;
 
 		// Deterministic-render mode — see setDeterministicMode()
 		this._deterministic = false;
@@ -539,6 +556,24 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		// Value of a WeakMap keyed by a canvas that outlives us: without this the whole
+		// disposed graph stays reachable until another app claims the same canvas.
+		if ( this.canvas && _appsByCanvas.get( this.canvas ) === this ) _appsByCanvas.delete( this.canvas );
+
+		if ( this._gpuDevice ) {
+
+			this._gpuDevice.onuncapturederror = null;
+			this._gpuDevice = null;
+
+		}
+
+		if ( this._deviceLostHolder ) {
+
+			this._deviceLostHolder.app = null;
+			this._deviceLostHolder = null;
+
+		}
+
 		disposeRenderer( this.renderer );
 		this.renderer = null;
 
@@ -2319,15 +2354,21 @@ export class PathTracerApp extends EventDispatcher {
 		// Detect GPU device loss (dGPU/iGPU switch, driver reset, TDR watchdog on heavy
 		// compute). Without this the rAF loop keeps calling render() on a dead device,
 		// spewing errors forever. reason 'destroyed' during dispose() is intentional teardown.
+		//
+		// Neither handler may outlive dispose() still holding this app. The device itself does
+		// outlive it: three's RenderObjects.dispose() drops its chain maps without disposing
+		// the render objects, and its Textures manager leaves a listener on every module-level
+		// texture singleton, so backend and device stay reachable for the page's lifetime. A
+		// handler capturing `this` therefore pinned the whole app graph — ~120 MiB of triangle,
+		// BVH and CPU-side texture data per create/dispose cycle. `lost` is a pending promise
+		// whose reaction cannot be unregistered, so it reads the app out of a holder that
+		// dispose() empties; `onuncapturederror` is cleared there directly.
 		const gpuDevice = this.renderer.backend?.device;
 		if ( gpuDevice?.lost ) {
 
-			gpuDevice.lost.then( ( info ) => {
-
-				if ( this._disposed ) return;
-				this._handleDeviceLost( info );
-
-			} );
+			this._gpuDevice = gpuDevice;
+			this._deviceLostHolder = { app: this };
+			attachDeviceLostHandler( gpuDevice, this._deviceLostHolder );
 			gpuDevice.onuncapturederror = ( event ) => log.error( 'WebGPU uncaptured error:', event.error );
 
 		}

package/src/Processor/utils.js

@@ -1,6 +1,10 @@
 import { SphereGeometry, Mesh, MeshPhysicalMaterial, Group, Object3D, Color, Vector3, ShaderMaterial, Vector2, Matrix4, GLSL3 } from 'three';
+import { QuadMesh } from 'three/webgpu';
 import { EngineEvents } from '../EngineEvents.js';
 
+/** Every QuadMesh in the realm shares this one geometry (module-level in three). */
+const _sharedQuadGeometry = /*@__PURE__*/ new QuadMesh( null ).geometry;
+
 let _statusCallback = null;
 
 /**
@@ -130,6 +134,18 @@ export function disposeRenderer( renderer ) {
 	renderer.dispose();
 	renderer._canvasTarget = null;
 
+	// Three.js 0.185: `RenderObjects.dispose()` drops its chain maps without disposing the
+	// render objects, so each one leaves behind the 'dispose' listener it registered on its
+	// geometry. Full-screen passes render a QuadMesh, and every QuadMesh in the realm shares
+	// one module-level geometry — so that listener list grows by one entry per renderer and
+	// keeps RenderObject → RenderObjects → Bindings → Backend → GPUDevice reachable for the
+	// page's lifetime. The chain maps are WeakMaps, so this list is the only handle on them.
+	//
+	// Clearing it also drops entries belonging to live renderers, which is safe: the
+	// singleton geometry is never disposed, so none of these listeners can ever fire.
+	const quadDisposeListeners = _sharedQuadGeometry._listeners?.dispose;
+	if ( quadDisposeListeners ) quadDisposeListeners.length = 0;
+
 }
 
 export function disposeObjectFromMemory( object, exeptions = [] ) {