rayzee 7.27.1 → 7.28.0

package/src/PathTracerApp.js

@@ -1,7 +1,7 @@
 import { WebGPURenderer, RectAreaLightNode, SRGBColorSpace } from 'three/webgpu';
 import { texture as _tslTexture, cubeTexture as _tslCubeTexture } from 'three/tsl';
 import {
-	ACESFilmicToneMapping, Scene, EventDispatcher, Box3
+	Scene, EventDispatcher, Box3
 } from 'three';
 import { RectAreaLightTexturesLib } from 'three/addons/lights/RectAreaLightTexturesLib.js';
 import { SceneHelpers } from './SceneHelpers.js';
@@ -16,12 +16,15 @@ import { AutoExposure } from './Stages/AutoExposure.js';
 import { Compositor } from './Stages/Compositor.js';
 import { RenderPipeline } from './Pipeline/RenderPipeline.js';
 import { CompletionTracker } from './Pipeline/CompletionTracker.js';
-import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize } from './EngineDefaults.js';
+import { ENGINE_DEFAULTS as DEFAULT_STATE, PRODUCTION_RENDER_CONFIG, INTERACTIVE_RENDER_CONFIG, MAX_STORAGE_TEXTURE_SIZE, MAX_RESERVABLE_RENDER_SIZE, setReservedRenderSize, getRenderProfile } from './EngineDefaults.js';
 import { updateStats, updateLoading, resetLoading, setStatusCallback, getDisplaySamples, disposeObjectFromMemory, disposeRenderer } from './Processor/utils.js';
 import { BuildTimer } from './Processor/BuildTimer.js';
 import { createLogger, fmt } from './utils/Logger.js';
 import { InteractionManager } from './managers/InteractionManager.js';
 import { EngineEvents } from './EngineEvents.js';
+import { IssueLog, ISSUE_CODES } from './EngineIssues.js';
+import { SETTING_SOURCE } from './RenderSettings.js';
+import { toneMapToRGBA8 } from './Processor/ToneMapCPU.js';
 import { AssetLoader } from './Processor/AssetLoader.js';
 import { SceneProcessor } from './Processor/SceneProcessor.js';
 
@@ -80,6 +83,32 @@ function attachDeviceLostHandler( device, holder ) {
 
 }
 
+const SOFTWARE_ADAPTER = /swiftshader|llvmpipe|lavapipe|basic render|microsoft basic|warp/i;
+
+/**
+ * Flags software rasterizers: correct output, ~100x slower, invisible in the image.
+ * `isFallbackAdapter` only covers adapters we asked to be fallbacks, so the strings matter.
+ *
+ * @param {GPUAdapter} adapter
+ * @returns {{vendor:string, architecture:string, device:string, description:string, isSoftware:boolean}}
+ */
+export function describeAdapter( adapter ) {
+
+	const info = adapter.info ?? {};
+	const identity = `${info.vendor ?? ''} ${info.architecture ?? ''} ${info.device ?? ''} ${info.description ?? ''}`;
+
+	return {
+		vendor: info.vendor ?? '',
+		architecture: info.architecture ?? '',
+		device: info.device ?? '',
+		description: info.description ?? '',
+		isSoftware: info.isFallbackAdapter === true
+			|| adapter.isFallbackAdapter === true
+			|| SOFTWARE_ADAPTER.test( identity ),
+	};
+
+}
+
 export class PathTracerApp extends EventDispatcher {
 
 	/**
@@ -88,6 +117,10 @@ export class PathTracerApp extends EventDispatcher {
 	 * @param {boolean} [options.autoResize=true] - Automatically listen for window resize events
 	 * @param {HTMLElement} [options.container] - Single DOM parent the engine mounts all auxiliary
 	 *   elements into (HUD overlay, denoiser canvas). Defaults to `canvas.parentNode`.
+	 * @param {boolean} [options.strict=false] - Throw at the point of degradation instead of
+	 *   rendering a plausible wrong image. See EngineIssues.js; read `app.issues` when off.
+	 * @param {string} [options.profile='viewer'] - Which tuning to apply where the viewer's
+	 *   product decisions differ from the physical answer. See RENDER_PROFILES.
 	 *
 	 * The engine dispatches `EngineEvents.FRAME` after each animate() iteration so hosts can
 	 * tick external instrumentation (e.g. a stats panel) without coupling the engine to it.
@@ -115,8 +148,24 @@ export class PathTracerApp extends EventDispatcher {
 		this._applySceneMetadataEnabled = options.applySceneMetadata !== false;
 		this._applyingSceneMetadata = false;
 
+		// Before the settings: the profile supplies some of their defaults.
+		this._profile = getRenderProfile( options.profile );
+
+		// First, so no subsystem can degrade unrecorded.
+		this._issues = new IssueLog( {
+			strict: options.strict === true,
+			onIssue: ( issue ) => this.dispatchEvent( { type: EngineEvents.ISSUE, issue } ),
+		} );
+
 		// ── Settings (single source of truth for all render parameters) ──
-		this.settings = new RenderSettings( DEFAULT_STATE );
+		this.settings = new RenderSettings(
+			{
+				...DEFAULT_STATE,
+				environmentRotation: this._profile.environmentRotation,
+				saturation: this._profile.saturation,
+			},
+			{ issues: this._issues }
+		);
 
 		// ── Core objects (populated in init) ──
 		this.renderer = null;
@@ -197,6 +246,9 @@ export class PathTracerApp extends EventDispatcher {
 		this._dispatchPinned = false;
 		this._deterministicRestore = null;
 
+		/** @type {?{vendor:string, architecture:string, device:string, description:string, isSoftware:boolean}} */
+		this.adapterInfo = null;
+
 	}
 
 	/**
@@ -501,6 +553,8 @@ export class PathTracerApp extends EventDispatcher {
 		this._removeTrackedListeners();
 		setStatusCallback( null );
 
+		this._issues.detach(); // onIssue captures `this`; see IssueLog.detach()
+
 		this.interactionManager?.deselect?.();
 		this.transformManager?.detach?.();
 
@@ -915,8 +969,9 @@ export class PathTracerApp extends EventDispatcher {
 	 * the 'load' event (_onAssetLoaded). Appending a model never applies it — an appended
 	 * model must not hijack the scene's environment.
 	 *
-	 * Resolves to null and never rejects: a failed fetch leaves the model on the current
-	 * environment. Returns null outright when there is nothing to apply.
+	 * Resolves to null rather than rejecting: a failed fetch leaves the model on the current
+	 * environment. Returns null outright when there is nothing to apply. Under `strict` the
+	 * recorded issue throws instead, and the rejection surfaces where loadSceneData awaits it.
 	 * Opt out per app with `new PathTracerApp( canvas, { applySceneMetadata: false } )`.
 	 *
 	 * @returns {Promise<import('three').Texture|null>|null}
@@ -935,7 +990,11 @@ export class PathTracerApp extends EventDispatcher {
 		return this.assetLoader.loadEnvironment( env.sourceFile )
 			.catch( error => {
 
-				log.warn( `scene metadata: environment "${env.sourceFile}" failed to load`, error );
+				this._issues.record(
+					ISSUE_CODES.ENVIRONMENT_LOAD_FAILED,
+					`authored environment "${env.sourceFile}" failed to load — lighting falls back to the previous environment`,
+					{ sourceFile: env.sourceFile, cause: String( error?.message ?? error ) }
+				);
 				return null;
 
 			} )
@@ -969,10 +1028,10 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( env.rotation !== undefined ) updates.environmentRotation = env.rotation;
 
-		this.settings.setMany( updates, { reset: false } );
+		this.settings.setMany( updates, { reset: false, source: SETTING_SOURCE.SCENE_METADATA } );
 		if ( this.scene ) this.scene.background = texture;
 
-		this.dispatchEvent( { type: 'SceneMetadataApplied', metadata, environment: { ...env } } );
+		this.dispatchEvent( { type: EngineEvents.SCENE_METADATA_APPLIED, metadata, environment: { ...env } } );
 
 	}
 
@@ -1016,7 +1075,11 @@ export class PathTracerApp extends EventDispatcher {
 					this._applySceneMetadataSettings( texture );
 
 				} )
-				.catch( error => log.warn( 'scene metadata: environment install failed', error ) )
+				.catch( error => this._issues.record(
+					ISSUE_CODES.ENVIRONMENT_LOAD_FAILED,
+					'authored environment failed to install — the scene is lit by whatever was already loaded',
+					{ cause: String( error?.message ?? error ) }
+				) )
 				.finally( () => timer.end( 'Environment fetch + CDF (concurrent)' ) );
 
 		} else if ( environmentTexture?.image?.data ) {
@@ -1571,7 +1634,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( applied < pending.requestedPx ) {
 
-			log.warn( `reserved render size ${fmt.n( pending.requestedPx )}px was capped to ${fmt.n( applied )}px by this device's limits — renders above ${fmt.n( applied )}px will be declined.` );
+			this._issues.warn(
+				ISSUE_CODES.RENDER_RESERVE_CAPPED,
+				`reserved render size ${fmt.n( pending.requestedPx )}px was capped to ${fmt.n( applied )}px by this device's limits — ` +
+				`renders above ${fmt.n( applied )}px will be declined`,
+				{ requested: pending.requestedPx, applied }
+			);
 
 		}
 
@@ -1599,7 +1667,12 @@ export class PathTracerApp extends EventDispatcher {
 
 		if ( width > MAX_STORAGE_TEXTURE_SIZE || height > MAX_STORAGE_TEXTURE_SIZE ) {
 
-			log.warn( `render resolution ${width}×${height} exceeds the ${MAX_STORAGE_TEXTURE_SIZE}px reserve (compute storage textures are pre-allocated at ${MAX_STORAGE_TEXTURE_SIZE}px). Ignoring resize — raise the reserve with setReservedRenderResolution( ${Math.max( width, height )} ) first, or use a resolution ≤ ${MAX_STORAGE_TEXTURE_SIZE}.` );
+			this._issues.record(
+				ISSUE_CODES.RENDER_SIZE_DECLINED,
+				`render resolution ${width}×${height} exceeds the ${MAX_STORAGE_TEXTURE_SIZE}px storage reserve — resize ignored, ` +
+				`so output stays at the previous size. Raise it with setReservedRenderResolution( ${Math.max( width, height )} ) before init().`,
+				{ width, height, reserve: MAX_STORAGE_TEXTURE_SIZE }
+			);
 			return false;
 
 		}
@@ -1704,7 +1777,7 @@ export class PathTracerApp extends EventDispatcher {
 			usePixelFreeze: config.usePixelFreeze ?? false,
 			pixelFreezeThreshold: config.pixelFreezeThreshold ?? DEFAULT_STATE.pixelFreezeThreshold,
 			pixelFreezeStability: config.pixelFreezeStability ?? DEFAULT_STATE.pixelFreezeStability,
-		}, { silent: true } );
+		}, { silent: true, source: SETTING_SOURCE.MODE_PRESET } );
 
 		// renderMode has no SETTING_ROUTES entry
 		this.stages.pathTracer?.setUniform( 'renderMode', parseInt( config.renderMode ) );
@@ -1923,6 +1996,27 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/** What the engine survived rather than failed on, oldest first. @returns {Object[]} copies */
+	get issues() {
+
+		return this._issues.list;
+
+	}
+
+	/** Non-empty means: do not publish this frame. */
+	get issueErrors() {
+
+		return this._issues.errors;
+
+	}
+
+	/** Scopes the log to one render on a reused app. */
+	clearIssues() {
+
+		this._issues.clear();
+
+	}
+
 	/**
 	 * Whether output is currently bit-reproducible. False when the dispatch heuristics
 	 * were left active via `pinDispatch: false`, since those consume async readbacks.
@@ -1939,14 +2033,18 @@ export class PathTracerApp extends EventDispatcher {
 	 * Awaits the STBN atlases first — until they land the sampler reads a constant-0.5
 	 * placeholder that gets baked permanently into the accumulation buffer.
 	 *
+	 * A frame retired by adaptive sampling stops advancing `frameCount`, so a fixed-count loop
+	 * can never reach `count`. `allowEarlyRetire` makes that an outcome instead of a throw.
+	 *
 	 * @param {number} count - samples to accumulate
 	 * @param {Object} [options]
 	 * @param {boolean} [options.reset=true] - restart accumulation from sample 0 first
 	 * @param {number} [options.yieldEvery=8] - yield to the event loop every N passes (0 disables)
 	 * @param {function(number): void} [options.onProgress] - called with the running sample count
-	 * @returns {Promise<number>} the final accumulated sample count
+	 * @param {boolean} [options.allowEarlyRetire=false]
+	 * @returns {Promise<number>} samples accumulated; below `count` only when retired early
 	 */
-	async renderFrames( count, { reset = true, yieldEvery = 8, onProgress } = {} ) {
+	async renderFrames( count, { reset = true, yieldEvery = 8, onProgress, allowEarlyRetire = false } = {} ) {
 
 		const stage = this.stages.pathTracer;
 		if ( ! stage ) throw new Error( 'renderFrames: app is not initialized' );
@@ -1970,6 +2068,8 @@ export class PathTracerApp extends EventDispatcher {
 		const maxPasses = count + 64;
 		let passes = 0;
 
+		let retiredEarly = false;
+
 		while ( stage.frameCount < target && passes < maxPasses ) {
 
 			if ( this._deviceLost ) throw new Error( 'renderFrames: WebGPU device lost' );
@@ -1978,6 +2078,14 @@ export class PathTracerApp extends EventDispatcher {
 			this.pipeline.render();
 			passes ++;
 
+			// render() no-ops once complete; spinning would burn the budget for nothing.
+			if ( stage.isComplete && stage.frameCount < target ) {
+
+				retiredEarly = true;
+				break;
+
+			}
+
 			onProgress?.( stage.frameCount );
 
 			if ( yieldEvery > 0 && passes % yieldEvery === 0 ) {
@@ -1988,11 +2096,15 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
-		if ( stage.frameCount < target ) {
+		if ( stage.frameCount < target && ! ( retiredEarly && allowEarlyRetire ) ) {
+
+			const cause = retiredEarly
+				? 'adaptive sampling retired the frame at the convergence threshold — pass ' +
+					'`allowEarlyRetire: true`, or disable it with setDeterministicMode()'
+				: 'something retired the render (maxSamples, a stray reset, or a canvas resize)';
 
 			throw new Error(
-				`renderFrames: stalled at ${stage.frameCount}/${target} samples after ${passes} passes — ` +
-				'something retired the render (maxSamples, a stray reset, or a canvas resize)'
+				`renderFrames: stopped at ${stage.frameCount}/${target} samples after ${passes} passes — ${cause}`
 			);
 
 		}
@@ -2001,6 +2113,53 @@ export class PathTracerApp extends EventDispatcher {
 
 	}
 
+	/**
+	 * The path tracer's accumulation as pixels, read from its storage target rather than the
+	 * canvas — so it works headless, works while the page is hidden, and cannot pick up a
+	 * helper overlay.
+	 *
+	 * This is `pathtracer:color`, NOT the Compositor's resolved output: denoising, bloom and
+	 * edge filtering are downstream and are absent here. Use getCanvas() when you want what
+	 * the viewport shows.
+	 *
+	 * @param {Object} [options]
+	 * @param {'linear'|'srgb'} [options.colorSpace='srgb']
+	 * @param {boolean} [options.preserveAlpha=false] - srgb only
+	 * @returns {Promise<{data: Float32Array|Uint8ClampedArray, width: number, height: number, colorSpace: string}>}
+	 */
+	async renderToBuffer( { colorSpace = 'srgb', preserveAlpha = false } = {} ) {
+
+		if ( colorSpace !== 'linear' && colorSpace !== 'srgb' ) {
+
+			throw new Error( `renderToBuffer: colorSpace must be 'linear' or 'srgb', got "${colorSpace}"` );
+
+		}
+
+		const stage = this.stages?.pathTracer;
+		const target = stage?.storageTextures?.readTarget;
+		if ( ! target ) throw new Error( 'renderToBuffer: no render target — call init() and render at least one sample' );
+
+		// The pool over-allocates to the reserve, so the texture is larger than the frame.
+		const { width, height } = stage;
+
+		const linear = await this.renderer.readRenderTargetPixelsAsync( target, 0, 0, width, height, 0 );
+
+		if ( colorSpace === 'linear' ) return { data: linear, width, height, colorSpace };
+
+		return {
+			data: toneMapToRGBA8( linear, {
+				exposure: this.renderer.toneMappingExposure,
+				toneMapping: this.renderer.toneMapping,
+				saturation: this.settings.get( 'saturation' ) ?? 1,
+				preserveAlpha,
+			} ),
+			width,
+			height,
+			colorSpace,
+		};
+
+	}
+
 	/**
 	 * Enables WebGPU timestamp queries so {@link PathTracerApp#getGPUTimings} reports real
 	 * GPU time. Off by default because the queries themselves cost time. No-ops when the
@@ -2580,6 +2739,20 @@ export class PathTracerApp extends EventDispatcher {
 
 		}
 
+		this.adapterInfo = describeAdapter( adapter );
+		if ( this.adapterInfo.isSoftware ) {
+
+			// Warning: the image is correct, only the cost is wrong.
+			this._issues.warn(
+				ISSUE_CODES.ADAPTER_SOFTWARE,
+				`software GPU adapter "${this.adapterInfo.description || this.adapterInfo.vendor}" — ` +
+				'renders are correct but orders of magnitude slower than hardware',
+				{ ...this.adapterInfo }
+			);
+			log.warn( `software GPU adapter — check app.adapterInfo.isSoftware. ${this.adapterInfo.description}` );
+
+		}
+
 		const adapterLimits = adapter.limits;
 
 		this.renderer = new WebGPURenderer( {
@@ -2596,6 +2769,17 @@ export class PathTracerApp extends EventDispatcher {
 
 		await this.renderer.init();
 
+		// WebGPURenderer swaps in WebGL2 on failure with only a warn(). The wavefront path is
+		// compute-only, so every frame would fail against an empty canvas.
+		if ( ! this.renderer.backend?.isWebGPUBackend ) {
+
+			throw new Error(
+				'WebGPU backend unavailable — three.js fell back to WebGL2, which cannot run the ' +
+				'path tracer\'s compute kernels. Check GPU process flags and driver support.'
+			);
+
+		}
+
 		// 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.
@@ -2621,7 +2805,7 @@ export class PathTracerApp extends EventDispatcher {
 		RectAreaLightNode.setLTC( RectAreaLightTexturesLib.init() );
 
 		this.renderer.outputColorSpace = SRGBColorSpace;
-		this.renderer.toneMapping = ACESFilmicToneMapping;
+		this.renderer.toneMapping = this._profile.toneMapping;
 		this.renderer.toneMappingExposure = 1.0;
 		this.renderer.setPixelRatio( 1.0 );
 
@@ -2643,8 +2827,11 @@ export class PathTracerApp extends EventDispatcher {
 
 	_initAssetPipeline() {
 
-		this._sdf = new SceneProcessor();
-		this.assetLoader = new AssetLoader( this.meshScene, this.cameraManager.camera, this.cameraManager.controls );
+		this._sdf = new SceneProcessor( { issues: this._issues } );
+		this.assetLoader = new AssetLoader(
+			this.meshScene, this.cameraManager.camera, this.cameraManager.controls,
+			{ issues: this._issues, profile: this._profile }
+		);
 		this.assetLoader.setRenderer( this.renderer );
 		this.assetLoader.createFloorPlane();
 
@@ -2662,7 +2849,7 @@ export class PathTracerApp extends EventDispatcher {
 		this._createStages();
 
 		const { clientWidth: w, clientHeight: h } = this.canvas;
-		this.pipeline = new RenderPipeline( this.renderer, w || 1, h || 1 );
+		this.pipeline = new RenderPipeline( this.renderer, w || 1, h || 1, { issues: this._issues } );
 
 		this.pipeline.addStage( this.stages.pathTracer );
 		this.pipeline.addStage( this.stages.normalDepth );

package/src/Pipeline/RenderPipeline.js

@@ -1,6 +1,7 @@
 import { PipelineContext } from './PipelineContext.js';
 import { EventDispatcher } from './EventDispatcher.js';
 import { auditStageRender } from './BindingAudit.js';
+import { ISSUE_CODES } from '../EngineIssues.js';
 
 /**
  * RenderPipeline - Orchestrates execution of pipeline stages
@@ -36,15 +37,42 @@ import { auditStageRender } from './BindingAudit.js';
  */
 export class RenderPipeline {
 
+	/**
+	 * A failed stage leaves a half-composited frame that still reaches the canvas — the exact
+	 * plausible-wrong-image case a batch host must not publish.
+	 * @private
+	 */
+	_reportStageFailure( name, phase, error ) {
+
+		console.error( `[Pipeline] Error in stage '${name}' (${phase}):`, error );
+
+		const key = `${name}:${phase}`;
+		if ( this._reportedStageFailures.has( key ) ) return;
+		this._reportedStageFailures.add( key );
+
+		this._issues?.record(
+			ISSUE_CODES.STAGE_RENDER_FAILED,
+			`stage "${name}" threw during ${phase} — the frame is incomplete`,
+			{ stage: name, phase, cause: String( error?.message ?? error ) }
+		);
+
+	}
+
 	/**
 	 * Create a new pipeline
 	 * @param {THREE.WebGLRenderer} renderer - Three.js renderer
 	 * @param {number} width - Viewport width
 	 * @param {number} height - Viewport height
+	 * @param {Object} [options]
+	 * @param {import('../EngineIssues.js').IssueLog} [options.issues] - records stage failures
 	 */
-	constructor( renderer, width, height ) {
+	constructor( renderer, width, height, { issues = null } = {} ) {
 
 		this.renderer = renderer;
+		this._issues = issues;
+
+		// A stage that throws does so every frame; record the first per stage, not 60/second.
+		this._reportedStageFailures = new Set();
 		this.width = width;
 		this.height = height;
 
@@ -215,8 +243,7 @@ export class RenderPipeline {
 
 			} catch ( error ) {
 
-				console.error( `[Pipeline] Error in stage '${stage.name}':`, error );
-				// Continue pipeline execution despite error
+				this._reportStageFailure( stage.name, 'render', error );
 
 			}
 
@@ -278,7 +305,7 @@ export class RenderPipeline {
 
 				} catch ( error ) {
 
-					console.error( `[Pipeline] Error resetting stage '${stage.name}':`, error );
+					this._reportStageFailure( stage.name, 'reset', error );
 
 				}
 

package/src/Processor/AssetLoader.js

@@ -16,6 +16,8 @@ import { BuildTimer } from './BuildTimer.js';
 import { getAssetConfig } from '../AssetConfig.js';
 import { loadPBRTScene, pickEntryPath } from './PBRT/index.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
+import { ISSUE_CODES } from '../EngineIssues.js';
+import { getRenderProfile } from '../EngineDefaults.js';
 
 // Define supported file formats
 const SUPPORTED_FORMATS = {
@@ -54,7 +56,7 @@ function standInForSplit( source ) {
  */
 export class AssetLoader extends EventDispatcher {
 
-	constructor( scene, camera, controls ) {
+	constructor( scene, camera, controls, { issues = null, profile = null } = {} ) {
 
 		super();
 		this.scene = scene;
@@ -78,6 +80,22 @@ export class AssetLoader extends EventDispatcher {
 		this._loadingManager = new LoadingManager();
 		this._loadCancelled = false;
 
+		this._issues = issues;
+		this._profile = profile ?? getRenderProfile();
+
+		// A glTF whose external texture 404s still loads. Only place the engine sees the URL.
+		// ZIP paths build their own managers and are not covered.
+		this._loadingManager.onError = ( url ) => {
+
+			if ( this._loadCancelled ) return;
+			this._issues?.record(
+				ISSUE_CODES.ASSET_UNREACHABLE,
+				`asset "${url}" could not be fetched — anything depending on it renders without it`,
+				{ url }
+			);
+
+		};
+
 	}
 
 	/**
@@ -1744,9 +1762,10 @@ export class AssetLoader extends EventDispatcher {
 					// Intensity is authored in Watts (Blender-style); emitted radiance
 					// is computed at render time as power/(π·area). Blender emission
 					// defaults: power-normalized, full Lambertian spread (π), rectangle.
+					// Viewer tuning, not physics — see RENDER_PROFILES.
 					const light = new RectAreaLight(
 						new Color( ...userData.color ),
-						userData.intensity * 0.1,
+						userData.intensity * this._profile.areaLightIntensityScale,
 						userData.width,
 						userData.height
 					);
@@ -1879,6 +1898,10 @@ export class AssetLoader extends EventDispatcher {
 		// Clear the internal listener map directly so handlers don't retain references.
 		this._listeners = undefined;
 
+		// onError captures `this`, and a manager outlives the loader via an in-flight fetch.
+		this._loadingManager.onError = undefined;
+		this._issues = null;
+
 		this.releaseTargetModel();
 
 	}

package/src/Processor/SceneProcessor.js

@@ -33,6 +33,7 @@ export class SceneProcessor {
      * @param {boolean} [options.useFloat32Array=true] - Use Float32Array for triangle data
      * @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
      */
 	constructor( options = {} ) {
 
@@ -160,7 +161,7 @@ export class SceneProcessor {
 		} );
 
 		// Create and configure texture creator
-		this.textureCreator = new TextureCreator( { maxTextureSize: this.config.maxTextureSize } );
+		this.textureCreator = new TextureCreator( { maxTextureSize: this.config.maxTextureSize, issues: this.config.issues } );
 		// The optimized TextureCreator will auto-detect capabilities and select optimal methods
 
 		// Create emissive triangle builder for direct lighting