From 6b4d65d2ff799610a320960ee7ea11490e58c1f0 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Thu, 2 Apr 2026 10:46:30 +0900
Subject: [PATCH 01/19] Add node material rebuild debug reporting

---
 examples/files.json                           |   1 +
 .../webgpu_materials_debug_rebuild.jpg        | Bin 0 -> 20834 bytes
 examples/webgpu_materials_debug_rebuild.html  | 502 +++++++++++++++++
 src/renderers/common/NodeMaterialDebug.js     | 523 ++++++++++++++++++
 src/renderers/common/RenderObjects.js         |   5 +
 src/renderers/common/Renderer.js              |  38 ++
 test/e2e/image.js                             |  14 +-
 .../unit/src/renderers/RenderObjects.tests.js | 190 +++++++
 test/unit/three.source.unit.js                |   1 +
 9 files changed, 1273 insertions(+), 1 deletion(-)
 create mode 100644 examples/screenshots/webgpu_materials_debug_rebuild.jpg
 create mode 100644 examples/webgpu_materials_debug_rebuild.html
 create mode 100644 src/renderers/common/NodeMaterialDebug.js
 create mode 100644 test/unit/src/renderers/RenderObjects.tests.js

diff --git a/examples/files.json b/examples/files.json
index 85dc5dc3d49bd8..f4df96e26796fe 100644
--- a/examples/files.json
+++ b/examples/files.json
@@ -382,6 +382,7 @@
 		"webgpu_materials_displacementmap",
 		"webgpu_materials_envmaps_bpcem",
 		"webgpu_materials_envmaps",
+		"webgpu_materials_debug_rebuild",
 		"webgpu_materials_lightmap",
 		"webgpu_materials_matcap",
 		"webgpu_materials_sss",
diff --git a/examples/screenshots/webgpu_materials_debug_rebuild.jpg b/examples/screenshots/webgpu_materials_debug_rebuild.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8c529c6a76d27d1772e7acd389fc48bc14b8d701
GIT binary patch
literal 20834
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
UAlU1Grw?gIa*=qLo&Eot0F@@YT>t<8

literal 0
HcmV?d00001

diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
new file mode 100644
index 00000000000000..027f52df5d71d7
--- /dev/null
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -0,0 +1,502 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<title>three.js webgpu - node material rebuild debug</title>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+		<link type="text/css" rel="stylesheet" href="example.css">
+		<style>
+			#container {
+				width: 100%;
+				height: 100%;
+			}
+
+			#panel {
+				position: absolute;
+				left: 12px;
+				bottom: 12px;
+				width: min( 720px, calc( 100% - 24px ) );
+				padding: 12px;
+				box-sizing: border-box;
+				border: 1px solid rgba( 255, 255, 255, 0.12 );
+				border-radius: 6px;
+				background: rgba( 0, 0, 0, 0.55 );
+				color: #e8e8e8;
+				font: 400 12px 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+				pointer-events: auto;
+			}
+
+			#actions {
+				display: grid;
+				grid-template-columns: repeat( 5, minmax( 0, 1fr ) );
+				gap: 8px;
+				margin-bottom: 10px;
+			}
+
+			#actions button {
+				padding: 7px 8px;
+				border: 1px solid rgba( 255, 255, 255, 0.18 );
+				border-radius: 4px;
+				background: rgba( 255, 255, 255, 0.08 );
+				color: inherit;
+				font: 600 11px/1.2 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+				cursor: pointer;
+				white-space: nowrap;
+			}
+
+			#actions button.active {
+				background: rgba( 255, 255, 255, 0.2 );
+			}
+
+			#stateBar,
+			#status,
+			#log {
+				font-family: monospace;
+				font-size: 11px;
+				line-height: 1.5;
+			}
+
+			#stateBar {
+				display: flex;
+				flex-wrap: wrap;
+				gap: 6px;
+				margin-bottom: 8px;
+			}
+
+			.badge {
+				padding: 4px 8px;
+				border: 1px solid rgba( 255, 255, 255, 0.14 );
+				border-radius: 999px;
+				background: rgba( 255, 255, 255, 0.06 );
+				color: #dddddd;
+			}
+
+			.badge.on {
+				background: rgba( 140, 220, 255, 0.18 );
+				color: #ffffff;
+			}
+
+			#recentEvent {
+				margin-bottom: 10px;
+				padding: 8px 10px;
+				border-left: 4px solid var( --recent-color, #8ce0ff );
+				border-radius: 4px;
+				background: rgba( 255, 255, 255, 0.04 );
+				font: 700 12px/1.4 monospace;
+				color: #eef4fb;
+			}
+
+			#status {
+				margin-bottom: 10px;
+				color: #c7c7c7;
+			}
+
+			#log {
+				max-height: 170px;
+				overflow-y: auto;
+				color: #ffffff;
+			}
+
+			.log-entry {
+				padding: 6px 8px;
+				border-left: 4px solid var( --entry-color, #8ce0ff );
+				border-radius: 4px;
+				background: rgba( 255, 255, 255, 0.04 );
+			}
+
+			.log-entry + .log-entry {
+				margin-top: 6px;
+			}
+
+			.log-entry .time {
+				color: #95a3b8;
+			}
+
+			.log-entry .reason {
+				color: var( --entry-color, #8ce0ff );
+			}
+
+			.log-entry .values {
+				color: #d5deea;
+			}
+
+			#eventBanner {
+				position: absolute;
+				top: 104px;
+				right: 12px;
+				width: min( 620px, calc( 100% - 24px ) );
+				padding: 14px 16px;
+				box-sizing: border-box;
+				border: 1px solid rgba( 255, 255, 255, 0.14 );
+				border-radius: 10px;
+				background: rgba( 10, 12, 16, 0.78 );
+				backdrop-filter: blur( 10px );
+				color: #f1f5f9;
+				opacity: 0;
+				transform: translateY( - 12px ) scale( 0.98 );
+				pointer-events: none;
+			}
+
+			#eventBannerTitle {
+				font: 700 18px/1.15 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+				letter-spacing: 0.02em;
+				text-transform: uppercase;
+			}
+
+			#eventBannerReason {
+				margin-top: 8px;
+				font: 700 14px/1.3 monospace;
+				color: var( --event-color, #8ce0ff );
+			}
+
+			#eventBannerValues {
+				margin-top: 6px;
+				font: 400 12px/1.45 monospace;
+				color: #d4dbe3;
+				word-break: break-word;
+			}
+
+			#hint {
+				margin-top: 8px;
+				font: 400 11px/1.5 monospace;
+				color: #96a3b3;
+			}
+
+			@media ( max-width: 900px ) {
+
+				#eventBanner {
+					top: auto;
+					right: 12px;
+					bottom: 226px;
+				}
+
+				#actions {
+					grid-template-columns: repeat( 2, minmax( 0, 1fr ) );
+				}
+
+			}
+		</style>
+	</head>
+	<body>
+
+		<div id="container"></div>
+
+		<div id="info">
+			<a href="https://threejs.org/" target="_blank" rel="noopener" class="logo-link"></a>
+
+			<div class="title-wrapper">
+				<a href="https://threejs.org/" target="_blank" rel="noopener">three.js</a><span>Node Material Rebuild Debug</span>
+			</div>
+
+			<small>
+				Uses <code>renderer.debug.onNodeMaterialInvalidation</code> to report why a material makes the node material rebuild.<br />
+				Toggle clearcoat/transmission, or add/remove the accent light to trigger rebuilds from material or scene changes.
+			</small>
+		</div>
+
+		<div id="panel">
+			<div id="actions">
+				<button id="clearcoatButton">Clearcoat</button>
+				<button id="transmissionButton">Transmission</button>
+				<button id="lightButton">Point Light</button>
+				<button id="autoDemoButton">Auto Demo</button>
+				<button id="clearLogButton">Clear</button>
+			</div>
+			<div id="stateBar"></div>
+			<div id="recentEvent">Waiting for the next rebuild event.</div>
+			<div id="status"></div>
+			<div id="log"></div>
+		</div>
+
+		<div id="eventBanner">
+			<div id="eventBannerTitle">NodeMaterial needs rebuild</div>
+			<div id="eventBannerReason">Waiting for a rebuild event</div>
+			<div id="eventBannerValues">Use the buttons or start the auto demo.</div>
+			<div id="hint">This banner is driven directly by the debug callback.</div>
+		</div>
+
+		<script type="importmap">
+			{
+				"imports": {
+					"three": "../build/three.webgpu.js",
+					"three/webgpu": "../build/three.webgpu.js",
+					"three/tsl": "../build/three.tsl.js",
+					"three/addons/": "./jsm/"
+				}
+			}
+		</script>
+
+		<script type="module">
+
+			import * as THREE from 'three/webgpu';
+
+			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+
+			let camera, scene, renderer, controls;
+			let material, accentLight, sphere;
+			let autoDemoInterval = null;
+			let autoDemoStep = 0;
+			let feedbackTime = - Infinity;
+
+			const container = document.getElementById( 'container' );
+			const stateBarElement = document.getElementById( 'stateBar' );
+			const recentEventElement = document.getElementById( 'recentEvent' );
+			const statusElement = document.getElementById( 'status' );
+			const logElement = document.getElementById( 'log' );
+			const eventBannerElement = document.getElementById( 'eventBanner' );
+			const eventBannerReasonElement = document.getElementById( 'eventBannerReason' );
+			const eventBannerValuesElement = document.getElementById( 'eventBannerValues' );
+			const autoDemoButton = document.getElementById( 'autoDemoButton' );
+
+			init();
+
+			function init() {
+
+				camera = new THREE.PerspectiveCamera( 45, window.innerWidth / window.innerHeight, 0.1, 100 );
+				camera.position.set( 3, 2.2, 5.5 );
+
+				scene = new THREE.Scene();
+				scene.background = new THREE.Color( 0x111114 );
+
+				renderer = new THREE.WebGPURenderer( { antialias: true } );
+				renderer.setPixelRatio( window.devicePixelRatio );
+				renderer.setSize( window.innerWidth, window.innerHeight );
+				renderer.setAnimationLoop( animate );
+				container.appendChild( renderer.domElement );
+
+				renderer.debug.onNodeMaterialInvalidation = function ( event ) {
+
+					addLog( event );
+					console.log( 'NodeMaterial needs rebuild', event );
+					showEvent( event );
+
+				};
+
+				controls = new OrbitControls( camera, renderer.domElement );
+				controls.enableDamping = true;
+				controls.target.set( 0, 1, 0 );
+
+				scene.add( new THREE.HemisphereLight( 0x99aaff, 0x101010, 0.9 ) );
+
+				const mainLight = new THREE.DirectionalLight( 0xffffff, 2.5 );
+				mainLight.position.set( 4, 7, 3 );
+				scene.add( mainLight );
+
+				accentLight = new THREE.PointLight( 0x66aaff, 20, 12, 2 );
+				accentLight.position.set( - 2.5, 1.8, 2.2 );
+
+				const floor = new THREE.Mesh(
+					new THREE.CylinderGeometry( 2.2, 2.4, 0.25, 64 ),
+					new THREE.MeshStandardMaterial( { color: 0x1a1c20, roughness: 0.85, metalness: 0.1 } )
+				);
+				floor.position.y = - 0.15;
+				scene.add( floor );
+
+				material = new THREE.MeshPhysicalMaterial( {
+					color: 0x8aa4ff,
+					roughness: 0.12,
+					metalness: 0.05,
+					clearcoat: 0,
+					clearcoatRoughness: 0.05,
+					transmission: 0,
+					thickness: 0.9,
+					ior: 1.5
+				} );
+				material.name = 'DebugPhysicalMaterial';
+
+				sphere = new THREE.Mesh( new THREE.SphereGeometry( 1, 64, 32 ), material );
+				sphere.position.y = 1;
+				scene.add( sphere );
+
+				document.getElementById( 'clearcoatButton' ).addEventListener( 'click', toggleClearcoat );
+				document.getElementById( 'transmissionButton' ).addEventListener( 'click', toggleTransmission );
+				document.getElementById( 'lightButton' ).addEventListener( 'click', toggleAccentLight );
+				autoDemoButton.addEventListener( 'click', toggleAutoDemo );
+				document.getElementById( 'clearLogButton' ).addEventListener( 'click', clearLog );
+
+				window.addEventListener( 'resize', onWindowResize );
+
+				addLog( 'Press a button or start the auto demo to trigger a node material rebuild.' );
+				addLog( 'Expected rebuild reasons include material.clearcoat, material.transmission or scene.lights.' );
+
+				updateStatus();
+
+			}
+
+			function toggleClearcoat() {
+
+				material.clearcoat = material.clearcoat === 0 ? 1 : 0;
+				material.needsUpdate = true;
+
+				updateStatus();
+
+			}
+
+			function toggleTransmission() {
+
+				material.transmission = material.transmission === 0 ? 0.95 : 0;
+				material.needsUpdate = true;
+
+				updateStatus();
+
+			}
+
+			function toggleAccentLight() {
+
+				if ( accentLight.parent === null ) {
+
+					scene.add( accentLight );
+
+				} else {
+
+					scene.remove( accentLight );
+
+				}
+
+				updateStatus();
+
+			}
+
+			function updateStatus() {
+
+				stateBarElement.innerHTML =
+					getBadgeHTML( 'clearcoat', material.clearcoat > 0 ) +
+					getBadgeHTML( 'transmission', material.transmission > 0 ) +
+					getBadgeHTML( 'point light', accentLight.parent !== null ) +
+					getBadgeHTML( 'auto demo', autoDemoInterval !== null );
+
+				statusElement.textContent = 'The banner and log update every time the debug callback reports a rebuild.';
+				autoDemoButton.classList.toggle( 'active', autoDemoInterval !== null );
+
+			}
+
+			function getBadgeHTML( label, active ) {
+
+				return `<span class="badge ${ active ? 'on' : '' }">${ label }: ${ active ? 'on' : 'off' }</span>`;
+
+			}
+
+			function getFeedbackMeta( property ) {
+
+				if ( property.startsWith( 'material.' ) ) return { color: 0x8ce0ff, cssColor: '#8ce0ff', label: 'Material rebuild' };
+				if ( property.startsWith( 'scene.' ) ) return { color: 0xffbe78, cssColor: '#ffbe78', label: 'Scene rebuild' };
+				if ( property.startsWith( 'renderer.' ) ) return { color: 0xff8fb1, cssColor: '#ff8fb1', label: 'Renderer rebuild' };
+
+				return { color: 0xffffff, cssColor: '#ffffff', label: 'Rebuild' };
+
+			}
+
+			function showEvent( event ) {
+
+				const feedback = getFeedbackMeta( event.property );
+
+				feedbackTime = performance.now();
+
+				eventBannerElement.style.setProperty( '--event-color', feedback.cssColor );
+				eventBannerReasonElement.textContent = event.property;
+				eventBannerValuesElement.textContent = `${ event.previousValue } -> ${ event.value }`;
+
+				recentEventElement.style.setProperty( '--recent-color', feedback.cssColor );
+				recentEventElement.innerHTML = `${ feedback.label }<br><span style="color:${ feedback.cssColor }">${ event.property }</span><br><span style="color:#d5deea">${ event.previousValue } -> ${ event.value }</span>`;
+
+			}
+
+			function toggleAutoDemo() {
+
+				if ( autoDemoInterval !== null ) {
+
+					clearInterval( autoDemoInterval );
+					autoDemoInterval = null;
+
+				} else {
+
+					const actions = [ toggleClearcoat, toggleTransmission, toggleAccentLight ];
+
+					actions[ autoDemoStep % actions.length ]();
+					autoDemoStep ++;
+
+					autoDemoInterval = setInterval( function () {
+
+						actions[ autoDemoStep % actions.length ]();
+						autoDemoStep ++;
+
+					}, 1800 );
+
+				}
+
+				updateStatus();
+
+			}
+
+			function addLog( event ) {
+
+				const entry = document.createElement( 'div' );
+				entry.className = 'log-entry';
+
+				if ( typeof event === 'string' ) {
+
+					entry.style.setProperty( '--entry-color', '#8ce0ff' );
+					entry.innerHTML = `<span class="time">[${ new Date().toLocaleTimeString() }]</span> <span class="values">${ event }</span>`;
+
+				} else {
+
+					const feedback = getFeedbackMeta( event.property );
+					entry.style.setProperty( '--entry-color', feedback.cssColor );
+					entry.innerHTML = `<span class="time">[${ new Date().toLocaleTimeString() }]</span> <span class="reason">${ event.property }</span><br><span class="values">${ event.previousValue } -> ${ event.value }</span>`;
+
+				}
+
+				logElement.prepend( entry );
+
+				while ( logElement.childElementCount > 8 ) {
+
+					logElement.lastElementChild.remove();
+
+				}
+
+			}
+
+			function clearLog() {
+
+				logElement.innerHTML = '';
+				recentEventElement.style.setProperty( '--recent-color', '#8ce0ff' );
+				recentEventElement.textContent = 'Waiting for the next rebuild event.';
+
+			}
+
+			function onWindowResize() {
+
+				camera.aspect = window.innerWidth / window.innerHeight;
+				camera.updateProjectionMatrix();
+
+				renderer.setSize( window.innerWidth, window.innerHeight );
+
+			}
+
+			function animate() {
+
+				const pulse = Math.max( 0, 1 - ( performance.now() - feedbackTime ) / 1400 );
+
+				sphere.rotation.y += 0.0035;
+
+				if ( pulse > 0 ) {
+
+					eventBannerElement.style.opacity = String( Math.min( 1, pulse * 2.1 ) );
+					eventBannerElement.style.transform = `translateY( ${ - 12 * ( 1 - pulse ) }px ) scale( ${ 1 - pulse * 0.02 } )`;
+
+				} else {
+
+					eventBannerElement.style.opacity = '0';
+					eventBannerElement.style.transform = 'translateY( -12px ) scale( 0.98 )';
+
+				}
+
+				controls.update();
+				renderer.render( scene, camera );
+
+			}
+
+		</script>
+
+	</body>
+</html>
diff --git a/src/renderers/common/NodeMaterialDebug.js b/src/renderers/common/NodeMaterialDebug.js
new file mode 100644
index 00000000000000..6ca3224269b015
--- /dev/null
+++ b/src/renderers/common/NodeMaterialDebug.js
@@ -0,0 +1,523 @@
+import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap } from '../../constants.js';
+import { warn } from '../../utils.js';
+
+function getKeys( obj ) {
+
+	const keys = Object.keys( obj );
+
+	let proto = Object.getPrototypeOf( obj );
+
+	while ( proto ) {
+
+		const descriptors = Object.getOwnPropertyDescriptors( proto );
+
+		for ( const key in descriptors ) {
+
+			if ( descriptors[ key ] !== undefined ) {
+
+				const descriptor = descriptors[ key ];
+
+				if ( descriptor && typeof descriptor.get === 'function' ) {
+
+					keys.push( key );
+
+				}
+
+			}
+
+		}
+
+		proto = Object.getPrototypeOf( proto );
+
+	}
+
+	return keys;
+
+}
+
+function getDebugValue( value ) {
+
+	if ( value === undefined ) return 'undefined';
+	if ( value === null ) return 'null';
+
+	const type = typeof value;
+
+	if ( type === 'string' ) return `"${ value }"`;
+	if ( type === 'number' || type === 'boolean' || type === 'bigint' ) return String( value );
+
+	if ( Array.isArray( value ) ) {
+
+		const values = value.slice( 0, 4 ).map( getDebugValue ).join( ', ' );
+		return `[${ values }${ value.length > 4 ? ', ...' : '' }]`;
+
+	}
+
+	if ( value.isTexture === true ) return `${ value.type }#${ value.id } v${ value.version }`;
+	if ( value.isColor === true ) return `Color(${ value.r }, ${ value.g }, ${ value.b })`;
+	if ( value.isVector2 === true || value.isVector3 === true || value.isVector4 === true ) return `${ value.constructor.name }(${ value.toArray().join( ', ' ) })`;
+	if ( value.isMatrix3 === true || value.isMatrix4 === true ) return `${ value.constructor.name }(...)`;
+	if ( value.uuid !== undefined ) return `${ value.type || 'Object' }(${ value.uuid })`;
+
+	return String( value );
+
+}
+
+function getShadowMapTypeName( type ) {
+
+	if ( type === BasicShadowMap ) return 'BasicShadowMap';
+	if ( type === PCFShadowMap ) return 'PCFShadowMap';
+	if ( type === PCFSoftShadowMap ) return 'PCFSoftShadowMap';
+	if ( type === VSMShadowMap ) return 'VSMShadowMap';
+
+	return String( type );
+
+}
+
+function getNodeValue( node ) {
+
+	if ( node === null ) return 'none';
+
+	const name = node.name !== undefined && node.name !== '' ? ` "${ node.name }"` : '';
+	return `${ node.type || node.constructor.name }#${ node.id }${ name }`;
+
+}
+
+function getLightValueKey( light ) {
+
+	let valueKey = `${ light.type }:${ light.id }:${ light.castShadow === true ? 1 : 0 }`;
+
+	if ( light.isSpotLight === true ) {
+
+		valueKey += `:${ light.map !== null ? light.map.id : - 1 }`;
+		valueKey += `:${ light.colorNode ? light.colorNode.getCacheKey() : - 1 }`;
+
+	}
+
+	return valueKey;
+
+}
+
+function getLightValue( light ) {
+
+	let value = `${ light.type }#${ light.id }`;
+
+	if ( light.castShadow === true ) value += ' shadow';
+
+	if ( light.isSpotLight === true ) {
+
+		if ( light.map !== null ) value += ` map:${ light.map.id }`;
+		if ( light.colorNode ) value += ' colorNode';
+
+	}
+
+	return value;
+
+}
+
+function getLightsValue( lightsNode ) {
+
+	if ( lightsNode === null ) return '0 lights';
+
+	const lights = lightsNode.getLights().slice().sort( ( a, b ) => a.id - b.id );
+	const values = lights.map( getLightValue );
+	const label = `${ lights.length } light${ lights.length === 1 ? '' : 's' }`;
+
+	return values.length > 0 ? `${ label } [${ values.join( ', ' ) }]` : label;
+
+}
+
+function getLightsValueKey( lightsNode ) {
+
+	if ( lightsNode === null ) return '';
+
+	return lightsNode.getLights().slice().sort( ( a, b ) => a.id - b.id ).map( getLightValueKey ).join( ',' );
+
+}
+
+function getCacheKeyDifference( previousComponents, currentComponents ) {
+
+	const currentMap = new Map();
+
+	for ( const component of currentComponents ) {
+
+		currentMap.set( component.property, component );
+
+	}
+
+	for ( const component of previousComponents ) {
+
+		const current = currentMap.get( component.property );
+
+		if ( current === undefined ) {
+
+			return { property: component.property, previousValue: component.value, value: 'undefined' };
+
+		}
+
+		if ( component.valueKey !== current.valueKey ) {
+
+			return { property: component.property, previousValue: component.value, value: current.value };
+
+		}
+
+	}
+
+	const previousMap = new Map();
+
+	for ( const component of previousComponents ) {
+
+		previousMap.set( component.property, component );
+
+	}
+
+	for ( const component of currentComponents ) {
+
+		if ( previousMap.has( component.property ) === false ) {
+
+			return { property: component.property, previousValue: 'undefined', value: component.value };
+
+		}
+
+	}
+
+	return null;
+
+}
+
+function getMaterialCacheKeyComponents( renderObject ) {
+
+	const { object, material, renderer } = renderObject;
+	const cacheKeyComponents = [];
+	const customProgramCacheKey = material.customProgramCacheKey();
+
+	cacheKeyComponents.push( {
+		property: 'material.customProgramCacheKey',
+		valueKey: customProgramCacheKey,
+		value: getDebugValue( customProgramCacheKey )
+	} );
+
+	for ( const property of getKeys( material ) ) {
+
+		if ( /^(is[A-Z]|_)|^(visible|version|uuid|name|opacity|userData)$/.test( property ) ) continue;
+
+		const value = material[ property ];
+		let valueKey;
+
+		if ( value !== null ) {
+
+			const type = typeof value;
+
+			if ( type === 'number' ) {
+
+				valueKey = value !== 0 ? '1' : '0';
+
+			} else if ( type === 'object' ) {
+
+				valueKey = '{';
+
+				if ( value.isTexture ) {
+
+					valueKey += value.mapping;
+
+					if ( renderer.backend.isWebGPUBackend === true ) {
+
+						valueKey += value.magFilter;
+						valueKey += value.minFilter;
+						valueKey += value.wrapS;
+						valueKey += value.wrapT;
+						valueKey += value.wrapR;
+
+					}
+
+				}
+
+				valueKey += '}';
+
+			} else {
+
+				valueKey = String( value );
+
+			}
+
+		} else {
+
+			valueKey = String( value );
+
+		}
+
+		cacheKeyComponents.push( {
+			property: `material.${ property }`,
+			valueKey,
+			value: getDebugValue( value )
+		} );
+
+	}
+
+	cacheKeyComponents.push( {
+		property: 'clippingContext.cacheKey',
+		valueKey: renderObject.clippingContextCacheKey,
+		value: getDebugValue( renderObject.clippingContextCacheKey )
+	} );
+
+	if ( object.geometry ) {
+
+		const geometryCacheKey = renderObject.getGeometryCacheKey();
+
+		cacheKeyComponents.push( {
+			property: 'geometry.cacheKey',
+			valueKey: geometryCacheKey,
+			value: getDebugValue( geometryCacheKey )
+		} );
+
+	}
+
+	if ( object.skeleton ) {
+
+		cacheKeyComponents.push( {
+			property: 'object.skeleton.bones.length',
+			valueKey: String( object.skeleton.bones.length ),
+			value: String( object.skeleton.bones.length )
+		} );
+
+	}
+
+	if ( object.isBatchedMesh ) {
+
+		cacheKeyComponents.push( {
+			property: 'object._matricesTexture',
+			valueKey: object._matricesTexture.uuid,
+			value: getDebugValue( object._matricesTexture )
+		} );
+
+		if ( object._colorsTexture !== null ) {
+
+			cacheKeyComponents.push( {
+				property: 'object._colorsTexture',
+				valueKey: object._colorsTexture.uuid,
+				value: getDebugValue( object._colorsTexture )
+			} );
+
+		}
+
+	}
+
+	if ( object.isInstancedMesh || object.count > 1 || Array.isArray( object.morphTargetInfluences ) ) {
+
+		cacheKeyComponents.push( {
+			property: 'object.uuid',
+			valueKey: object.uuid,
+			value: object.uuid
+		} );
+
+	}
+
+	cacheKeyComponents.push( {
+		property: 'renderContext.id',
+		valueKey: String( renderObject.context.id ),
+		value: String( renderObject.context.id )
+	} );
+
+	cacheKeyComponents.push( {
+		property: 'object.receiveShadow',
+		valueKey: String( object.receiveShadow ),
+		value: String( object.receiveShadow )
+	} );
+
+	return cacheKeyComponents;
+
+}
+
+function getDynamicCacheKeyComponents( renderObject ) {
+
+	const cacheKeyComponents = [ {
+		property: 'scene.lights',
+		valueKey: getLightsValueKey( renderObject.lightsNode ),
+		value: getLightsValue( renderObject.lightsNode )
+	}, {
+		property: 'object.receiveShadow',
+		valueKey: String( renderObject.object.receiveShadow ),
+		value: String( renderObject.object.receiveShadow )
+	}, {
+		property: 'renderer.contextNode',
+		valueKey: `${ renderObject.renderer.contextNode.id },${ renderObject.renderer.contextNode.version }`,
+		value: `id:${ renderObject.renderer.contextNode.id }, version:${ renderObject.renderer.contextNode.version }`
+	} ];
+
+	if ( renderObject.material.isShadowPassMaterial !== true ) {
+
+		const environmentNode = renderObject._nodes.getEnvironmentNode( renderObject.scene );
+		const fogNode = renderObject._nodes.getFogNode( renderObject.scene );
+		const outputRenderTarget = renderObject.renderer.getOutputRenderTarget();
+
+		cacheKeyComponents.push( {
+			property: 'scene.environmentNode',
+			valueKey: environmentNode ? String( environmentNode.getCacheKey() ) : 'null',
+			value: getNodeValue( environmentNode )
+		}, {
+			property: 'scene.fogNode',
+			valueKey: fogNode ? String( fogNode.getCacheKey() ) : 'null',
+			value: getNodeValue( fogNode )
+		}, {
+			property: 'renderTarget.multiview',
+			valueKey: outputRenderTarget && outputRenderTarget.multiview ? 'true' : 'false',
+			value: outputRenderTarget && outputRenderTarget.multiview ? 'true' : 'false'
+		}, {
+			property: 'renderer.shadowMap.enabled',
+			valueKey: renderObject.renderer.shadowMap.enabled ? 'true' : 'false',
+			value: renderObject.renderer.shadowMap.enabled ? 'true' : 'false'
+		}, {
+			property: 'renderer.shadowMap.type',
+			valueKey: String( renderObject.renderer.shadowMap.type ),
+			value: getShadowMapTypeName( renderObject.renderer.shadowMap.type )
+		} );
+
+	}
+
+	if ( renderObject.camera.isArrayCamera ) {
+
+		cacheKeyComponents.push( {
+			property: 'camera.cameras.length',
+			valueKey: String( renderObject.camera.cameras.length ),
+			value: String( renderObject.camera.cameras.length )
+		} );
+
+	}
+
+	return cacheKeyComponents;
+
+}
+
+/**
+ * Renderer component for node material invalidation debugging.
+ *
+ * @private
+ */
+class NodeMaterialDebug {
+
+	/**
+	 * Constructs a new node material debug component.
+	 *
+	 * @param {Renderer} renderer - The renderer.
+	 */
+	constructor( renderer ) {
+
+		/**
+		 * The renderer.
+		 *
+		 * @type {Renderer}
+		 */
+		this.renderer = renderer;
+
+		/**
+		 * Weak map with cache-key snapshots per render object.
+		 *
+		 * @type {WeakMap<RenderObject,Object>}
+		 */
+		this.cache = new WeakMap();
+
+	}
+
+	/**
+	 * Whether node material invalidation debugging is enabled.
+	 *
+	 * @type {boolean}
+	 * @readonly
+	 */
+	get enabled() {
+
+		return this.renderer.debug.traceNodeMaterialInvalidation === true || typeof this.renderer.debug.onNodeMaterialInvalidation === 'function';
+
+	}
+
+	/**
+	 * Updates the cached debug data for the given render object.
+	 *
+	 * @param {RenderObject} renderObject - The render object.
+	 */
+	update( renderObject ) {
+
+		if ( this.enabled === false ) return;
+
+		this.cache.set( renderObject, {
+			material: getMaterialCacheKeyComponents( renderObject ),
+			dynamic: getDynamicCacheKeyComponents( renderObject )
+		} );
+
+	}
+
+	/**
+	 * Reports cache invalidation for the given render object.
+	 *
+	 * @param {RenderObject} renderObject - The render object.
+	 */
+	report( renderObject ) {
+
+		if ( this.enabled === false ) return;
+
+		const previousData = this.cache.get( renderObject );
+
+		if ( previousData === undefined ) return;
+
+		const materialCacheDifference = getCacheKeyDifference( previousData.material, getMaterialCacheKeyComponents( renderObject ) );
+
+		if ( materialCacheDifference !== null ) {
+
+			this._dispatch( {
+				stage: 'material-cache',
+				property: materialCacheDifference.property,
+				previousValue: materialCacheDifference.previousValue,
+				value: materialCacheDifference.value,
+				rebuild: true,
+				needsRefresh: true,
+				material: renderObject.material,
+				renderObject
+			} );
+
+			return;
+
+		}
+
+		const dynamicCacheDifference = getCacheKeyDifference( previousData.dynamic, getDynamicCacheKeyComponents( renderObject ) );
+
+		if ( dynamicCacheDifference !== null ) {
+
+			this._dispatch( {
+				stage: 'dynamic-cache',
+				property: dynamicCacheDifference.property,
+				previousValue: dynamicCacheDifference.previousValue,
+				value: dynamicCacheDifference.value,
+				rebuild: true,
+				needsRefresh: true,
+				material: renderObject.material,
+				renderObject
+			} );
+
+		}
+
+	}
+
+	_dispatch( data ) {
+
+		const callback = this.renderer.debug.onNodeMaterialInvalidation;
+		const materialLabel = data.material.name !== '' ? data.material.name : data.material.type;
+		const event = { ...data, materialLabel };
+
+		if ( typeof callback === 'function' ) {
+
+			callback( event );
+			return;
+
+		}
+
+		if ( this.renderer.debug.traceNodeMaterialInvalidation !== true ) return;
+
+		const property = event.property !== undefined ? ` via ${ event.property }` : '';
+		const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
+
+		warn( `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }.` );
+
+	}
+
+}
+
+export default NodeMaterialDebug;
diff --git a/src/renderers/common/RenderObjects.js b/src/renderers/common/RenderObjects.js
index 676cc2bd416942..8f338977543c6d 100644
--- a/src/renderers/common/RenderObjects.js
+++ b/src/renderers/common/RenderObjects.js
@@ -90,6 +90,7 @@ class RenderObjects {
 	get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
+		const nodeMaterialDebug = this.renderer._getNodeMaterialDebug();
 
 		// set chain keys
 
@@ -128,6 +129,8 @@ class RenderObjects {
 
 				if ( renderObject.initialCacheKey !== renderObject.getCacheKey() ) {
 
+					if ( nodeMaterialDebug !== null ) nodeMaterialDebug.report( renderObject );
+
 					renderObject.dispose();
 
 					renderObject = this.get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId );
@@ -151,6 +154,8 @@ class RenderObjects {
 
 		//
 
+		if ( nodeMaterialDebug !== null ) nodeMaterialDebug.update( renderObject );
+
 		return renderObject;
 
 	}
diff --git a/src/renderers/common/Renderer.js b/src/renderers/common/Renderer.js
index a8967b5afd005e..30f11329ac260b 100644
--- a/src/renderers/common/Renderer.js
+++ b/src/renderers/common/Renderer.js
@@ -10,6 +10,7 @@ import RenderContexts from './RenderContexts.js';
 import Textures from './Textures.js';
 import Background from './Background.js';
 import NodeManager from './nodes/NodeManager.js';
+import NodeMaterialDebug from './NodeMaterialDebug.js';
 import Color4 from './Color4.js';
 import ClippingContext from './ClippingContext.js';
 import QuadMesh from './QuadMesh.js';
@@ -703,6 +704,8 @@ class Renderer {
 		 * @typedef {Object} DebugConfig
 		 * @property {boolean} checkShaderErrors - Whether shader errors should be checked or not.
 		 * @property {?Function} onShaderError - A callback function that is executed when a shader error happens. Only supported with WebGL 2 right now.
+		 * @property {boolean} traceNodeMaterialInvalidation - Whether node material invalidations that trigger render object cache misses should be reported.
+		 * @property {?Function} onNodeMaterialInvalidation - A callback function that receives node material invalidation data. Assigning a custom function disables default reporting.
 		 * @property {Function} getShaderAsync - Allows the get the raw shader code for the given scene, camera and 3D object.
 		 */
 
@@ -711,9 +714,13 @@ class Renderer {
 		 *
 		 * @type {DebugConfig}
 		 */
+		this._nodeMaterialDebug = null;
+
 		this.debug = {
 			checkShaderErrors: true,
 			onShaderError: null,
+			traceNodeMaterialInvalidation: false,
+			onNodeMaterialInvalidation: null,
 			getShaderAsync: async ( scene, camera, object ) => {
 
 				await this.compileAsync( scene, camera );
@@ -734,6 +741,37 @@ class Renderer {
 
 	}
 
+	/**
+	 * Returns the node material debug helper when the feature is enabled.
+	 *
+	 * @private
+	 * @return {?NodeMaterialDebug} The debug helper.
+	 */
+	_getNodeMaterialDebug() {
+
+		const debug = this.debug;
+		let nodeMaterialDebug = this._nodeMaterialDebug;
+
+		if ( debug.traceNodeMaterialInvalidation === true || typeof debug.onNodeMaterialInvalidation === 'function' ) {
+
+			if ( nodeMaterialDebug === null ) {
+
+				nodeMaterialDebug = new NodeMaterialDebug( this );
+				this._nodeMaterialDebug = nodeMaterialDebug;
+
+			}
+
+		} else if ( nodeMaterialDebug !== null ) {
+
+			this._nodeMaterialDebug = null;
+			nodeMaterialDebug = null;
+
+		}
+
+		return nodeMaterialDebug;
+
+	}
+
 	/**
 	 * Initializes the renderer so it is ready for usage.
 	 *
diff --git a/test/e2e/image.js b/test/e2e/image.js
index cecdc5598e827d..56875ec08ea6ce 100644
--- a/test/e2e/image.js
+++ b/test/e2e/image.js
@@ -169,10 +169,22 @@ class Image {
 
 			buffer = await fs.readFile( input );
 
-		} else {
+		} else if ( Buffer.isBuffer( input ) ) {
 
 			buffer = input;
 
+		} else if ( ArrayBuffer.isView( input ) ) {
+
+			buffer = Buffer.from( input.buffer, input.byteOffset, input.byteLength );
+
+		} else if ( input instanceof ArrayBuffer ) {
+
+			buffer = Buffer.from( input );
+
+		} else {
+
+			buffer = Buffer.from( input );
+
 		}
 
 		// Check if PNG (starts with PNG signature)
diff --git a/test/unit/src/renderers/RenderObjects.tests.js b/test/unit/src/renderers/RenderObjects.tests.js
new file mode 100644
index 00000000000000..c2b97e7876ad94
--- /dev/null
+++ b/test/unit/src/renderers/RenderObjects.tests.js
@@ -0,0 +1,190 @@
+import RenderObjects from '../../../../src/renderers/common/RenderObjects.js';
+import NodeMaterialDebug from '../../../../src/renderers/common/NodeMaterialDebug.js';
+import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
+import { MeshBasicMaterial } from '../../../../src/materials/MeshBasicMaterial.js';
+import { PerspectiveCamera } from '../../../../src/cameras/PerspectiveCamera.js';
+import { Mesh } from '../../../../src/objects/Mesh.js';
+import { Scene } from '../../../../src/scenes/Scene.js';
+
+function createRenderer( events ) {
+
+	const renderer = {
+		backend: { isWebGPUBackend: false },
+		contextNode: { id: 1, version: 0 },
+		shadowMap: { enabled: false, type: 1 },
+		debug: {
+			traceNodeMaterialInvalidation: false,
+			onNodeMaterialInvalidation: events ? ( event ) => events.push( event ) : null
+		},
+		getOutputRenderTarget() {
+
+			return null;
+
+		}
+	};
+
+	renderer._nodeMaterialDebug = events ? new NodeMaterialDebug( renderer ) : null;
+	renderer._getNodeMaterialDebug = () => renderer._nodeMaterialDebug;
+
+	return renderer;
+
+}
+
+function createNodes() {
+
+	return {
+		getCacheKey: () => 0,
+		getEnvironmentNode: () => null,
+		getFogNode: () => null,
+		delete: () => {}
+	};
+
+}
+
+function createRenderObjects( events, nodes = createNodes() ) {
+
+	return new RenderObjects(
+		createRenderer( events ),
+		nodes,
+		{},
+		{ delete: () => {} },
+		{ deleteForRender: () => {} },
+		{}
+	);
+
+}
+
+function createState() {
+
+	const material = new MeshBasicMaterial();
+	const object = new Mesh( new BufferGeometry(), material );
+	const scene = new Scene();
+	const camera = new PerspectiveCamera();
+	const lights = [];
+	const lightsNode = {
+		getLights() {
+
+			return lights;
+
+		},
+		getCacheKey() {
+
+			return lights.map( ( light ) => `${ light.type }:${ light.id }:${ light.castShadow === true ? 1 : 0 }` ).join( '|' );
+
+		}
+	};
+
+	return {
+		object,
+		material,
+		scene,
+		camera,
+		lights,
+		lightsNode,
+		renderContext: { id: 1 },
+		clippingContext: { cacheKey: '' }
+	};
+
+}
+
+export default QUnit.module( 'Renderers', () => {
+
+	QUnit.module( 'RenderObjects', () => {
+
+		QUnit.test( 'reports the cache contributor that invalidates a node material', ( assert ) => {
+
+			const events = [];
+			const renderObjects = createRenderObjects( events );
+			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
+
+			material.name = 'DebugMaterial';
+
+			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			material.transparent = true;
+			material.needsUpdate = true;
+
+			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated after the cache miss.' );
+			assert.strictEqual( events.length, 1, 'One invalidation event was reported.' );
+			assert.strictEqual( events[ 0 ].material, material, 'The event exposes the invalidated material.' );
+			assert.strictEqual( events[ 0 ].materialLabel, 'DebugMaterial', 'The material label prefers material.name.' );
+			assert.strictEqual( events[ 0 ].property, 'material.transparent', 'The changed cache contributor is reported.' );
+			assert.strictEqual( events[ 0 ].previousValue, 'false', 'The previous contributor value is reported.' );
+			assert.strictEqual( events[ 0 ].value, 'true', 'The next contributor value is reported.' );
+			assert.strictEqual( events[ 0 ].rebuild, true, 'The event identifies the render object rebuild.' );
+			assert.strictEqual( events[ 0 ].needsRefresh, true, 'The event identifies the forced refresh.' );
+
+		} );
+
+		QUnit.test( 'reports dynamic cache invalidations with readable light changes', ( assert ) => {
+
+			let nodeCacheKey = 1;
+
+			const nodes = {
+				getCacheKey: () => nodeCacheKey,
+				getEnvironmentNode: () => null,
+				getFogNode: () => null,
+				delete: () => {}
+			};
+
+			const events = [];
+			const renderObjects = createRenderObjects( events, nodes );
+			const { object, material, scene, camera, lights, lightsNode, renderContext, clippingContext } = createState();
+
+			lights.push( { type: 'HemisphereLight', id: 1, castShadow: false } );
+			lights.push( { type: 'DirectionalLight', id: 2, castShadow: true } );
+
+			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			lights.push( { type: 'PointLight', id: 3, castShadow: false } );
+			nodeCacheKey = 2;
+
+			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated after the dynamic cache changes.' );
+			assert.strictEqual( events.length, 1, 'One invalidation event was reported.' );
+			assert.strictEqual( events[ 0 ].property, 'scene.lights', 'The report points to the light setup instead of an opaque hash.' );
+			assert.strictEqual( events[ 0 ].previousValue, '2 lights [HemisphereLight#1, DirectionalLight#2 shadow]', 'The previous light setup is human readable.' );
+			assert.strictEqual( events[ 0 ].value, '3 lights [HemisphereLight#1, DirectionalLight#2 shadow, PointLight#3]', 'The next light setup is human readable.' );
+
+		} );
+
+		QUnit.test( 'ignores material changes that do not affect the render object cache', ( assert ) => {
+
+			const events = [];
+			const renderObjects = createRenderObjects( events );
+			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
+
+			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			material.opacity = 0.25;
+			material.needsUpdate = true;
+
+			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			assert.strictEqual( refreshedRenderObject, initialRenderObject, 'The existing render object is reused when the cache key stays stable.' );
+			assert.strictEqual( events.length, 0, 'No invalidation event is reported for cache-stable changes.' );
+
+		} );
+
+		QUnit.test( 'works without node material debug enabled', ( assert ) => {
+
+			const renderObjects = createRenderObjects( null );
+			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
+
+			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			material.transparent = true;
+			material.needsUpdate = true;
+
+			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
+
+			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated without requiring debug support.' );
+
+		} );
+
+	} );
+
+} );
diff --git a/test/unit/three.source.unit.js b/test/unit/three.source.unit.js
index 96c8e2ca0c3602..815b626cfc3aa6 100644
--- a/test/unit/three.source.unit.js
+++ b/test/unit/three.source.unit.js
@@ -235,6 +235,7 @@ import './src/renderers/WebGLArrayRenderTarget.tests.js';
 import './src/renderers/WebGLCubeRenderTarget.tests.js';
 import './src/renderers/WebGLRenderer.tests.js';
 import './src/renderers/WebGLRenderTarget.tests.js';
+import './src/renderers/RenderObjects.tests.js';
 
 //src/renderers/shaders
 import './src/renderers/shaders/ShaderChunk.tests.js';

From 14f2a3889237aba138184b8e3491228ef4a2a84a Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Thu, 2 Apr 2026 11:03:50 +0900
Subject: [PATCH 02/19] Fix image buffer normalization branch

---
 test/e2e/image.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/test/e2e/image.js b/test/e2e/image.js
index 56875ec08ea6ce..916d9b0e9e1424 100644
--- a/test/e2e/image.js
+++ b/test/e2e/image.js
@@ -177,10 +177,6 @@ class Image {
 
 			buffer = Buffer.from( input.buffer, input.byteOffset, input.byteLength );
 
-		} else if ( input instanceof ArrayBuffer ) {
-
-			buffer = Buffer.from( input );
-
 		} else {
 
 			buffer = Buffer.from( input );

From 44296dc8da7b5e63620c27e25c96622c6b488429 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Thu, 2 Apr 2026 13:21:21 +0900
Subject: [PATCH 03/19] Tests: ignore webgpu materials debug rebuild screenshot

---
 test/e2e/puppeteer.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/e2e/puppeteer.js b/test/e2e/puppeteer.js
index 6445cf1a66c1d4..2191b7927d2655 100644
--- a/test/e2e/puppeteer.js
+++ b/test/e2e/puppeteer.js
@@ -27,6 +27,7 @@ const exceptionList = [
 	'webgl_worker_offscreencanvas',
 	'webgpu_backdrop_water',
 	'webgpu_lightprobe_cubecamera',
+	'webgpu_materials_debug_rebuild',
 	'webgpu_portal',
 	'webgpu_postprocessing_ao',
 	'webgpu_postprocessing_dof',

From 254e6e61e420ef258ea949db45c220145de3498f Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Sat, 4 Apr 2026 10:51:09 +0900
Subject: [PATCH 04/19] save node comp

---
 src/renderers/common/NodeMaterialDebug.js | 485 +++++++++++++++++++++-
 1 file changed, 466 insertions(+), 19 deletions(-)

diff --git a/src/renderers/common/NodeMaterialDebug.js b/src/renderers/common/NodeMaterialDebug.js
index 6ca3224269b015..3e10701c60ba6b 100644
--- a/src/renderers/common/NodeMaterialDebug.js
+++ b/src/renderers/common/NodeMaterialDebug.js
@@ -1,5 +1,6 @@
 import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap } from '../../constants.js';
 import { warn } from '../../utils.js';
+import ChainMap from './ChainMap.js';
 
 function getKeys( obj ) {
 
@@ -82,18 +83,181 @@ function getNodeValue( node ) {
 
 }
 
-function getLightValueKey( light ) {
+function getPath( basePath, property, index = undefined ) {
 
-	let valueKey = `${ light.type }:${ light.id }:${ light.castShadow === true ? 1 : 0 }`;
+	let path = `${ basePath }.${ property }`;
 
-	if ( light.isSpotLight === true ) {
+	if ( index !== undefined ) {
+
+		path += Number.isInteger( index ) ? `[${ index }]` : `.${ index }`;
+
+	}
+
+	return path;
+
+}
+
+function getNodeCustomCacheStateComponents( node, path ) {
+
+	const cacheKeyComponents = [];
+
+	if ( node.type === 'ToneMappingNode' && typeof node.getToneMapping === 'function' ) {
+
+		const toneMapping = node.getToneMapping();
+
+		cacheKeyComponents.push( {
+			property: `${ path }.toneMapping`,
+			valueKey: String( toneMapping ),
+			value: String( toneMapping )
+		} );
+
+	} else if ( node.isPropertyNode === true ) {
+
+		cacheKeyComponents.push( {
+			property: `${ path }.name`,
+			valueKey: String( node.name ),
+			value: getDebugValue( node.name )
+		}, {
+			property: `${ path }.varying`,
+			valueKey: String( node.varying ),
+			value: String( node.varying )
+		} );
+
+	} else if ( typeof node.getLights === 'function' ) {
+
+		cacheKeyComponents.push( {
+			property: `${ path }.lights`,
+			valueKey: getLightsNodeValueKey( node ),
+			value: getLightsNodeValue( node )
+		} );
+
+	}
+
+	return cacheKeyComponents;
+
+}
+
+function getNodeComponent( node, path, withSnapshot = false ) {
+
+	const component = {
+		node,
+		property: path,
+		valueKey: node.getCacheKey(),
+		value: getNodeValue( node ),
+		nodeId: node.id,
+		nodeType: node.type || node.constructor.name,
+		customCacheKey: node.customCacheKey(),
+		customCacheState: getNodeCustomCacheStateComponents( node, path )
+	};
+
+	if ( withSnapshot === true ) {
+
+		component.snapshot = getNodeSnapshot( node, path );
+
+	}
+
+	return component;
+
+}
+
+function getComponentByProperty( components, property ) {
+
+	for ( const component of components ) {
+
+		if ( component.property === property ) return component;
+
+	}
+
+	return null;
+
+}
+
+function getNodeSnapshot( node, path, ignores = new Set() ) {
+
+	const component = getNodeComponent( node, path );
+
+	const nextIgnores = new Set( ignores );
+	nextIgnores.add( node );
+
+	const children = [];
+
+	for ( const { property, index, childNode } of node._getChildren( new Set( ignores ) ) ) {
+
+		const childPath = getPath( path, property, index );
 
-		valueKey += `:${ light.map !== null ? light.map.id : - 1 }`;
-		valueKey += `:${ light.colorNode ? light.colorNode.getCacheKey() : - 1 }`;
+		children.push( {
+			property: childPath,
+			valueKey: childNode.getCacheKey(),
+			value: getNodeValue( childNode ),
+			snapshot: getNodeSnapshot( childNode, childPath, nextIgnores )
+		} );
+
+	}
+
+	return {
+		path,
+		value: component.value,
+		valueKey: component.valueKey,
+		nodeId: component.nodeId,
+		nodeType: component.nodeType,
+		customCacheKey: component.customCacheKey,
+		customCacheState: component.customCacheState,
+		children
+	};
+
+}
+
+function getMaterialNodeComponents( material, withSnapshots = false ) {
+
+	if ( material.isNodeMaterial !== true || typeof material._getNodeChildren !== 'function' ) return [];
+
+	const cacheKeyComponents = [];
+
+	for ( const { property, childNode } of material._getNodeChildren() ) {
+
+		const path = `material.${ property }`;
+
+		cacheKeyComponents.push( getNodeComponent( childNode, path, withSnapshots ) );
+
+	}
+
+	return cacheKeyComponents;
+
+}
+
+function getTraceMaterialNodeComponents( previousComponents, currentComponents ) {
+
+	const previousMap = new Map();
+
+	for ( const component of previousComponents ) {
+
+		previousMap.set( component.property, component );
+
+	}
+
+	for ( const component of currentComponents ) {
+
+		const previousComponent = previousMap.get( component.property );
+
+		if (
+			previousComponent !== undefined &&
+			previousComponent.valueKey === component.valueKey &&
+			previousComponent.nodeId === component.nodeId &&
+			previousComponent.nodeType === component.nodeType &&
+			previousComponent.snapshot !== undefined
+		) {
+
+			component.snapshot = previousComponent.snapshot;
+
+		} else {
+
+			component.snapshot = getNodeSnapshot( component.node, component.property );
+
+		}
 
 	}
 
-	return valueKey;
+	return currentComponents;
 
 }
 
@@ -126,15 +290,25 @@ function getLightsValue( lightsNode ) {
 
 }
 
-function getLightsValueKey( lightsNode ) {
+function getLightsNodeValue( lightsNode ) {
 
-	if ( lightsNode === null ) return '';
+	if ( lightsNode === null ) return 'none';
 
-	return lightsNode.getLights().slice().sort( ( a, b ) => a.id - b.id ).map( getLightValueKey ).join( ',' );
+	const lightsNodeType = lightsNode.type || lightsNode.constructor.name;
+
+	return `${ lightsNodeType } ${ getLightsValue( lightsNode ) }`;
 
 }
 
-function getCacheKeyDifference( previousComponents, currentComponents ) {
+function getLightsNodeValueKey( lightsNode ) {
+
+	if ( lightsNode === null ) return 'null';
+
+	return String( lightsNode.getCacheKey( true ) );
+
+}
+
+function getCacheKeyDifference( previousComponents, currentComponents, resolveDifference = null ) {
 
 	const currentMap = new Map();
 
@@ -156,6 +330,14 @@ function getCacheKeyDifference( previousComponents, currentComponents ) {
 
 		if ( component.valueKey !== current.valueKey ) {
 
+			if ( resolveDifference !== null ) {
+
+				const resolvedDifference = resolveDifference( component, current );
+
+				if ( resolvedDifference !== null ) return resolvedDifference;
+
+			}
+
 			return { property: component.property, previousValue: component.value, value: current.value };
 
 		}
@@ -184,6 +366,86 @@ function getCacheKeyDifference( previousComponents, currentComponents ) {
 
 }
 
+function getNodeSnapshotDifference( previousSnapshot, currentSnapshot ) {
+
+	if ( previousSnapshot.valueKey === currentSnapshot.valueKey ) return null;
+
+	if ( previousSnapshot.nodeId !== currentSnapshot.nodeId || previousSnapshot.nodeType !== currentSnapshot.nodeType ) {
+
+		return {
+			property: previousSnapshot.path,
+			previousValue: previousSnapshot.value,
+			value: currentSnapshot.value
+		};
+
+	}
+
+	const childDifference = getCacheKeyDifference(
+		previousSnapshot.children,
+		currentSnapshot.children,
+		( previousComponent, currentComponent ) => getNodeSnapshotDifference( previousComponent.snapshot, currentComponent.snapshot )
+	);
+
+	if ( childDifference !== null ) return childDifference;
+
+	if ( previousSnapshot.customCacheKey !== currentSnapshot.customCacheKey ) {
+
+		const customCacheStateDifference = getCacheKeyDifference( previousSnapshot.customCacheState, currentSnapshot.customCacheState );
+
+		if ( customCacheStateDifference !== null ) return customCacheStateDifference;
+
+		return {
+			property: `${ previousSnapshot.path }.customCacheKey()`,
+			previousValue: String( previousSnapshot.customCacheKey ),
+			value: String( currentSnapshot.customCacheKey )
+		};
+
+	}
+
+	return {
+		property: previousSnapshot.path,
+		previousValue: `${ previousSnapshot.value } cacheKey:${ previousSnapshot.valueKey }`,
+		value: `${ currentSnapshot.value } cacheKey:${ currentSnapshot.valueKey }`
+	};
+
+}
+
+function getNodeComponentDifference( previousComponent, currentComponent ) {
+
+	if ( previousComponent.valueKey === currentComponent.valueKey ) return null;
+
+	if ( previousComponent.nodeId !== currentComponent.nodeId || previousComponent.nodeType !== currentComponent.nodeType ) {
+
+		return {
+			property: previousComponent.property,
+			previousValue: previousComponent.value,
+			value: currentComponent.value
+		};
+
+	}
+
+	if ( previousComponent.customCacheKey !== currentComponent.customCacheKey ) {
+
+		const customCacheStateDifference = getCacheKeyDifference( previousComponent.customCacheState, currentComponent.customCacheState );
+
+		if ( customCacheStateDifference !== null ) return customCacheStateDifference;
+
+		return {
+			property: `${ previousComponent.property }.customCacheKey()`,
+			previousValue: String( previousComponent.customCacheKey ),
+			value: String( currentComponent.customCacheKey )
+		};
+
+	}
+
+	return {
+		property: previousComponent.property,
+		previousValue: `${ previousComponent.value } cacheKey:${ previousComponent.valueKey }`,
+		value: `${ currentComponent.value } cacheKey:${ currentComponent.valueKey }`
+	};
+
+}
+
 function getMaterialCacheKeyComponents( renderObject ) {
 
 	const { object, material, renderer } = renderObject;
@@ -330,9 +592,9 @@ function getMaterialCacheKeyComponents( renderObject ) {
 function getDynamicCacheKeyComponents( renderObject ) {
 
 	const cacheKeyComponents = [ {
-		property: 'scene.lights',
-		valueKey: getLightsValueKey( renderObject.lightsNode ),
-		value: getLightsValue( renderObject.lightsNode )
+		property: 'scene.lightsNode',
+		valueKey: getLightsNodeValueKey( renderObject.lightsNode ),
+		value: getLightsNodeValue( renderObject.lightsNode )
 	}, {
 		property: 'object.receiveShadow',
 		valueKey: String( renderObject.object.receiveShadow ),
@@ -387,6 +649,20 @@ function getDynamicCacheKeyComponents( renderObject ) {
 
 }
 
+function getNodesCacheKey( renderObject ) {
+
+	let cacheKey = 0;
+
+	if ( renderObject.material.isShadowPassMaterial !== true ) {
+
+		cacheKey = renderObject._nodes.getCacheKey( renderObject.scene, renderObject.lightsNode );
+
+	}
+
+	return String( cacheKey );
+
+}
+
 /**
  * Renderer component for node material invalidation debugging.
  *
@@ -415,6 +691,13 @@ class NodeMaterialDebug {
 		 */
 		this.cache = new WeakMap();
 
+		/**
+		 * Cache snapshots handed off to replacement render objects after a rebuild.
+		 *
+		 * @type {ChainMap}
+		 */
+		this.handoffs = new ChainMap();
+
 	}
 
 	/**
@@ -429,6 +712,18 @@ class NodeMaterialDebug {
 
 	}
 
+	/**
+	 * Whether detailed material-node tracing is enabled.
+	 *
+	 * @type {boolean}
+	 * @readonly
+	 */
+	get traceEnabled() {
+
+		return this.renderer.debug.traceNodeMaterialInvalidation === true;
+
+	}
+
 	/**
 	 * Updates the cached debug data for the given render object.
 	 *
@@ -438,10 +733,54 @@ class NodeMaterialDebug {
 
 		if ( this.enabled === false ) return;
 
-		this.cache.set( renderObject, {
+		const previousData = this.cache.get( renderObject );
+		const geometryId = renderObject.geometry !== null ? renderObject.geometry.id : null;
+
+		if ( previousData === undefined ) {
+
+			const handoffData = this.handoffs.get( renderObject.getChainArray() );
+
+			if ( handoffData !== undefined ) {
+
+				this.handoffs.delete( renderObject.getChainArray() );
+				this.cache.set( renderObject, handoffData );
+				return;
+
+			}
+
+		}
+
+		if ( previousData !== undefined ) {
+
+			// Callback mode only needs the baseline captured when the render object became current.
+			if ( this.traceEnabled === false ) return;
+
+			if (
+				previousData.materialNodes !== undefined &&
+				previousData.version === renderObject.version &&
+				previousData.geometryId === geometryId &&
+				previousData.clippingContextCacheKey === renderObject.clippingContextCacheKey
+			) {
+
+				return;
+
+			}
+
+		}
+
+		const data = {
+			version: renderObject.version,
+			geometryId,
+			clippingContextCacheKey: renderObject.clippingContextCacheKey,
 			material: getMaterialCacheKeyComponents( renderObject ),
-			dynamic: getDynamicCacheKeyComponents( renderObject )
-		} );
+			materialNodes: getMaterialNodeComponents( renderObject.material, this.traceEnabled ),
+			materialNodesTrace: this.traceEnabled,
+			dynamic: getDynamicCacheKeyComponents( renderObject ),
+			dynamicCacheKey: String( renderObject.getDynamicCacheKey() ),
+			nodesCacheKey: getNodesCacheKey( renderObject )
+		};
+
+		this.cache.set( renderObject, data );
 
 	}
 
@@ -458,15 +797,114 @@ class NodeMaterialDebug {
 
 		if ( previousData === undefined ) return;
 
-		const materialCacheDifference = getCacheKeyDifference( previousData.material, getMaterialCacheKeyComponents( renderObject ) );
+		let material = null;
+		let materialNodes = null;
+		let traceMaterialNodes = null;
+		let dynamic = null;
+		let dynamicCacheKey = null;
+		let nodesCacheKey = null;
+		const currentMaterial = () => material || ( material = getMaterialCacheKeyComponents( renderObject ) );
+		const currentMaterialNodes = () => materialNodes || ( materialNodes = getMaterialNodeComponents( renderObject.material ) );
+		const currentTraceMaterialNodes = () => {
+
+			if ( traceMaterialNodes === null ) {
+
+				traceMaterialNodes = getTraceMaterialNodeComponents( previousData.materialNodes, currentMaterialNodes() );
+
+			}
+
+			return traceMaterialNodes;
+
+		};
+
+		const currentDynamic = () => dynamic || ( dynamic = getDynamicCacheKeyComponents( renderObject ) );
+		const currentDynamicCacheKey = () => dynamicCacheKey || ( dynamicCacheKey = String( renderObject.getDynamicCacheKey() ) );
+		const currentNodesCacheKey = () => nodesCacheKey || ( nodesCacheKey = getNodesCacheKey( renderObject ) );
+		const createCurrentData = () => {
+
+			const data = {
+				version: renderObject.version,
+				geometryId: renderObject.geometry !== null ? renderObject.geometry.id : null,
+				clippingContextCacheKey: renderObject.clippingContextCacheKey,
+				material: currentMaterial(),
+				dynamic: currentDynamic(),
+				dynamicCacheKey: currentDynamicCacheKey(),
+				nodesCacheKey: currentNodesCacheKey()
+			};
+
+			if ( previousData.materialNodes !== undefined ) {
+
+				data.materialNodes = previousData.materialNodesTrace === true ? currentTraceMaterialNodes() : currentMaterialNodes();
+				data.materialNodesTrace = previousData.materialNodesTrace;
+
+			}
+
+			return data;
+
+		};
+
+		const materialCacheDifference = getCacheKeyDifference(
+			previousData.material,
+			currentMaterial(),
+			( previousComponent, currentComponent ) => {
+
+				if ( previousData.materialNodes === undefined ) return null;
+				if ( previousComponent.property !== 'material.customProgramCacheKey' ) return null;
+
+				let nodeDifference = null;
+
+				nodeDifference = getCacheKeyDifference( previousData.materialNodes, currentMaterialNodes(), getNodeComponentDifference );
+
+				if ( nodeDifference === null ) return null;
+
+				if ( previousData.materialNodesTrace === true ) {
+
+					const previousNode = getComponentByProperty( previousData.materialNodes, nodeDifference.property );
+
+					if (
+						previousNode !== null &&
+						previousNode.snapshot !== undefined &&
+						previousNode.property === nodeDifference.property
+					) {
+
+						const currentNode = getComponentByProperty( currentTraceMaterialNodes(), nodeDifference.property );
+
+						if ( currentNode !== null && currentNode.snapshot !== undefined ) {
+
+							const snapshotDifference = getNodeSnapshotDifference( previousNode.snapshot, currentNode.snapshot );
+
+							if ( snapshotDifference !== null ) nodeDifference = snapshotDifference;
+
+						}
+
+					}
+
+				}
+
+				return {
+					property: nodeDifference.property,
+					previousValue: nodeDifference.previousValue,
+					value: nodeDifference.value,
+					sourceProperty: previousComponent.property,
+					sourcePreviousValue: previousComponent.value,
+					sourceValue: currentComponent.value
+				};
+
+			}
+		);
 
 		if ( materialCacheDifference !== null ) {
 
+			this.handoffs.set( renderObject.getChainArray(), createCurrentData() );
+
 			this._dispatch( {
 				stage: 'material-cache',
 				property: materialCacheDifference.property,
 				previousValue: materialCacheDifference.previousValue,
 				value: materialCacheDifference.value,
+				sourceProperty: materialCacheDifference.sourceProperty,
+				sourcePreviousValue: materialCacheDifference.sourcePreviousValue,
+				sourceValue: materialCacheDifference.sourceValue,
 				rebuild: true,
 				needsRefresh: true,
 				material: renderObject.material,
@@ -481,6 +919,8 @@ class NodeMaterialDebug {
 
 		if ( dynamicCacheDifference !== null ) {
 
+			this.handoffs.set( renderObject.getChainArray(), createCurrentData() );
+
 			this._dispatch( {
 				stage: 'dynamic-cache',
 				property: dynamicCacheDifference.property,
@@ -488,6 +928,10 @@ class NodeMaterialDebug {
 				value: dynamicCacheDifference.value,
 				rebuild: true,
 				needsRefresh: true,
+				dynamicCacheKeyPrevious: previousData.dynamicCacheKey,
+				dynamicCacheKey: currentDynamicCacheKey(),
+				nodesCacheKeyPrevious: previousData.nodesCacheKey,
+				nodesCacheKey: currentNodesCacheKey(),
 				material: renderObject.material,
 				renderObject
 			} );
@@ -500,7 +944,9 @@ class NodeMaterialDebug {
 
 		const callback = this.renderer.debug.onNodeMaterialInvalidation;
 		const materialLabel = data.material.name !== '' ? data.material.name : data.material.type;
-		const event = { ...data, materialLabel };
+		const event = Object.assign( {}, data );
+
+		event.materialLabel = materialLabel;
 
 		if ( typeof callback === 'function' ) {
 
@@ -513,8 +959,9 @@ class NodeMaterialDebug {
 
 		const property = event.property !== undefined ? ` via ${ event.property }` : '';
 		const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
+		const source = event.sourceProperty !== undefined && event.sourceProperty !== event.property ? ` [${ event.sourceProperty }]` : '';
 
-		warn( `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }.` );
+		warn( `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }${ source }.` );
 
 	}
 

From e5da40bd581ce550a44c8cd6de477eaacb1b7f97 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:19:05 +0900
Subject: [PATCH 05/19] Move material rebuild debug to inspector

---
 examples/jsm/inspector/Inspector.js           |  65 +++-
 examples/jsm/inspector/NodeMaterialDebug.js   |  94 ++++++
 .../inspector/NodeMaterialDebugAnalyzer.js    |  41 +--
 examples/jsm/inspector/tabs/Console.js        |  35 +++
 examples/webgpu_materials_debug_rebuild.html  | 295 ++----------------
 src/renderers/common/RenderObjects.js         |   3 -
 src/renderers/common/Renderer.js              |  38 ---
 7 files changed, 224 insertions(+), 347 deletions(-)
 create mode 100644 examples/jsm/inspector/NodeMaterialDebug.js
 rename src/renderers/common/NodeMaterialDebug.js => examples/jsm/inspector/NodeMaterialDebugAnalyzer.js (95%)

diff --git a/examples/jsm/inspector/Inspector.js b/examples/jsm/inspector/Inspector.js
index 97534de1851c34..74e169f6fbf5ae 100644
--- a/examples/jsm/inspector/Inspector.js
+++ b/examples/jsm/inspector/Inspector.js
@@ -9,12 +9,13 @@ import { Settings } from './tabs/Settings.js';
 import { Viewer } from './tabs/Viewer.js';
 import { Timeline } from './tabs/Timeline.js';
 import { setText } from './ui/utils.js';
+import NodeMaterialDebug from './NodeMaterialDebug.js';
 
 import { setConsoleFunction, REVISION } from 'three/webgpu';
 
 class Inspector extends RendererInspector {
 
-	constructor() {
+	constructor( options = {} ) {
 
 		super();
 
@@ -43,7 +44,12 @@ class Inspector extends RendererInspector {
 		const timeline = new Timeline();
 		profiler.addTab( timeline );
 
-		const consoleTab = new Console();
+		const consoleTab = new Console( { traceNodeMaterialInvalidation: options.traceNodeMaterialInvalidation } );
+		consoleTab.addEventListener( 'trace-node-material-invalidation', ( event ) => {
+
+			this.setTraceNodeMaterialInvalidation( event.enabled );
+
+		} );
 		profiler.addTab( consoleTab );
 
 		const settings = new Settings();
@@ -68,6 +74,9 @@ class Inspector extends RendererInspector {
 		this.settings = settings;
 		this.once = {};
 		this.extensionsData = new WeakMap();
+		this.nodeMaterialDebug = null;
+		this.onNodeMaterialInvalidation = null;
+		this.traceNodeMaterialInvalidation = options.traceNodeMaterialInvalidation === true;
 
 		this.displayCycle = {
 			text: {
@@ -257,21 +266,32 @@ class Inspector extends RendererInspector {
 
 		}
 
+		this.updateNodeMaterialDebug();
+
 	}
 
 	setRenderer( renderer ) {
 
+		if ( this.nodeMaterialDebug !== null ) {
+
+			this.nodeMaterialDebug.dispose();
+			this.nodeMaterialDebug = null;
+
+		}
+
 		super.setRenderer( renderer );
 
 		if ( renderer !== null ) {
 
 			setConsoleFunction( this.resolveConsole.bind( this ) );
+			this.setTraceNodeMaterialInvalidation( this.traceNodeMaterialInvalidation );
 
 			if ( this.isAvailable ) {
 
 				renderer.init().then( () => {
 
 					renderer.backend.trackTimestamp = true;
+					this.updateNodeMaterialDebug();
 
 					if ( renderer.hasFeature( 'timestamp-query' ) !== true ) {
 
@@ -291,6 +311,47 @@ class Inspector extends RendererInspector {
 
 	}
 
+	updateNodeMaterialDebug() {
+
+		if ( this.nodeMaterialDebug !== null ) this.nodeMaterialDebug.updateRenderer();
+
+		return this;
+
+	}
+
+	setTraceNodeMaterialInvalidation( enabled ) {
+
+		this.traceNodeMaterialInvalidation = enabled === true;
+
+		const renderer = this.getRenderer();
+
+		if ( this.traceNodeMaterialInvalidation === true && renderer !== null ) {
+
+			if ( this.nodeMaterialDebug === null ) this.nodeMaterialDebug = new NodeMaterialDebug( renderer );
+			this.nodeMaterialDebug.onNodeMaterialInvalidation = ( event ) => {
+
+				const property = event.property !== undefined ? ` via ${ event.property }` : '';
+				const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
+				const source = event.sourceProperty !== undefined && event.sourceProperty !== event.property ? ` [${ event.sourceProperty }]` : '';
+
+				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ event.materialLabel }"${ property }${ values }${ source }.` );
+
+				if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
+
+			};
+			this.nodeMaterialDebug.updateRenderer();
+
+		} else if ( this.nodeMaterialDebug !== null ) {
+
+			this.nodeMaterialDebug.dispose();
+			this.nodeMaterialDebug = null;
+
+		}
+
+		return this;
+
+	}
+
 	createParameters( name ) {
 
 		if ( this.parameters.isVisible === false ) {
diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
new file mode 100644
index 00000000000000..e4314f70420bfc
--- /dev/null
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -0,0 +1,94 @@
+import NodeMaterialDebugAnalyzer from './NodeMaterialDebugAnalyzer.js';
+
+class NodeMaterialDebug {
+
+	constructor( renderer ) {
+
+		this.renderer = renderer;
+		this.analyzer = new NodeMaterialDebugAnalyzer( renderer );
+		this.onNodeMaterialInvalidation = null;
+
+		this._objects = null;
+		this._originalGet = null;
+
+		this.updateRenderer();
+
+	}
+
+	updateRenderer() {
+
+		const renderObjects = this.renderer._objects;
+
+		if ( renderObjects === null || renderObjects === undefined || this._objects === renderObjects ) return this;
+
+		this.dispose();
+
+		const originalGet = renderObjects.get;
+		const nodeMaterialDebug = this;
+
+		renderObjects.get = function ( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId ) {
+
+			const chainMap = this.getChainMap( passId );
+			const previousRenderObject = chainMap.get( [ object, material, renderContext, lightsNode ] );
+
+			if ( previousRenderObject !== undefined ) {
+
+				previousRenderObject.camera = camera;
+				previousRenderObject.updateClipping( clippingContext );
+
+				if ( previousRenderObject.needsGeometryUpdate ) previousRenderObject.setGeometry( object.geometry );
+
+				if ( ( previousRenderObject.version !== material.version || previousRenderObject.needsUpdate ) && previousRenderObject.initialCacheKey !== previousRenderObject.getCacheKey() ) {
+
+					nodeMaterialDebug.report( previousRenderObject );
+
+				}
+
+			}
+
+			const renderObject = originalGet.call( this, object, material, scene, camera, lightsNode, renderContext, clippingContext, passId );
+
+			nodeMaterialDebug.analyzer.update( renderObject );
+
+			return renderObject;
+
+		};
+
+		this._objects = renderObjects;
+		this._originalGet = originalGet;
+
+		return this;
+
+	}
+
+	report( renderObject ) {
+
+		const previousCallback = this.analyzer.onNodeMaterialInvalidation;
+
+		this.analyzer.onNodeMaterialInvalidation = ( event ) => {
+
+			if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
+
+		};
+
+		this.analyzer.report( renderObject );
+		this.analyzer.onNodeMaterialInvalidation = previousCallback;
+
+	}
+
+	dispose() {
+
+		if ( this._objects !== null && this._originalGet !== null ) {
+
+			this._objects.get = this._originalGet;
+
+		}
+
+		this._objects = null;
+		this._originalGet = null;
+
+	}
+
+}
+
+export default NodeMaterialDebug;
diff --git a/src/renderers/common/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
similarity index 95%
rename from src/renderers/common/NodeMaterialDebug.js
rename to examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 3e10701c60ba6b..3c11107dfc5daf 100644
--- a/src/renderers/common/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -1,6 +1,6 @@
-import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap } from '../../constants.js';
-import { warn } from '../../utils.js';
-import ChainMap from './ChainMap.js';
+import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap } from 'three/webgpu';
+import { warn } from 'three/webgpu';
+
 
 function getKeys( obj ) {
 
@@ -668,7 +668,7 @@ function getNodesCacheKey( renderObject ) {
  *
  * @private
  */
-class NodeMaterialDebug {
+class NodeMaterialDebugAnalyzer {
 
 	/**
 	 * Constructs a new node material debug component.
@@ -691,12 +691,6 @@ class NodeMaterialDebug {
 		 */
 		this.cache = new WeakMap();
 
-		/**
-		 * Cache snapshots handed off to replacement render objects after a rebuild.
-		 *
-		 * @type {ChainMap}
-		 */
-		this.handoffs = new ChainMap();
 
 	}
 
@@ -708,7 +702,7 @@ class NodeMaterialDebug {
 	 */
 	get enabled() {
 
-		return this.renderer.debug.traceNodeMaterialInvalidation === true || typeof this.renderer.debug.onNodeMaterialInvalidation === 'function';
+		return true;
 
 	}
 
@@ -720,7 +714,7 @@ class NodeMaterialDebug {
 	 */
 	get traceEnabled() {
 
-		return this.renderer.debug.traceNodeMaterialInvalidation === true;
+		return true;
 
 	}
 
@@ -736,20 +730,6 @@ class NodeMaterialDebug {
 		const previousData = this.cache.get( renderObject );
 		const geometryId = renderObject.geometry !== null ? renderObject.geometry.id : null;
 
-		if ( previousData === undefined ) {
-
-			const handoffData = this.handoffs.get( renderObject.getChainArray() );
-
-			if ( handoffData !== undefined ) {
-
-				this.handoffs.delete( renderObject.getChainArray() );
-				this.cache.set( renderObject, handoffData );
-				return;
-
-			}
-
-		}
-
 		if ( previousData !== undefined ) {
 
 			// Callback mode only needs the baseline captured when the render object became current.
@@ -895,8 +875,6 @@ class NodeMaterialDebug {
 
 		if ( materialCacheDifference !== null ) {
 
-			this.handoffs.set( renderObject.getChainArray(), createCurrentData() );
-
 			this._dispatch( {
 				stage: 'material-cache',
 				property: materialCacheDifference.property,
@@ -919,8 +897,6 @@ class NodeMaterialDebug {
 
 		if ( dynamicCacheDifference !== null ) {
 
-			this.handoffs.set( renderObject.getChainArray(), createCurrentData() );
-
 			this._dispatch( {
 				stage: 'dynamic-cache',
 				property: dynamicCacheDifference.property,
@@ -942,7 +918,7 @@ class NodeMaterialDebug {
 
 	_dispatch( data ) {
 
-		const callback = this.renderer.debug.onNodeMaterialInvalidation;
+		const callback = this.onNodeMaterialInvalidation;
 		const materialLabel = data.material.name !== '' ? data.material.name : data.material.type;
 		const event = Object.assign( {}, data );
 
@@ -955,7 +931,6 @@ class NodeMaterialDebug {
 
 		}
 
-		if ( this.renderer.debug.traceNodeMaterialInvalidation !== true ) return;
 
 		const property = event.property !== undefined ? ` via ${ event.property }` : '';
 		const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
@@ -967,4 +942,4 @@ class NodeMaterialDebug {
 
 }
 
-export default NodeMaterialDebug;
+export default NodeMaterialDebugAnalyzer;
diff --git a/examples/jsm/inspector/tabs/Console.js b/examples/jsm/inspector/tabs/Console.js
index 2668c114bfc389..da546c3dce719d 100644
--- a/examples/jsm/inspector/tabs/Console.js
+++ b/examples/jsm/inspector/tabs/Console.js
@@ -8,6 +8,7 @@ class Console extends Tab {
 
 		this.filters = { info: true, warn: true, error: true };
 		this.filterText = '';
+		this.traceNodeMaterialInvalidation = false;
 
 		this.buildHeader();
 
@@ -15,6 +16,13 @@ class Console extends Tab {
 		this.logContainer.id = 'console-log';
 		this.content.appendChild( this.logContainer );
 
+		if ( options.traceNodeMaterialInvalidation === true ) {
+
+			this.traceNodeMaterialInvalidation = true;
+			this.nodeMaterialCheckbox.checked = true;
+
+		}
+
 	}
 
 	buildHeader() {
@@ -42,6 +50,23 @@ class Console extends Tab {
 		const buttonsGroup = document.createElement( 'div' );
 		buttonsGroup.className = 'console-buttons-group';
 
+		const nodeMaterialLabel = document.createElement( 'label' );
+		nodeMaterialLabel.className = 'custom-checkbox';
+		nodeMaterialLabel.title = 'Trace node material rebuild reasons';
+
+		const nodeMaterialCheckbox = document.createElement( 'input' );
+		nodeMaterialCheckbox.type = 'checkbox';
+		nodeMaterialCheckbox.dataset.action = 'trace-node-material-invalidation';
+		this.nodeMaterialCheckbox = nodeMaterialCheckbox;
+
+		const nodeMaterialCheckmark = document.createElement( 'span' );
+		nodeMaterialCheckmark.className = 'checkmark';
+
+		nodeMaterialLabel.appendChild( nodeMaterialCheckbox );
+		nodeMaterialLabel.appendChild( nodeMaterialCheckmark );
+		nodeMaterialLabel.append( 'Materials' );
+		buttonsGroup.appendChild( nodeMaterialLabel );
+
 		Object.keys( this.filters ).forEach( type => {
 
 			const label = document.createElement( 'label' );
@@ -65,6 +90,16 @@ class Console extends Tab {
 
 		buttonsGroup.addEventListener( 'change', ( e ) => {
 
+			const action = e.target.dataset.action;
+
+			if ( action === 'trace-node-material-invalidation' ) {
+
+				this.traceNodeMaterialInvalidation = e.target.checked;
+				this.dispatchEvent( { type: 'trace-node-material-invalidation', enabled: this.traceNodeMaterialInvalidation } );
+				return;
+
+			}
+
 			const type = e.target.dataset.type;
 			if ( type in this.filters ) {
 
diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index 027f52df5d71d7..35ee25677036f6 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -11,28 +11,23 @@
 				height: 100%;
 			}
 
-			#panel {
+			#actions {
 				position: absolute;
 				left: 12px;
 				bottom: 12px;
-				width: min( 720px, calc( 100% - 24px ) );
-				padding: 12px;
+				display: flex;
+				flex-wrap: wrap;
+				gap: 8px;
+				max-width: calc( 100% - 24px );
+				padding: 10px;
 				box-sizing: border-box;
 				border: 1px solid rgba( 255, 255, 255, 0.12 );
 				border-radius: 6px;
 				background: rgba( 0, 0, 0, 0.55 );
 				color: #e8e8e8;
-				font: 400 12px 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 				pointer-events: auto;
 			}
 
-			#actions {
-				display: grid;
-				grid-template-columns: repeat( 5, minmax( 0, 1fr ) );
-				gap: 8px;
-				margin-bottom: 10px;
-			}
-
 			#actions button {
 				padding: 7px 8px;
 				border: 1px solid rgba( 255, 255, 255, 0.18 );
@@ -48,133 +43,6 @@
 				background: rgba( 255, 255, 255, 0.2 );
 			}
 
-			#stateBar,
-			#status,
-			#log {
-				font-family: monospace;
-				font-size: 11px;
-				line-height: 1.5;
-			}
-
-			#stateBar {
-				display: flex;
-				flex-wrap: wrap;
-				gap: 6px;
-				margin-bottom: 8px;
-			}
-
-			.badge {
-				padding: 4px 8px;
-				border: 1px solid rgba( 255, 255, 255, 0.14 );
-				border-radius: 999px;
-				background: rgba( 255, 255, 255, 0.06 );
-				color: #dddddd;
-			}
-
-			.badge.on {
-				background: rgba( 140, 220, 255, 0.18 );
-				color: #ffffff;
-			}
-
-			#recentEvent {
-				margin-bottom: 10px;
-				padding: 8px 10px;
-				border-left: 4px solid var( --recent-color, #8ce0ff );
-				border-radius: 4px;
-				background: rgba( 255, 255, 255, 0.04 );
-				font: 700 12px/1.4 monospace;
-				color: #eef4fb;
-			}
-
-			#status {
-				margin-bottom: 10px;
-				color: #c7c7c7;
-			}
-
-			#log {
-				max-height: 170px;
-				overflow-y: auto;
-				color: #ffffff;
-			}
-
-			.log-entry {
-				padding: 6px 8px;
-				border-left: 4px solid var( --entry-color, #8ce0ff );
-				border-radius: 4px;
-				background: rgba( 255, 255, 255, 0.04 );
-			}
-
-			.log-entry + .log-entry {
-				margin-top: 6px;
-			}
-
-			.log-entry .time {
-				color: #95a3b8;
-			}
-
-			.log-entry .reason {
-				color: var( --entry-color, #8ce0ff );
-			}
-
-			.log-entry .values {
-				color: #d5deea;
-			}
-
-			#eventBanner {
-				position: absolute;
-				top: 104px;
-				right: 12px;
-				width: min( 620px, calc( 100% - 24px ) );
-				padding: 14px 16px;
-				box-sizing: border-box;
-				border: 1px solid rgba( 255, 255, 255, 0.14 );
-				border-radius: 10px;
-				background: rgba( 10, 12, 16, 0.78 );
-				backdrop-filter: blur( 10px );
-				color: #f1f5f9;
-				opacity: 0;
-				transform: translateY( - 12px ) scale( 0.98 );
-				pointer-events: none;
-			}
-
-			#eventBannerTitle {
-				font: 700 18px/1.15 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-				letter-spacing: 0.02em;
-				text-transform: uppercase;
-			}
-
-			#eventBannerReason {
-				margin-top: 8px;
-				font: 700 14px/1.3 monospace;
-				color: var( --event-color, #8ce0ff );
-			}
-
-			#eventBannerValues {
-				margin-top: 6px;
-				font: 400 12px/1.45 monospace;
-				color: #d4dbe3;
-				word-break: break-word;
-			}
-
-			#hint {
-				margin-top: 8px;
-				font: 400 11px/1.5 monospace;
-				color: #96a3b3;
-			}
-
-			@media ( max-width: 900px ) {
-
-				#eventBanner {
-					top: auto;
-					right: 12px;
-					bottom: 226px;
-				}
-
-				#actions {
-					grid-template-columns: repeat( 2, minmax( 0, 1fr ) );
-				}
-
-			}
 		</style>
 	</head>
 	<body>
@@ -189,31 +57,18 @@
 			</div>
 
 			<small>
-				Uses <code>renderer.debug.onNodeMaterialInvalidation</code> to report why a material makes the node material rebuild.<br />
-				Toggle clearcoat/transmission, or add/remove the accent light to trigger rebuilds from material or scene changes.
+				Open the Inspector Console tab to see material rebuild reasons.<br />
+				The <code>Materials</code> trace option is enabled when this example starts.
 			</small>
 		</div>
 
-		<div id="panel">
-			<div id="actions">
-				<button id="clearcoatButton">Clearcoat</button>
-				<button id="transmissionButton">Transmission</button>
-				<button id="lightButton">Point Light</button>
-				<button id="autoDemoButton">Auto Demo</button>
-				<button id="clearLogButton">Clear</button>
-			</div>
-			<div id="stateBar"></div>
-			<div id="recentEvent">Waiting for the next rebuild event.</div>
-			<div id="status"></div>
-			<div id="log"></div>
+		<div id="actions">
+			<button id="clearcoatButton">Clearcoat</button>
+			<button id="transmissionButton">Transmission</button>
+			<button id="lightButton">Point Light</button>
+			<button id="autoDemoButton">Auto Demo</button>
 		</div>
 
-		<div id="eventBanner">
-			<div id="eventBannerTitle">NodeMaterial needs rebuild</div>
-			<div id="eventBannerReason">Waiting for a rebuild event</div>
-			<div id="eventBannerValues">Use the buttons or start the auto demo.</div>
-			<div id="hint">This banner is driven directly by the debug callback.</div>
-		</div>
 
 		<script type="importmap">
 			{
@@ -231,21 +86,14 @@
 			import * as THREE from 'three/webgpu';
 
 			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+			import { Inspector } from 'three/addons/inspector/Inspector.js';
 
 			let camera, scene, renderer, controls;
 			let material, accentLight, sphere;
 			let autoDemoInterval = null;
 			let autoDemoStep = 0;
-			let feedbackTime = - Infinity;
 
 			const container = document.getElementById( 'container' );
-			const stateBarElement = document.getElementById( 'stateBar' );
-			const recentEventElement = document.getElementById( 'recentEvent' );
-			const statusElement = document.getElementById( 'status' );
-			const logElement = document.getElementById( 'log' );
-			const eventBannerElement = document.getElementById( 'eventBanner' );
-			const eventBannerReasonElement = document.getElementById( 'eventBannerReason' );
-			const eventBannerValuesElement = document.getElementById( 'eventBannerValues' );
 			const autoDemoButton = document.getElementById( 'autoDemoButton' );
 
 			init();
@@ -262,16 +110,9 @@
 				renderer.setPixelRatio( window.devicePixelRatio );
 				renderer.setSize( window.innerWidth, window.innerHeight );
 				renderer.setAnimationLoop( animate );
+				renderer.inspector = new Inspector( { traceNodeMaterialInvalidation: true } );
 				container.appendChild( renderer.domElement );
 
-				renderer.debug.onNodeMaterialInvalidation = function ( event ) {
-
-					addLog( event );
-					console.log( 'NodeMaterial needs rebuild', event );
-					showEvent( event );
-
-				};
-
 				controls = new OrbitControls( camera, renderer.domElement );
 				controls.enableDamping = true;
 				controls.target.set( 0, 1, 0 );
@@ -312,14 +153,10 @@
 				document.getElementById( 'transmissionButton' ).addEventListener( 'click', toggleTransmission );
 				document.getElementById( 'lightButton' ).addEventListener( 'click', toggleAccentLight );
 				autoDemoButton.addEventListener( 'click', toggleAutoDemo );
-				document.getElementById( 'clearLogButton' ).addEventListener( 'click', clearLog );
 
 				window.addEventListener( 'resize', onWindowResize );
 
-				addLog( 'Press a button or start the auto demo to trigger a node material rebuild.' );
-				addLog( 'Expected rebuild reasons include material.clearcoat, material.transmission or scene.lights.' );
-
-				updateStatus();
+				updateActions();
 
 			}
 
@@ -328,7 +165,7 @@
 				material.clearcoat = material.clearcoat === 0 ? 1 : 0;
 				material.needsUpdate = true;
 
-				updateStatus();
+				updateActions();
 
 			}
 
@@ -337,7 +174,7 @@
 				material.transmission = material.transmission === 0 ? 0.95 : 0;
 				material.needsUpdate = true;
 
-				updateStatus();
+				updateActions();
 
 			}
 
@@ -353,54 +190,19 @@
 
 				}
 
-				updateStatus();
+				updateActions();
 
 			}
 
-			function updateStatus() {
-
-				stateBarElement.innerHTML =
-					getBadgeHTML( 'clearcoat', material.clearcoat > 0 ) +
-					getBadgeHTML( 'transmission', material.transmission > 0 ) +
-					getBadgeHTML( 'point light', accentLight.parent !== null ) +
-					getBadgeHTML( 'auto demo', autoDemoInterval !== null );
+			function updateActions() {
 
-				statusElement.textContent = 'The banner and log update every time the debug callback reports a rebuild.';
+				document.getElementById( 'clearcoatButton' ).classList.toggle( 'active', material.clearcoat > 0 );
+				document.getElementById( 'transmissionButton' ).classList.toggle( 'active', material.transmission > 0 );
+				document.getElementById( 'lightButton' ).classList.toggle( 'active', accentLight.parent !== null );
 				autoDemoButton.classList.toggle( 'active', autoDemoInterval !== null );
 
 			}
 
-			function getBadgeHTML( label, active ) {
-
-				return `<span class="badge ${ active ? 'on' : '' }">${ label }: ${ active ? 'on' : 'off' }</span>`;
-
-			}
-
-			function getFeedbackMeta( property ) {
-
-				if ( property.startsWith( 'material.' ) ) return { color: 0x8ce0ff, cssColor: '#8ce0ff', label: 'Material rebuild' };
-				if ( property.startsWith( 'scene.' ) ) return { color: 0xffbe78, cssColor: '#ffbe78', label: 'Scene rebuild' };
-				if ( property.startsWith( 'renderer.' ) ) return { color: 0xff8fb1, cssColor: '#ff8fb1', label: 'Renderer rebuild' };
-
-				return { color: 0xffffff, cssColor: '#ffffff', label: 'Rebuild' };
-
-			}
-
-			function showEvent( event ) {
-
-				const feedback = getFeedbackMeta( event.property );
-
-				feedbackTime = performance.now();
-
-				eventBannerElement.style.setProperty( '--event-color', feedback.cssColor );
-				eventBannerReasonElement.textContent = event.property;
-				eventBannerValuesElement.textContent = `${ event.previousValue } -> ${ event.value }`;
-
-				recentEventElement.style.setProperty( '--recent-color', feedback.cssColor );
-				recentEventElement.innerHTML = `${ feedback.label }<br><span style="color:${ feedback.cssColor }">${ event.property }</span><br><span style="color:#d5deea">${ event.previousValue } -> ${ event.value }</span>`;
-
-			}
-
 			function toggleAutoDemo() {
 
 				if ( autoDemoInterval !== null ) {
@@ -424,43 +226,7 @@
 
 				}
 
-				updateStatus();
-
-			}
-
-			function addLog( event ) {
-
-				const entry = document.createElement( 'div' );
-				entry.className = 'log-entry';
-
-				if ( typeof event === 'string' ) {
-
-					entry.style.setProperty( '--entry-color', '#8ce0ff' );
-					entry.innerHTML = `<span class="time">[${ new Date().toLocaleTimeString() }]</span> <span class="values">${ event }</span>`;
-
-				} else {
-
-					const feedback = getFeedbackMeta( event.property );
-					entry.style.setProperty( '--entry-color', feedback.cssColor );
-					entry.innerHTML = `<span class="time">[${ new Date().toLocaleTimeString() }]</span> <span class="reason">${ event.property }</span><br><span class="values">${ event.previousValue } -> ${ event.value }</span>`;
-
-				}
-
-				logElement.prepend( entry );
-
-				while ( logElement.childElementCount > 8 ) {
-
-					logElement.lastElementChild.remove();
-
-				}
-
-			}
-
-			function clearLog() {
-
-				logElement.innerHTML = '';
-				recentEventElement.style.setProperty( '--recent-color', '#8ce0ff' );
-				recentEventElement.textContent = 'Waiting for the next rebuild event.';
+				updateActions();
 
 			}
 
@@ -475,21 +241,8 @@
 
 			function animate() {
 
-				const pulse = Math.max( 0, 1 - ( performance.now() - feedbackTime ) / 1400 );
-
 				sphere.rotation.y += 0.0035;
 
-				if ( pulse > 0 ) {
-
-					eventBannerElement.style.opacity = String( Math.min( 1, pulse * 2.1 ) );
-					eventBannerElement.style.transform = `translateY( ${ - 12 * ( 1 - pulse ) }px ) scale( ${ 1 - pulse * 0.02 } )`;
-
-				} else {
-
-					eventBannerElement.style.opacity = '0';
-					eventBannerElement.style.transform = 'translateY( -12px ) scale( 0.98 )';
-
-				}
 
 				controls.update();
 				renderer.render( scene, camera );
diff --git a/src/renderers/common/RenderObjects.js b/src/renderers/common/RenderObjects.js
index 8f338977543c6d..7ca860b80ca67a 100644
--- a/src/renderers/common/RenderObjects.js
+++ b/src/renderers/common/RenderObjects.js
@@ -90,7 +90,6 @@ class RenderObjects {
 	get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
-		const nodeMaterialDebug = this.renderer._getNodeMaterialDebug();
 
 		// set chain keys
 
@@ -129,8 +128,6 @@ class RenderObjects {
 
 				if ( renderObject.initialCacheKey !== renderObject.getCacheKey() ) {
 
-					if ( nodeMaterialDebug !== null ) nodeMaterialDebug.report( renderObject );
-
 					renderObject.dispose();
 
 					renderObject = this.get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId );
diff --git a/src/renderers/common/Renderer.js b/src/renderers/common/Renderer.js
index 30f11329ac260b..a8967b5afd005e 100644
--- a/src/renderers/common/Renderer.js
+++ b/src/renderers/common/Renderer.js
@@ -10,7 +10,6 @@ import RenderContexts from './RenderContexts.js';
 import Textures from './Textures.js';
 import Background from './Background.js';
 import NodeManager from './nodes/NodeManager.js';
-import NodeMaterialDebug from './NodeMaterialDebug.js';
 import Color4 from './Color4.js';
 import ClippingContext from './ClippingContext.js';
 import QuadMesh from './QuadMesh.js';
@@ -704,8 +703,6 @@ class Renderer {
 		 * @typedef {Object} DebugConfig
 		 * @property {boolean} checkShaderErrors - Whether shader errors should be checked or not.
 		 * @property {?Function} onShaderError - A callback function that is executed when a shader error happens. Only supported with WebGL 2 right now.
-		 * @property {boolean} traceNodeMaterialInvalidation - Whether node material invalidations that trigger render object cache misses should be reported.
-		 * @property {?Function} onNodeMaterialInvalidation - A callback function that receives node material invalidation data. Assigning a custom function disables default reporting.
 		 * @property {Function} getShaderAsync - Allows the get the raw shader code for the given scene, camera and 3D object.
 		 */
 
@@ -714,13 +711,9 @@ class Renderer {
 		 *
 		 * @type {DebugConfig}
 		 */
-		this._nodeMaterialDebug = null;
-
 		this.debug = {
 			checkShaderErrors: true,
 			onShaderError: null,
-			traceNodeMaterialInvalidation: false,
-			onNodeMaterialInvalidation: null,
 			getShaderAsync: async ( scene, camera, object ) => {
 
 				await this.compileAsync( scene, camera );
@@ -741,37 +734,6 @@ class Renderer {
 
 	}
 
-	/**
-	 * Returns the node material debug helper when the feature is enabled.
-	 *
-	 * @private
-	 * @return {?NodeMaterialDebug} The debug helper.
-	 */
-	_getNodeMaterialDebug() {
-
-		const debug = this.debug;
-		let nodeMaterialDebug = this._nodeMaterialDebug;
-
-		if ( debug.traceNodeMaterialInvalidation === true || typeof debug.onNodeMaterialInvalidation === 'function' ) {
-
-			if ( nodeMaterialDebug === null ) {
-
-				nodeMaterialDebug = new NodeMaterialDebug( this );
-				this._nodeMaterialDebug = nodeMaterialDebug;
-
-			}
-
-		} else if ( nodeMaterialDebug !== null ) {
-
-			this._nodeMaterialDebug = null;
-			nodeMaterialDebug = null;
-
-		}
-
-		return nodeMaterialDebug;
-
-	}
-
 	/**
 	 * Initializes the renderer so it is ready for usage.
 	 *

From dbf880c766821e6db08ad9f784caee66387e5c87 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:21:00 +0900
Subject: [PATCH 06/19] Remove RenderObjects debug tests

---
 src/renderers/common/RenderObjects.js         |   2 -
 .../unit/src/renderers/RenderObjects.tests.js | 190 ------------------
 2 files changed, 192 deletions(-)
 delete mode 100644 test/unit/src/renderers/RenderObjects.tests.js

diff --git a/src/renderers/common/RenderObjects.js b/src/renderers/common/RenderObjects.js
index 7ca860b80ca67a..676cc2bd416942 100644
--- a/src/renderers/common/RenderObjects.js
+++ b/src/renderers/common/RenderObjects.js
@@ -151,8 +151,6 @@ class RenderObjects {
 
 		//
 
-		if ( nodeMaterialDebug !== null ) nodeMaterialDebug.update( renderObject );
-
 		return renderObject;
 
 	}
diff --git a/test/unit/src/renderers/RenderObjects.tests.js b/test/unit/src/renderers/RenderObjects.tests.js
deleted file mode 100644
index c2b97e7876ad94..00000000000000
--- a/test/unit/src/renderers/RenderObjects.tests.js
+++ /dev/null
@@ -1,190 +0,0 @@
-import RenderObjects from '../../../../src/renderers/common/RenderObjects.js';
-import NodeMaterialDebug from '../../../../src/renderers/common/NodeMaterialDebug.js';
-import { BufferGeometry } from '../../../../src/core/BufferGeometry.js';
-import { MeshBasicMaterial } from '../../../../src/materials/MeshBasicMaterial.js';
-import { PerspectiveCamera } from '../../../../src/cameras/PerspectiveCamera.js';
-import { Mesh } from '../../../../src/objects/Mesh.js';
-import { Scene } from '../../../../src/scenes/Scene.js';
-
-function createRenderer( events ) {
-
-	const renderer = {
-		backend: { isWebGPUBackend: false },
-		contextNode: { id: 1, version: 0 },
-		shadowMap: { enabled: false, type: 1 },
-		debug: {
-			traceNodeMaterialInvalidation: false,
-			onNodeMaterialInvalidation: events ? ( event ) => events.push( event ) : null
-		},
-		getOutputRenderTarget() {
-
-			return null;
-
-		}
-	};
-
-	renderer._nodeMaterialDebug = events ? new NodeMaterialDebug( renderer ) : null;
-	renderer._getNodeMaterialDebug = () => renderer._nodeMaterialDebug;
-
-	return renderer;
-
-}
-
-function createNodes() {
-
-	return {
-		getCacheKey: () => 0,
-		getEnvironmentNode: () => null,
-		getFogNode: () => null,
-		delete: () => {}
-	};
-
-}
-
-function createRenderObjects( events, nodes = createNodes() ) {
-
-	return new RenderObjects(
-		createRenderer( events ),
-		nodes,
-		{},
-		{ delete: () => {} },
-		{ deleteForRender: () => {} },
-		{}
-	);
-
-}
-
-function createState() {
-
-	const material = new MeshBasicMaterial();
-	const object = new Mesh( new BufferGeometry(), material );
-	const scene = new Scene();
-	const camera = new PerspectiveCamera();
-	const lights = [];
-	const lightsNode = {
-		getLights() {
-
-			return lights;
-
-		},
-		getCacheKey() {
-
-			return lights.map( ( light ) => `${ light.type }:${ light.id }:${ light.castShadow === true ? 1 : 0 }` ).join( '|' );
-
-		}
-	};
-
-	return {
-		object,
-		material,
-		scene,
-		camera,
-		lights,
-		lightsNode,
-		renderContext: { id: 1 },
-		clippingContext: { cacheKey: '' }
-	};
-
-}
-
-export default QUnit.module( 'Renderers', () => {
-
-	QUnit.module( 'RenderObjects', () => {
-
-		QUnit.test( 'reports the cache contributor that invalidates a node material', ( assert ) => {
-
-			const events = [];
-			const renderObjects = createRenderObjects( events );
-			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
-
-			material.name = 'DebugMaterial';
-
-			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			material.transparent = true;
-			material.needsUpdate = true;
-
-			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated after the cache miss.' );
-			assert.strictEqual( events.length, 1, 'One invalidation event was reported.' );
-			assert.strictEqual( events[ 0 ].material, material, 'The event exposes the invalidated material.' );
-			assert.strictEqual( events[ 0 ].materialLabel, 'DebugMaterial', 'The material label prefers material.name.' );
-			assert.strictEqual( events[ 0 ].property, 'material.transparent', 'The changed cache contributor is reported.' );
-			assert.strictEqual( events[ 0 ].previousValue, 'false', 'The previous contributor value is reported.' );
-			assert.strictEqual( events[ 0 ].value, 'true', 'The next contributor value is reported.' );
-			assert.strictEqual( events[ 0 ].rebuild, true, 'The event identifies the render object rebuild.' );
-			assert.strictEqual( events[ 0 ].needsRefresh, true, 'The event identifies the forced refresh.' );
-
-		} );
-
-		QUnit.test( 'reports dynamic cache invalidations with readable light changes', ( assert ) => {
-
-			let nodeCacheKey = 1;
-
-			const nodes = {
-				getCacheKey: () => nodeCacheKey,
-				getEnvironmentNode: () => null,
-				getFogNode: () => null,
-				delete: () => {}
-			};
-
-			const events = [];
-			const renderObjects = createRenderObjects( events, nodes );
-			const { object, material, scene, camera, lights, lightsNode, renderContext, clippingContext } = createState();
-
-			lights.push( { type: 'HemisphereLight', id: 1, castShadow: false } );
-			lights.push( { type: 'DirectionalLight', id: 2, castShadow: true } );
-
-			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			lights.push( { type: 'PointLight', id: 3, castShadow: false } );
-			nodeCacheKey = 2;
-
-			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated after the dynamic cache changes.' );
-			assert.strictEqual( events.length, 1, 'One invalidation event was reported.' );
-			assert.strictEqual( events[ 0 ].property, 'scene.lights', 'The report points to the light setup instead of an opaque hash.' );
-			assert.strictEqual( events[ 0 ].previousValue, '2 lights [HemisphereLight#1, DirectionalLight#2 shadow]', 'The previous light setup is human readable.' );
-			assert.strictEqual( events[ 0 ].value, '3 lights [HemisphereLight#1, DirectionalLight#2 shadow, PointLight#3]', 'The next light setup is human readable.' );
-
-		} );
-
-		QUnit.test( 'ignores material changes that do not affect the render object cache', ( assert ) => {
-
-			const events = [];
-			const renderObjects = createRenderObjects( events );
-			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
-
-			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			material.opacity = 0.25;
-			material.needsUpdate = true;
-
-			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			assert.strictEqual( refreshedRenderObject, initialRenderObject, 'The existing render object is reused when the cache key stays stable.' );
-			assert.strictEqual( events.length, 0, 'No invalidation event is reported for cache-stable changes.' );
-
-		} );
-
-		QUnit.test( 'works without node material debug enabled', ( assert ) => {
-
-			const renderObjects = createRenderObjects( null );
-			const { object, material, scene, camera, lightsNode, renderContext, clippingContext } = createState();
-
-			const initialRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			material.transparent = true;
-			material.needsUpdate = true;
-
-			const refreshedRenderObject = renderObjects.get( object, material, scene, camera, lightsNode, renderContext, clippingContext );
-
-			assert.notStrictEqual( refreshedRenderObject, initialRenderObject, 'The render object is recreated without requiring debug support.' );
-
-		} );
-
-	} );
-
-} );

From 7259596a3064281e287695114e70404fac8bd8fa Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:28:18 +0900
Subject: [PATCH 07/19] Fix analyzer CodeQL warnings

---
 .../inspector/NodeMaterialDebugAnalyzer.js    | 24 -------------------
 1 file changed, 24 deletions(-)

diff --git a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 3c11107dfc5daf..0b169f420981b0 100644
--- a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -280,8 +280,6 @@ function getLightValue( light ) {
 
 function getLightsValue( lightsNode ) {
 
-	if ( lightsNode === null ) return '0 lights';
-
 	const lights = lightsNode.getLights().slice().sort( ( a, b ) => a.id - b.id );
 	const values = lights.map( getLightValue );
 	const label = `${ lights.length } light${ lights.length === 1 ? '' : 's' }`;
@@ -800,28 +798,6 @@ class NodeMaterialDebugAnalyzer {
 		const currentDynamic = () => dynamic || ( dynamic = getDynamicCacheKeyComponents( renderObject ) );
 		const currentDynamicCacheKey = () => dynamicCacheKey || ( dynamicCacheKey = String( renderObject.getDynamicCacheKey() ) );
 		const currentNodesCacheKey = () => nodesCacheKey || ( nodesCacheKey = getNodesCacheKey( renderObject ) );
-		const createCurrentData = () => {
-
-			const data = {
-				version: renderObject.version,
-				geometryId: renderObject.geometry !== null ? renderObject.geometry.id : null,
-				clippingContextCacheKey: renderObject.clippingContextCacheKey,
-				material: currentMaterial(),
-				dynamic: currentDynamic(),
-				dynamicCacheKey: currentDynamicCacheKey(),
-				nodesCacheKey: currentNodesCacheKey()
-			};
-
-			if ( previousData.materialNodes !== undefined ) {
-
-				data.materialNodes = previousData.materialNodesTrace === true ? currentTraceMaterialNodes() : currentMaterialNodes();
-				data.materialNodesTrace = previousData.materialNodesTrace;
-
-			}
-
-			return data;
-
-		};
 
 		const materialCacheDifference = getCacheKeyDifference(
 			previousData.material,

From 1fce173a280bb59b8d79acb09120667082dd2401 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:39:49 +0900
Subject: [PATCH 08/19] Report updateBefore material rebuilds

---
 examples/jsm/inspector/NodeMaterialDebug.js | 48 ++++++++++++++++++++-
 1 file changed, 46 insertions(+), 2 deletions(-)

diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
index e4314f70420bfc..5e22e1949d3abb 100644
--- a/examples/jsm/inspector/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -10,6 +10,8 @@ class NodeMaterialDebug {
 
 		this._objects = null;
 		this._originalGet = null;
+		this._nodes = null;
+		this._originalUpdateBefore = null;
 
 		this.updateRenderer();
 
@@ -18,11 +20,22 @@ class NodeMaterialDebug {
 	updateRenderer() {
 
 		const renderObjects = this.renderer._objects;
+		const nodes = this.renderer._nodes;
 
-		if ( renderObjects === null || renderObjects === undefined || this._objects === renderObjects ) return this;
+		if ( renderObjects === null || renderObjects === undefined || nodes === null || nodes === undefined ) return this;
+		if ( this._objects === renderObjects && this._nodes === nodes ) return this;
 
 		this.dispose();
 
+		this._patchRenderObjects( renderObjects );
+		this._patchNodeManager( nodes );
+
+		return this;
+
+	}
+
+	_patchRenderObjects( renderObjects ) {
+
 		const originalGet = renderObjects.get;
 		const nodeMaterialDebug = this;
 
@@ -57,7 +70,29 @@ class NodeMaterialDebug {
 		this._objects = renderObjects;
 		this._originalGet = originalGet;
 
-		return this;
+	}
+
+	_patchNodeManager( nodes ) {
+
+		const originalUpdateBefore = nodes.updateBefore;
+		const nodeMaterialDebug = this;
+
+		nodes.updateBefore = function ( renderObject ) {
+
+			const previousCacheKey = renderObject.getCacheKey();
+
+			originalUpdateBefore.call( this, renderObject );
+
+			if ( previousCacheKey !== renderObject.getCacheKey() ) {
+
+				nodeMaterialDebug.report( renderObject );
+
+			}
+
+		};
+
+		this._nodes = nodes;
+		this._originalUpdateBefore = originalUpdateBefore;
 
 	}
 
@@ -72,6 +107,7 @@ class NodeMaterialDebug {
 		};
 
 		this.analyzer.report( renderObject );
+		this.analyzer.update( renderObject );
 		this.analyzer.onNodeMaterialInvalidation = previousCallback;
 
 	}
@@ -84,8 +120,16 @@ class NodeMaterialDebug {
 
 		}
 
+		if ( this._nodes !== null && this._originalUpdateBefore !== null ) {
+
+			this._nodes.updateBefore = this._originalUpdateBefore;
+
+		}
+
 		this._objects = null;
 		this._originalGet = null;
+		this._nodes = null;
+		this._originalUpdateBefore = null;
 
 	}
 

From 3358050de0fd41f911d1cadbd12f4999326ad4a1 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:42:07 +0900
Subject: [PATCH 09/19] Add node rebuild trigger example

---
 examples/webgpu_materials_debug_rebuild.html | 57 ++++++++++++++++++--
 1 file changed, 54 insertions(+), 3 deletions(-)

diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index 35ee25677036f6..5ecd8d202642df 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -65,6 +65,7 @@
 		<div id="actions">
 			<button id="clearcoatButton">Clearcoat</button>
 			<button id="transmissionButton">Transmission</button>
+			<button id="nodeButton">Node</button>
 			<button id="lightButton">Point Light</button>
 			<button id="autoDemoButton">Auto Demo</button>
 		</div>
@@ -84,12 +85,51 @@
 		<script type="module">
 
 			import * as THREE from 'three/webgpu';
+			import { color, NodeUpdateType } from 'three/tsl';
 
 			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 			import { Inspector } from 'three/addons/inspector/Inspector.js';
 
+			class RebuildColorNode extends THREE.Node {
+
+				constructor() {
+
+					super( 'color' );
+
+					this.enabled = false;
+					this.pendingUpdate = false;
+					this.updateBeforeType = NodeUpdateType.RENDER;
+
+				}
+
+				customCacheKey() {
+
+					return this.enabled === true ? 1 : 0;
+
+				}
+
+				updateBefore() {
+
+					if ( this.pendingUpdate === false ) return false;
+
+					this.pendingUpdate = false;
+					this.enabled = ! this.enabled;
+					this.needsUpdate = true;
+
+				}
+
+				generate( builder, output ) {
+
+					const value = this.enabled === true ? color( 0xff8f40 ) : color( 0x8aa4ff );
+
+					return value.build( builder, output );
+
+				}
+
+			}
+
 			let camera, scene, renderer, controls;
-			let material, accentLight, sphere;
+			let material, accentLight, sphere, rebuildColorNode;
 			let autoDemoInterval = null;
 			let autoDemoStep = 0;
 
@@ -134,7 +174,6 @@
 				scene.add( floor );
 
 				material = new THREE.MeshPhysicalMaterial( {
-					color: 0x8aa4ff,
 					roughness: 0.12,
 					metalness: 0.05,
 					clearcoat: 0,
@@ -144,6 +183,8 @@
 					ior: 1.5
 				} );
 				material.name = 'DebugPhysicalMaterial';
+				rebuildColorNode = new RebuildColorNode();
+				material.colorNode = rebuildColorNode;
 
 				sphere = new THREE.Mesh( new THREE.SphereGeometry( 1, 64, 32 ), material );
 				sphere.position.y = 1;
@@ -151,6 +192,7 @@
 
 				document.getElementById( 'clearcoatButton' ).addEventListener( 'click', toggleClearcoat );
 				document.getElementById( 'transmissionButton' ).addEventListener( 'click', toggleTransmission );
+				document.getElementById( 'nodeButton' ).addEventListener( 'click', toggleNode );
 				document.getElementById( 'lightButton' ).addEventListener( 'click', toggleAccentLight );
 				autoDemoButton.addEventListener( 'click', toggleAutoDemo );
 
@@ -194,10 +236,19 @@
 
 			}
 
+			function toggleNode() {
+
+				rebuildColorNode.pendingUpdate = true;
+
+				updateActions();
+
+			}
+
 			function updateActions() {
 
 				document.getElementById( 'clearcoatButton' ).classList.toggle( 'active', material.clearcoat > 0 );
 				document.getElementById( 'transmissionButton' ).classList.toggle( 'active', material.transmission > 0 );
+				document.getElementById( 'nodeButton' ).classList.toggle( 'active', rebuildColorNode.enabled || rebuildColorNode.pendingUpdate );
 				document.getElementById( 'lightButton' ).classList.toggle( 'active', accentLight.parent !== null );
 				autoDemoButton.classList.toggle( 'active', autoDemoInterval !== null );
 
@@ -212,7 +263,7 @@
 
 				} else {
 
-					const actions = [ toggleClearcoat, toggleTransmission, toggleAccentLight ];
+					const actions = [ toggleClearcoat, toggleTransmission, toggleNode, toggleAccentLight ];
 
 					actions[ autoDemoStep % actions.length ]();
 					autoDemoStep ++;

From 8df6ee9acbbe8221ee61a54a13ae9a04b1ea1396 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:43:07 +0900
Subject: [PATCH 10/19] Report undiffed node cache rebuilds

---
 .../jsm/inspector/NodeMaterialDebugAnalyzer.js   | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 0b169f420981b0..3205a1272bf01d 100644
--- a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -888,8 +888,24 @@ class NodeMaterialDebugAnalyzer {
 				renderObject
 			} );
 
+			return;
+
 		}
 
+		const previousCustomProgramCacheKey = previousData.material.find( ( component ) => component.property === 'material.customProgramCacheKey' );
+		const currentCustomProgramCacheKey = currentMaterial().find( ( component ) => component.property === 'material.customProgramCacheKey' );
+
+		this._dispatch( {
+			stage: 'node-cache',
+			property: 'material.customProgramCacheKey',
+			previousValue: previousCustomProgramCacheKey ? previousCustomProgramCacheKey.value : previousData.materialCacheKey,
+			value: currentCustomProgramCacheKey ? currentCustomProgramCacheKey.value : renderObject.getMaterialCacheKey(),
+			rebuild: true,
+			needsRefresh: true,
+			material: renderObject.material,
+			renderObject
+		} );
+
 	}
 
 	_dispatch( data ) {

From 3166024b1a6139d1595dbb8c931554ba0f26a9eb Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:44:09 +0900
Subject: [PATCH 11/19] Make node rebuild trigger per object

---
 examples/webgpu_materials_debug_rebuild.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index 5ecd8d202642df..d00b210c8174fb 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -98,7 +98,7 @@
 
 					this.enabled = false;
 					this.pendingUpdate = false;
-					this.updateBeforeType = NodeUpdateType.RENDER;
+					this.updateBeforeType = NodeUpdateType.OBJECT;
 
 				}
 

From fb1656c157f5cce112f925339e3c7d6cd03f3373 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:44:32 +0900
Subject: [PATCH 12/19] Fix node toggle state in debug example

---
 examples/webgpu_materials_debug_rebuild.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index d00b210c8174fb..d787a60525b942 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -113,7 +113,6 @@
 					if ( this.pendingUpdate === false ) return false;
 
 					this.pendingUpdate = false;
-					this.enabled = ! this.enabled;
 					this.needsUpdate = true;
 
 				}
@@ -238,6 +237,7 @@
 
 			function toggleNode() {
 
+				rebuildColorNode.enabled = ! rebuildColorNode.enabled;
 				rebuildColorNode.pendingUpdate = true;
 
 				updateActions();
@@ -248,7 +248,7 @@
 
 				document.getElementById( 'clearcoatButton' ).classList.toggle( 'active', material.clearcoat > 0 );
 				document.getElementById( 'transmissionButton' ).classList.toggle( 'active', material.transmission > 0 );
-				document.getElementById( 'nodeButton' ).classList.toggle( 'active', rebuildColorNode.enabled || rebuildColorNode.pendingUpdate );
+				document.getElementById( 'nodeButton' ).classList.toggle( 'active', rebuildColorNode.enabled );
 				document.getElementById( 'lightButton' ).classList.toggle( 'active', accentLight.parent !== null );
 				autoDemoButton.classList.toggle( 'active', autoDemoInterval !== null );
 

From af002f2aeef127fc0103643bcb27de1fc04ae1fa Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:45:41 +0900
Subject: [PATCH 13/19] Use updateBefore event for node rebuild example

---
 examples/webgpu_materials_debug_rebuild.html | 34 +++++++++++---------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index d787a60525b942..901b122f19bd3e 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -85,7 +85,7 @@
 		<script type="module">
 
 			import * as THREE from 'three/webgpu';
-			import { color, NodeUpdateType } from 'three/tsl';
+			import { Fn, OnBeforeObjectUpdate, color } from 'three/tsl';
 
 			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 			import { Inspector } from 'three/addons/inspector/Inspector.js';
@@ -97,8 +97,6 @@
 					super( 'color' );
 
 					this.enabled = false;
-					this.pendingUpdate = false;
-					this.updateBeforeType = NodeUpdateType.OBJECT;
 
 				}
 
@@ -108,15 +106,6 @@
 
 				}
 
-				updateBefore() {
-
-					if ( this.pendingUpdate === false ) return false;
-
-					this.pendingUpdate = false;
-					this.needsUpdate = true;
-
-				}
-
 				generate( builder, output ) {
 
 					const value = this.enabled === true ? color( 0xff8f40 ) : color( 0x8aa4ff );
@@ -128,7 +117,7 @@
 			}
 
 			let camera, scene, renderer, controls;
-			let material, accentLight, sphere, rebuildColorNode;
+			let material, accentLight, sphere, rebuildColorNode, nodeUpdatePending;
 			let autoDemoInterval = null;
 			let autoDemoStep = 0;
 
@@ -183,7 +172,22 @@
 				} );
 				material.name = 'DebugPhysicalMaterial';
 				rebuildColorNode = new RebuildColorNode();
-				material.colorNode = rebuildColorNode;
+				nodeUpdatePending = false;
+				material.colorNode = Fn( () => {
+
+					OnBeforeObjectUpdate( () => {
+
+						if ( nodeUpdatePending === false ) return false;
+
+						nodeUpdatePending = false;
+						rebuildColorNode.needsUpdate = true;
+						updateActions();
+
+					} );
+
+					return rebuildColorNode;
+
+				} )();
 
 				sphere = new THREE.Mesh( new THREE.SphereGeometry( 1, 64, 32 ), material );
 				sphere.position.y = 1;
@@ -238,7 +242,7 @@
 			function toggleNode() {
 
 				rebuildColorNode.enabled = ! rebuildColorNode.enabled;
-				rebuildColorNode.pendingUpdate = true;
+				nodeUpdatePending = true;
 
 				updateActions();
 

From 3e08277b611ac78d1d9d84fc0d66e28869b3f6e5 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:51:59 +0900
Subject: [PATCH 14/19] Improve node rebuild debug logging

---
 examples/jsm/inspector/Inspector.js           |  3 +-
 examples/jsm/inspector/NodeMaterialDebug.js   | 51 +++++++++++++------
 .../inspector/NodeMaterialDebugAnalyzer.js    |  8 +++
 examples/webgpu_materials_debug_rebuild.html  | 26 +++-------
 4 files changed, 51 insertions(+), 37 deletions(-)

diff --git a/examples/jsm/inspector/Inspector.js b/examples/jsm/inspector/Inspector.js
index 74e169f6fbf5ae..b6c89cbce9a5f8 100644
--- a/examples/jsm/inspector/Inspector.js
+++ b/examples/jsm/inspector/Inspector.js
@@ -330,11 +330,12 @@ class Inspector extends RendererInspector {
 			if ( this.nodeMaterialDebug === null ) this.nodeMaterialDebug = new NodeMaterialDebug( renderer );
 			this.nodeMaterialDebug.onNodeMaterialInvalidation = ( event ) => {
 
+				const materialLabel = event.materialLabel || ( event.material ? event.material.name || event.material.type : 'unknown material' );
 				const property = event.property !== undefined ? ` via ${ event.property }` : '';
 				const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
 				const source = event.sourceProperty !== undefined && event.sourceProperty !== event.property ? ` [${ event.sourceProperty }]` : '';
 
-				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ event.materialLabel }"${ property }${ values }${ source }.` );
+				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }${ source }.` );
 
 				if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
 
diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
index 5e22e1949d3abb..b3b7ead035505a 100644
--- a/examples/jsm/inspector/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -11,7 +11,7 @@ class NodeMaterialDebug {
 		this._objects = null;
 		this._originalGet = null;
 		this._nodes = null;
-		this._originalUpdateBefore = null;
+		this._originalNeedsRefresh = null;
 
 		this.updateRenderer();
 
@@ -74,37 +74,50 @@ class NodeMaterialDebug {
 
 	_patchNodeManager( nodes ) {
 
-		const originalUpdateBefore = nodes.updateBefore;
+		const originalNeedsRefresh = nodes.needsRefresh;
 		const nodeMaterialDebug = this;
 
-		nodes.updateBefore = function ( renderObject ) {
+		nodes.needsRefresh = function ( renderObject ) {
 
 			const previousCacheKey = renderObject.getCacheKey();
+			const needsRefresh = originalNeedsRefresh.call( this, renderObject );
+			const cacheKey = renderObject.getCacheKey();
 
-			originalUpdateBefore.call( this, renderObject );
+			if ( needsRefresh === true && previousCacheKey !== cacheKey ) {
 
-			if ( previousCacheKey !== renderObject.getCacheKey() ) {
-
-				nodeMaterialDebug.report( renderObject );
+				nodeMaterialDebug.reportRefresh( renderObject, previousCacheKey, cacheKey );
 
 			}
 
+			return needsRefresh;
+
 		};
 
 		this._nodes = nodes;
-		this._originalUpdateBefore = originalUpdateBefore;
+		this._originalNeedsRefresh = originalNeedsRefresh;
 
 	}
 
-	report( renderObject ) {
+	reportRefresh( renderObject, previousCacheKey, cacheKey ) {
 
-		const previousCallback = this.analyzer.onNodeMaterialInvalidation;
+		this.dispatch( {
+			stage: 'node-refresh',
+			property: 'NodeMaterialObserver.needsRefresh',
+			previousValue: String( previousCacheKey ),
+			value: String( cacheKey ),
+			rebuild: false,
+			needsRefresh: true,
+			material: renderObject.material,
+			renderObject
+		} );
 
-		this.analyzer.onNodeMaterialInvalidation = ( event ) => {
+	}
 
-			if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
+	report( renderObject ) {
 
-		};
+		const previousCallback = this.analyzer.onNodeMaterialInvalidation;
+
+		this.analyzer.onNodeMaterialInvalidation = ( event ) => this.dispatch( event );
 
 		this.analyzer.report( renderObject );
 		this.analyzer.update( renderObject );
@@ -112,6 +125,12 @@ class NodeMaterialDebug {
 
 	}
 
+	dispatch( event ) {
+
+		if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
+
+	}
+
 	dispose() {
 
 		if ( this._objects !== null && this._originalGet !== null ) {
@@ -120,16 +139,16 @@ class NodeMaterialDebug {
 
 		}
 
-		if ( this._nodes !== null && this._originalUpdateBefore !== null ) {
+		if ( this._nodes !== null && this._originalNeedsRefresh !== null ) {
 
-			this._nodes.updateBefore = this._originalUpdateBefore;
+			this._nodes.needsRefresh = this._originalNeedsRefresh;
 
 		}
 
 		this._objects = null;
 		this._originalGet = null;
 		this._nodes = null;
-		this._originalUpdateBefore = null;
+		this._originalNeedsRefresh = null;
 
 	}
 
diff --git a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 3205a1272bf01d..5239e4a36e5346 100644
--- a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -111,6 +111,14 @@ function getNodeCustomCacheStateComponents( node, path ) {
 			value: String( toneMapping )
 		} );
 
+	} else if ( Object.prototype.hasOwnProperty.call( node, 'enabled' ) && typeof node.enabled === 'boolean' ) {
+
+		cacheKeyComponents.push( {
+			property: `${ path }.enabled`,
+			valueKey: String( node.enabled ),
+			value: node.enabled ? 'enabled' : 'disabled'
+		} );
+
 	} else if ( node.isPropertyNode === true ) {
 
 		cacheKeyComponents.push( {
diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index 901b122f19bd3e..6b696a9b684ec2 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -85,7 +85,7 @@
 		<script type="module">
 
 			import * as THREE from 'three/webgpu';
-			import { Fn, OnBeforeObjectUpdate, color } from 'three/tsl';
+			import { color } from 'three/tsl';
 
 			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 			import { Inspector } from 'three/addons/inspector/Inspector.js';
@@ -117,7 +117,7 @@
 			}
 
 			let camera, scene, renderer, controls;
-			let material, accentLight, sphere, rebuildColorNode, nodeUpdatePending;
+			let material, accentLight, sphere, rebuildColorNode;
 			let autoDemoInterval = null;
 			let autoDemoStep = 0;
 
@@ -161,7 +161,7 @@
 				floor.position.y = - 0.15;
 				scene.add( floor );
 
-				material = new THREE.MeshPhysicalMaterial( {
+				material = new THREE.MeshPhysicalNodeMaterial( {
 					roughness: 0.12,
 					metalness: 0.05,
 					clearcoat: 0,
@@ -172,22 +172,7 @@
 				} );
 				material.name = 'DebugPhysicalMaterial';
 				rebuildColorNode = new RebuildColorNode();
-				nodeUpdatePending = false;
-				material.colorNode = Fn( () => {
-
-					OnBeforeObjectUpdate( () => {
-
-						if ( nodeUpdatePending === false ) return false;
-
-						nodeUpdatePending = false;
-						rebuildColorNode.needsUpdate = true;
-						updateActions();
-
-					} );
-
-					return rebuildColorNode;
-
-				} )();
+				material.colorNode = rebuildColorNode;
 
 				sphere = new THREE.Mesh( new THREE.SphereGeometry( 1, 64, 32 ), material );
 				sphere.position.y = 1;
@@ -242,7 +227,8 @@
 			function toggleNode() {
 
 				rebuildColorNode.enabled = ! rebuildColorNode.enabled;
-				nodeUpdatePending = true;
+				rebuildColorNode.needsUpdate = true;
+				material.needsUpdate = true;
 
 				updateActions();
 

From fd6b404e5815665dbaccf083d74f4bcc5c1fa97b Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 11:54:43 +0900
Subject: [PATCH 15/19] Update materials debug rebuild screenshot

---
 .../webgpu_materials_debug_rebuild.jpg        | Bin 20834 -> 8090 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/examples/screenshots/webgpu_materials_debug_rebuild.jpg b/examples/screenshots/webgpu_materials_debug_rebuild.jpg
index 8c529c6a76d27d1772e7acd389fc48bc14b8d701..82674e6b37168283578892ef13327469392d56a3 100644
GIT binary patch
delta 3483
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
Fe*iC-r*QxP

delta 16924
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
VOnOyc<D2^9q)vPb0?5_;{{q-LH&Orq


From 3683a603558cf47d31f19bd125ccc774a7b3c327 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 15:03:54 +0900
Subject: [PATCH 16/19] Improve node material rebuild diagnostics

---
 examples/jsm/inspector/Inspector.js         | 38 +++++++++----
 examples/jsm/inspector/NodeMaterialDebug.js | 55 +++++++++++++++++++
 examples/jsm/inspector/tabs/Console.js      | 27 ++++++----
 examples/jsm/inspector/tabs/Settings.js     | 13 ++++-
 src/renderers/common/InspectorBase.js       | 14 +++++
 src/renderers/common/nodes/NodeManager.js   | 59 +++++++++++++++++++++
 6 files changed, 187 insertions(+), 19 deletions(-)

diff --git a/examples/jsm/inspector/Inspector.js b/examples/jsm/inspector/Inspector.js
index b6c89cbce9a5f8..34d4a63eb76537 100644
--- a/examples/jsm/inspector/Inspector.js
+++ b/examples/jsm/inspector/Inspector.js
@@ -44,10 +44,10 @@ class Inspector extends RendererInspector {
 		const timeline = new Timeline();
 		profiler.addTab( timeline );
 
-		const consoleTab = new Console( { traceNodeMaterialInvalidation: options.traceNodeMaterialInvalidation } );
-		consoleTab.addEventListener( 'trace-node-material-invalidation', ( event ) => {
+		const consoleTab = new Console( { nodeMaterialDebugEnabled: options.nodeMaterialDebugEnabled } );
+		consoleTab.addEventListener( 'node-material-debug', ( event ) => {
 
-			this.setTraceNodeMaterialInvalidation( event.enabled );
+			this.setNodeMaterialDebug( event.enabled );
 
 		} );
 		profiler.addTab( consoleTab );
@@ -76,7 +76,7 @@ class Inspector extends RendererInspector {
 		this.extensionsData = new WeakMap();
 		this.nodeMaterialDebug = null;
 		this.onNodeMaterialInvalidation = null;
-		this.traceNodeMaterialInvalidation = options.traceNodeMaterialInvalidation === true;
+		this.nodeMaterialDebugEnabled = consoleTab.nodeMaterialDebugEnabled === true;
 
 		this.displayCycle = {
 			text: {
@@ -284,7 +284,7 @@ class Inspector extends RendererInspector {
 		if ( renderer !== null ) {
 
 			setConsoleFunction( this.resolveConsole.bind( this ) );
-			this.setTraceNodeMaterialInvalidation( this.traceNodeMaterialInvalidation );
+			this.setNodeMaterialDebug( this.nodeMaterialDebugEnabled );
 
 			if ( this.isAvailable ) {
 
@@ -311,6 +311,22 @@ class Inspector extends RendererInspector {
 
 	}
 
+	beginNodeBuild( info ) {
+
+		super.beginNodeBuild( info );
+
+		if ( this.nodeMaterialDebug !== null ) this.nodeMaterialDebug.updatePendingBuildInfo( info );
+
+	}
+
+	finishNodeBuild( info ) {
+
+		super.finishNodeBuild( info );
+
+		if ( this.nodeMaterialDebug !== null ) this.nodeMaterialDebug.flushPendingInvalidations( info );
+
+	}
+
 	updateNodeMaterialDebug() {
 
 		if ( this.nodeMaterialDebug !== null ) this.nodeMaterialDebug.updateRenderer();
@@ -319,27 +335,31 @@ class Inspector extends RendererInspector {
 
 	}
 
-	setTraceNodeMaterialInvalidation( enabled ) {
+	setNodeMaterialDebug( enabled ) {
 
-		this.traceNodeMaterialInvalidation = enabled === true;
+		this.nodeMaterialDebugEnabled = enabled === true;
 
 		const renderer = this.getRenderer();
 
-		if ( this.traceNodeMaterialInvalidation === true && renderer !== null ) {
+		if ( this.nodeMaterialDebugEnabled === true && renderer !== null ) {
 
 			if ( this.nodeMaterialDebug === null ) this.nodeMaterialDebug = new NodeMaterialDebug( renderer );
 			this.nodeMaterialDebug.onNodeMaterialInvalidation = ( event ) => {
 
 				const materialLabel = event.materialLabel || ( event.material ? event.material.name || event.material.type : 'unknown material' );
+
 				const property = event.property !== undefined ? ` via ${ event.property }` : '';
 				const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
 				const source = event.sourceProperty !== undefined && event.sourceProperty !== event.property ? ` [${ event.sourceProperty }]` : '';
+				const buildInfo = event.buildInfo;
+				const timing = buildInfo && buildInfo.durationMs !== undefined ? ` in <strong>${ buildInfo.durationMs.toFixed( 3 ) } ms</strong>` : '';
 
-				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }${ source }.` );
+				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }${ source }${ timing }.` );
 
 				if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
 
 			};
+
 			this.nodeMaterialDebug.updateRenderer();
 
 		} else if ( this.nodeMaterialDebug !== null ) {
diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
index b3b7ead035505a..2b85eb7648ac3c 100644
--- a/examples/jsm/inspector/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -12,6 +12,7 @@ class NodeMaterialDebug {
 		this._originalGet = null;
 		this._nodes = null;
 		this._originalNeedsRefresh = null;
+		this._pendingInvalidations = new WeakMap();
 
 		this.updateRenderer();
 
@@ -125,8 +126,61 @@ class NodeMaterialDebug {
 
 	}
 
+	updatePendingBuildInfo( info ) {
+
+		const pendingInvalidations = this._pendingInvalidations.get( info.material );
+
+		if ( pendingInvalidations !== undefined ) {
+
+			for ( const event of pendingInvalidations ) {
+
+				event.buildInfo = info;
+
+			}
+
+		}
+
+	}
+
+	flushPendingInvalidations( info ) {
+
+		const material = info.material;
+		const pendingInvalidations = this._pendingInvalidations.get( material );
+
+		if ( pendingInvalidations !== undefined ) {
+
+			this._pendingInvalidations.delete( material );
+
+			for ( const event of pendingInvalidations ) {
+
+				event.buildInfo = info;
+				this.dispatch( event );
+
+			}
+
+		}
+
+	}
+
 	dispatch( event ) {
 
+		if ( event.rebuild === true && event.material && event.buildInfo === undefined ) {
+
+			let pendingInvalidations = this._pendingInvalidations.get( event.material );
+
+			if ( pendingInvalidations === undefined ) {
+
+				pendingInvalidations = [];
+				this._pendingInvalidations.set( event.material, pendingInvalidations );
+
+			}
+
+			pendingInvalidations.push( event );
+
+			return;
+
+		}
+
 		if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
 
 	}
@@ -149,6 +203,7 @@ class NodeMaterialDebug {
 		this._originalGet = null;
 		this._nodes = null;
 		this._originalNeedsRefresh = null;
+		this._pendingInvalidations = new WeakMap();
 
 	}
 
diff --git a/examples/jsm/inspector/tabs/Console.js b/examples/jsm/inspector/tabs/Console.js
index da546c3dce719d..44f030e4e4ec3e 100644
--- a/examples/jsm/inspector/tabs/Console.js
+++ b/examples/jsm/inspector/tabs/Console.js
@@ -1,4 +1,5 @@
 import { Tab } from '../ui/Tab.js';
+import { loadSettingsState, setNodeMaterialDebug } from './Settings.js';
 
 class Console extends Tab {
 
@@ -6,9 +7,11 @@ class Console extends Tab {
 
 		super( 'Console', options );
 
+		const settingsState = loadSettingsState();
+
 		this.filters = { info: true, warn: true, error: true };
 		this.filterText = '';
-		this.traceNodeMaterialInvalidation = false;
+		this.nodeMaterialDebugEnabled = settingsState.nodeMaterialDebugEnabled === true || options.nodeMaterialDebugEnabled === true;
 
 		this.buildHeader();
 
@@ -16,9 +19,8 @@ class Console extends Tab {
 		this.logContainer.id = 'console-log';
 		this.content.appendChild( this.logContainer );
 
-		if ( options.traceNodeMaterialInvalidation === true ) {
+		if ( this.nodeMaterialDebugEnabled === true ) {
 
-			this.traceNodeMaterialInvalidation = true;
 			this.nodeMaterialCheckbox.checked = true;
 
 		}
@@ -56,7 +58,7 @@ class Console extends Tab {
 
 		const nodeMaterialCheckbox = document.createElement( 'input' );
 		nodeMaterialCheckbox.type = 'checkbox';
-		nodeMaterialCheckbox.dataset.action = 'trace-node-material-invalidation';
+		nodeMaterialCheckbox.dataset.action = 'node-material-debug';
 		this.nodeMaterialCheckbox = nodeMaterialCheckbox;
 
 		const nodeMaterialCheckmark = document.createElement( 'span' );
@@ -92,10 +94,11 @@ class Console extends Tab {
 
 			const action = e.target.dataset.action;
 
-			if ( action === 'trace-node-material-invalidation' ) {
+			if ( action === 'node-material-debug' ) {
 
-				this.traceNodeMaterialInvalidation = e.target.checked;
-				this.dispatchEvent( { type: 'trace-node-material-invalidation', enabled: this.traceNodeMaterialInvalidation } );
+				this.nodeMaterialDebugEnabled = e.target.checked;
+				setNodeMaterialDebug( this.nodeMaterialDebugEnabled );
+				this.dispatchEvent( { type: 'node-material-debug', enabled: this.nodeMaterialDebugEnabled } );
 				return;
 
 			}
@@ -219,11 +222,17 @@ class Console extends Tab {
 
 		}
 
-		const parts = content.split( /(".*?"|'.*?'|`.*?`)/g ).map( p => p.trim() ).filter( Boolean );
+		const parts = content.split( /(<strong>.*?<\/strong>|".*?"|'.*?'|`.*?`)/g ).map( p => p.trim() ).filter( Boolean );
 
 		parts.forEach( ( part, index ) => {
 
-			if ( /^("|'|`)/.test( part ) ) {
+			if ( part.startsWith( '<strong>' ) ) {
+
+				const strong = document.createElement( 'strong' );
+				strong.textContent = part.slice( 8, - 9 );
+				fragment.appendChild( strong );
+
+			} else if ( /^("|'|`)/.test( part ) ) {
 
 				const codeSpan = document.createElement( 'span' );
 				codeSpan.className = 'log-code';
diff --git a/examples/jsm/inspector/tabs/Settings.js b/examples/jsm/inspector/tabs/Settings.js
index c7e4c3794bdc73..3c0c12259aef6b 100644
--- a/examples/jsm/inspector/tabs/Settings.js
+++ b/examples/jsm/inspector/tabs/Settings.js
@@ -43,6 +43,7 @@ function _loadState() {
 	_state = {
 		forceWebGL: settings.forceWebGL !== undefined ? settings.forceWebGL : false,
 		captureStackTrace: settings.captureStackTrace !== undefined ? settings.captureStackTrace : false,
+		nodeMaterialDebugEnabled: settings.nodeMaterialDebugEnabled !== undefined ? settings.nodeMaterialDebugEnabled : settings.traceNodeMaterialInvalidation === true,
 		activeExtensions: settings.activeExtensions !== undefined ? settings.activeExtensions : {}
 	};
 
@@ -67,11 +68,21 @@ function _saveState() {
 	setItem( 'settings', {
 		forceWebGL: _state.forceWebGL,
 		captureStackTrace: _state.captureStackTrace,
+		nodeMaterialDebugEnabled: _state.nodeMaterialDebugEnabled,
 		activeExtensions: _state.activeExtensions
 	} );
 
 }
 
+function setNodeMaterialDebug( enabled ) {
+
+	_loadState();
+
+	_state.nodeMaterialDebugEnabled = enabled === true;
+	_saveState();
+
+}
+
 _loadState();
 
 //
@@ -261,4 +272,4 @@ class Settings extends Parameters {
 
 }
 
-export { Settings };
+export { Settings, _loadState as loadSettingsState, setNodeMaterialDebug };
diff --git a/src/renderers/common/InspectorBase.js b/src/renderers/common/InspectorBase.js
index b1e61902c7df5a..e6ee159239d417 100644
--- a/src/renderers/common/InspectorBase.js
+++ b/src/renderers/common/InspectorBase.js
@@ -57,6 +57,20 @@ class InspectorBase extends EventDispatcher {
 
 	}
 
+	/**
+	 * Called before a missing node builder state is built.
+	 *
+	 * @param {Object} info - Information about the node build.
+	 */
+	beginNodeBuild( /*info*/ ) { }
+
+	/**
+	 * Called after a missing node builder state has been built.
+	 *
+	 * @param {Object} info - Information about the node build.
+	 */
+	finishNodeBuild( /*info*/ ) { }
+
 	/**
 	 * Returns the renderer associated with this inspector.
 	 *
diff --git a/src/renderers/common/nodes/NodeManager.js b/src/renderers/common/nodes/NodeManager.js
index 2caf90c8efea77..0b691e7d8def0d 100644
--- a/src/renderers/common/nodes/NodeManager.js
+++ b/src/renderers/common/nodes/NodeManager.js
@@ -14,6 +14,34 @@ import { error } from '../../../utils.js';
 const _chainKeys = [];
 const _cacheKeyValues = [];
 
+function getNodeBuildInfo( renderer, renderObject, useAsync, cacheKey ) {
+
+	const object = renderObject.object || null;
+	const material = renderObject.material || null;
+	const geometry = renderObject.geometry || object && object.geometry || null;
+
+	return {
+		renderer,
+		renderObject,
+		object,
+		material,
+		geometry,
+		lightsNode: renderObject.lightsNode || null,
+		scene: renderObject.scene || null,
+		camera: renderObject.camera || null,
+		useAsync,
+		cacheKey: cacheKey || null,
+		materialVersion: material ? material.version : null,
+		materialUuid: material ? material.uuid : null,
+		geometryUuid: geometry ? geometry.uuid : null,
+		objectUuid: object ? object.uuid : null,
+		reason: 'missing-node-builder-state',
+		durationMs: 0,
+		result: null
+	};
+
+}
+
 /**
  * This renderer module manages node-related objects and is the
  * primary interface between the renderer and the node system.
@@ -197,6 +225,19 @@ class NodeManager extends DataMap {
 
 			if ( nodeBuilderState === undefined ) {
 
+				const renderer = this.renderer;
+				const inspector = renderer.inspector;
+				const nodeBuildInfo = inspector !== null ? getNodeBuildInfo( renderer, renderObject, useAsync, cacheKey ) : null;
+				let startTime = 0;
+
+				if ( inspector !== null ) {
+
+					startTime = performance.now();
+
+					inspector.beginNodeBuild( nodeBuildInfo );
+
+				}
+
 				const buildNodeBuilder = async () => {
 
 					let nodeBuilder = this._createNodeBuilder( renderObject, renderObject.material );
@@ -244,6 +285,15 @@ class NodeManager extends DataMap {
 						nodeBuilderState.usedTimes ++;
 						renderObjectData.nodeBuilderState = nodeBuilderState;
 
+						if ( inspector !== null ) {
+
+							nodeBuildInfo.durationMs = performance.now() - startTime;
+							nodeBuildInfo.result = nodeBuilderState;
+
+							inspector.finishNodeBuild( nodeBuildInfo );
+
+						}
+
 						return nodeBuilderState;
 
 					} );
@@ -280,6 +330,15 @@ class NodeManager extends DataMap {
 
 					nodeBuilderCache.set( cacheKey, nodeBuilderState );
 
+					if ( inspector !== null ) {
+
+						nodeBuildInfo.durationMs = performance.now() - startTime;
+						nodeBuildInfo.result = nodeBuilderState;
+
+						inspector.finishNodeBuild( nodeBuildInfo );
+
+					}
+
 				}
 
 			}

From 98deff6dd42dbee68d90fa07dd1ee5902d99faee Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 15:09:25 +0900
Subject: [PATCH 17/19] Fix node material debug analyzer lint

---
 examples/jsm/inspector/NodeMaterialDebugAnalyzer.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 5239e4a36e5346..837eef54b40e76 100644
--- a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -1,5 +1,4 @@
-import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap } from 'three/webgpu';
-import { warn } from 'three/webgpu';
+import { BasicShadowMap, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, warn } from 'three/webgpu';
 
 
 function getKeys( obj ) {
@@ -786,7 +785,6 @@ class NodeMaterialDebugAnalyzer {
 		let material = null;
 		let materialNodes = null;
 		let traceMaterialNodes = null;
-		let dynamic = null;
 		let dynamicCacheKey = null;
 		let nodesCacheKey = null;
 		const currentMaterial = () => material || ( material = getMaterialCacheKeyComponents( renderObject ) );
@@ -803,7 +801,6 @@ class NodeMaterialDebugAnalyzer {
 
 		};
 
-		const currentDynamic = () => dynamic || ( dynamic = getDynamicCacheKeyComponents( renderObject ) );
 		const currentDynamicCacheKey = () => dynamicCacheKey || ( dynamicCacheKey = String( renderObject.getDynamicCacheKey() ) );
 		const currentNodesCacheKey = () => nodesCacheKey || ( nodesCacheKey = getNodesCacheKey( renderObject ) );
 

From f040b436e4b46e08a431724ba75f05098950dffa Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Fri, 10 Apr 2026 16:12:51 +0900
Subject: [PATCH 18/19] Improve node material refresh diagnostics

---
 examples/jsm/inspector/NodeMaterialDebug.js   | 23 +++++++++++++++++++
 .../inspector/NodeMaterialDebugAnalyzer.js    | 17 ++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
index 2b85eb7648ac3c..0eb90773c882e4 100644
--- a/examples/jsm/inspector/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -101,11 +101,34 @@ class NodeMaterialDebug {
 
 	reportRefresh( renderObject, previousCacheKey, cacheKey ) {
 
+		const previousCallback = this.analyzer.onNodeMaterialInvalidation;
+		let dispatched = false;
+
+		this.analyzer.onNodeMaterialInvalidation = ( event ) => {
+
+			dispatched = true;
+			event.stage = event.stage || 'node-refresh';
+			event.needsRefresh = true;
+			event.refreshCacheKeyPrevious = String( previousCacheKey );
+			event.refreshCacheKey = String( cacheKey );
+			this.dispatch( event );
+
+		};
+
+		this.analyzer.report( renderObject );
+		this.analyzer.update( renderObject );
+		this.analyzer.onNodeMaterialInvalidation = previousCallback;
+
+		if ( dispatched === true ) return;
+
 		this.dispatch( {
 			stage: 'node-refresh',
 			property: 'NodeMaterialObserver.needsRefresh',
 			previousValue: String( previousCacheKey ),
 			value: String( cacheKey ),
+			refreshCacheKeyPrevious: String( previousCacheKey ),
+			refreshCacheKey: String( cacheKey ),
+			currentDebugData: typeof this.analyzer.getCurrentDebugData === 'function' ? this.analyzer.getCurrentDebugData( renderObject ) : null,
 			rebuild: false,
 			needsRefresh: true,
 			material: renderObject.material,
diff --git a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
index 837eef54b40e76..400ce96f27637a 100644
--- a/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
+++ b/examples/jsm/inspector/NodeMaterialDebugAnalyzer.js
@@ -769,6 +769,23 @@ class NodeMaterialDebugAnalyzer {
 
 	}
 
+	getCurrentDebugData( renderObject ) {
+
+		const geometryId = renderObject.geometry !== null ? renderObject.geometry.id : null;
+
+		return {
+			version: renderObject.version,
+			geometryId,
+			clippingContextCacheKey: renderObject.clippingContextCacheKey,
+			material: getMaterialCacheKeyComponents( renderObject ),
+			materialNodes: getMaterialNodeComponents( renderObject.material, this.traceEnabled ),
+			dynamic: getDynamicCacheKeyComponents( renderObject ),
+			dynamicCacheKey: String( renderObject.getDynamicCacheKey() ),
+			nodesCacheKey: getNodesCacheKey( renderObject )
+		};
+
+	}
+
 	/**
 	 * Reports cache invalidation for the given render object.
 	 *

From 0eeef3eec5ada65ceefaac77418de357bb4019d1 Mon Sep 17 00:00:00 2001
From: RenaudRohlinger <renaud.rohlinger@gmail.com>
Date: Sat, 11 Apr 2026 11:00:58 +0900
Subject: [PATCH 19/19] Add compute rebuild debug logging

---
 examples/jsm/inspector/Inspector.js          |   6 +-
 examples/jsm/inspector/NodeMaterialDebug.js  | 106 +++++++++++++++++++
 examples/webgpu_materials_debug_rebuild.html |  41 ++++++-
 3 files changed, 148 insertions(+), 5 deletions(-)

diff --git a/examples/jsm/inspector/Inspector.js b/examples/jsm/inspector/Inspector.js
index 34d4a63eb76537..78fea821a444df 100644
--- a/examples/jsm/inspector/Inspector.js
+++ b/examples/jsm/inspector/Inspector.js
@@ -346,15 +346,17 @@ class Inspector extends RendererInspector {
 			if ( this.nodeMaterialDebug === null ) this.nodeMaterialDebug = new NodeMaterialDebug( renderer );
 			this.nodeMaterialDebug.onNodeMaterialInvalidation = ( event ) => {
 
-				const materialLabel = event.materialLabel || ( event.material ? event.material.name || event.material.type : 'unknown material' );
+				const label = event.compute === true ? ( event.computeLabel || 'unknown compute node' ) : ( event.materialLabel || ( event.material ? event.material.name || event.material.type : 'unknown material' ) );
+				const type = event.compute === true ? 'Compute node' : 'NodeMaterial';
 
 				const property = event.property !== undefined ? ` via ${ event.property }` : '';
 				const values = event.previousValue !== undefined && event.value !== undefined ? ` (${ event.previousValue } -> ${ event.value })` : '';
 				const source = event.sourceProperty !== undefined && event.sourceProperty !== event.property ? ` [${ event.sourceProperty }]` : '';
+				const reason = event.reason !== undefined ? ` because ${ event.reason }` : '';
 				const buildInfo = event.buildInfo;
 				const timing = buildInfo && buildInfo.durationMs !== undefined ? ` in <strong>${ buildInfo.durationMs.toFixed( 3 ) } ms</strong>` : '';
 
-				this.console.addMessage( 'warn', `Renderer: NodeMaterial needs rebuild for "${ materialLabel }"${ property }${ values }${ source }${ timing }.` );
+				this.console.addMessage( 'warn', `Renderer: ${ type } needs rebuild for "${ label }"${ property }${ values }${ source }${ reason }${ timing }.` );
 
 				if ( typeof this.onNodeMaterialInvalidation === 'function' ) this.onNodeMaterialInvalidation( event );
 
diff --git a/examples/jsm/inspector/NodeMaterialDebug.js b/examples/jsm/inspector/NodeMaterialDebug.js
index 0eb90773c882e4..07b6ef0d48b7e2 100644
--- a/examples/jsm/inspector/NodeMaterialDebug.js
+++ b/examples/jsm/inspector/NodeMaterialDebug.js
@@ -12,6 +12,9 @@ class NodeMaterialDebug {
 		this._originalGet = null;
 		this._nodes = null;
 		this._originalNeedsRefresh = null;
+		this._originalGetForCompute = null;
+		this._computeBuilds = new WeakMap();
+		this._computeInvalidations = new WeakMap();
 		this._pendingInvalidations = new WeakMap();
 
 		this.updateRenderer();
@@ -76,6 +79,7 @@ class NodeMaterialDebug {
 	_patchNodeManager( nodes ) {
 
 		const originalNeedsRefresh = nodes.needsRefresh;
+		const originalGetForCompute = nodes.getForCompute;
 		const nodeMaterialDebug = this;
 
 		nodes.needsRefresh = function ( renderObject ) {
@@ -94,8 +98,79 @@ class NodeMaterialDebug {
 
 		};
 
+		nodes.getForCompute = function ( computeNode ) {
+
+			const computeData = this.get( computeNode );
+			const previousNodeBuilderState = computeData.nodeBuilderState;
+			const invalidation = nodeMaterialDebug._computeInvalidations.get( computeNode );
+			const startTime = previousNodeBuilderState === undefined ? performance.now() : 0;
+			const nodeBuilderState = originalGetForCompute.call( this, computeNode );
+
+			if ( previousNodeBuilderState === undefined && nodeBuilderState !== undefined ) {
+
+				nodeMaterialDebug.reportComputeBuild( computeNode, nodeBuilderState, invalidation, performance.now() - startTime );
+
+			}
+
+			return nodeBuilderState;
+
+		};
+
 		this._nodes = nodes;
 		this._originalNeedsRefresh = originalNeedsRefresh;
+		this._originalGetForCompute = originalGetForCompute;
+
+	}
+
+	reportComputeBuild( computeNode, nodeBuilderState, invalidation, durationMs ) {
+
+		const computeShader = nodeBuilderState.computeShader;
+		const computeLabel = computeNode.name || computeNode.type || 'ComputeNode';
+		const previousBuild = invalidation !== undefined ? invalidation.previousBuild : undefined;
+		const reason = invalidation !== undefined ? invalidation.reason : 'initial compute build';
+		const difference = previousBuild !== undefined ? getComputeBuildDifference( previousBuild, computeShader ) : null;
+		const event = {
+			stage: invalidation !== undefined ? 'compute-cache' : 'compute-build',
+			property: invalidation !== undefined ? invalidation.property : 'NodeManager.getForCompute',
+			reason,
+			rebuild: true,
+			needsRefresh: true,
+			compute: true,
+			buildInfo: {
+				durationMs,
+				result: nodeBuilderState
+			},
+			computeNode,
+			computeLabel
+		};
+
+		if ( difference !== null ) {
+
+			event.property = difference.property;
+			event.previousValue = difference.previousValue;
+			event.value = difference.value;
+			event.previousComputeShader = difference.previousComputeShader;
+			event.computeShader = difference.computeShader;
+
+		}
+
+		this._computeBuilds.set( computeNode, {
+			computeShader
+		} );
+
+		this.dispatch( event );
+
+		this._computeInvalidations.delete( computeNode );
+
+	}
+
+	markComputeDisposed( computeNode, reason = 'computeNode.dispose() cleared cached compute state', property = 'computeNode.dispose' ) {
+
+		this._computeInvalidations.set( computeNode, {
+			property,
+			reason,
+			previousBuild: this._computeBuilds.get( computeNode )
+		} );
 
 	}
 
@@ -151,6 +226,8 @@ class NodeMaterialDebug {
 
 	updatePendingBuildInfo( info ) {
 
+		if ( info.material === undefined ) return;
+
 		const pendingInvalidations = this._pendingInvalidations.get( info.material );
 
 		if ( pendingInvalidations !== undefined ) {
@@ -167,6 +244,8 @@ class NodeMaterialDebug {
 
 	flushPendingInvalidations( info ) {
 
+		if ( info.material === undefined ) return;
+
 		const material = info.material;
 		const pendingInvalidations = this._pendingInvalidations.get( material );
 
@@ -222,14 +301,41 @@ class NodeMaterialDebug {
 
 		}
 
+		if ( this._nodes !== null && this._originalGetForCompute !== null ) {
+
+			this._nodes.getForCompute = this._originalGetForCompute;
+
+		}
+
 		this._objects = null;
 		this._originalGet = null;
 		this._nodes = null;
 		this._originalNeedsRefresh = null;
+		this._originalGetForCompute = null;
+		this._computeBuilds = new WeakMap();
+		this._computeInvalidations = new WeakMap();
 		this._pendingInvalidations = new WeakMap();
 
 	}
 
 }
 
+function getComputeBuildDifference( previousBuild, computeShader ) {
+
+	if ( previousBuild.computeShader !== computeShader ) {
+
+		return {
+			property: 'computeShader',
+			previousValue: 'previous compute shader',
+			value: 'changed compute shader',
+			previousComputeShader: previousBuild.computeShader,
+			computeShader
+		};
+
+	}
+
+	return null;
+
+}
+
 export default NodeMaterialDebug;
diff --git a/examples/webgpu_materials_debug_rebuild.html b/examples/webgpu_materials_debug_rebuild.html
index 6b696a9b684ec2..1d8121e50086ee 100644
--- a/examples/webgpu_materials_debug_rebuild.html
+++ b/examples/webgpu_materials_debug_rebuild.html
@@ -66,6 +66,7 @@
 			<button id="clearcoatButton">Clearcoat</button>
 			<button id="transmissionButton">Transmission</button>
 			<button id="nodeButton">Node</button>
+			<button id="computeButton">Compute</button>
 			<button id="lightButton">Point Light</button>
 			<button id="autoDemoButton">Auto Demo</button>
 		</div>
@@ -85,7 +86,7 @@
 		<script type="module">
 
 			import * as THREE from 'three/webgpu';
-			import { color } from 'three/tsl';
+			import { Fn, color, float, instanceIndex, instancedArray } from 'three/tsl';
 
 			import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 			import { Inspector } from 'three/addons/inspector/Inspector.js';
@@ -117,7 +118,8 @@
 			}
 
 			let camera, scene, renderer, controls;
-			let material, accentLight, sphere, rebuildColorNode;
+			let material, accentLight, sphere, rebuildColorNode, computeNode;
+			let computeVersion = 1;
 			let autoDemoInterval = null;
 			let autoDemoStep = 0;
 
@@ -174,6 +176,8 @@
 				rebuildColorNode = new RebuildColorNode();
 				material.colorNode = rebuildColorNode;
 
+				createComputeNode();
+
 				sphere = new THREE.Mesh( new THREE.SphereGeometry( 1, 64, 32 ), material );
 				sphere.position.y = 1;
 				scene.add( sphere );
@@ -181,6 +185,7 @@
 				document.getElementById( 'clearcoatButton' ).addEventListener( 'click', toggleClearcoat );
 				document.getElementById( 'transmissionButton' ).addEventListener( 'click', toggleTransmission );
 				document.getElementById( 'nodeButton' ).addEventListener( 'click', toggleNode );
+				document.getElementById( 'computeButton' ).addEventListener( 'click', rebuildCompute );
 				document.getElementById( 'lightButton' ).addEventListener( 'click', toggleAccentLight );
 				autoDemoButton.addEventListener( 'click', toggleAutoDemo );
 
@@ -190,6 +195,19 @@
 
 			}
 
+			function createComputeNode() {
+
+				const computeBuffer = instancedArray( 1, 'float' );
+				const computeTest = Fn( () => {
+
+					computeBuffer.element( instanceIndex ).assign( float( computeVersion ) );
+
+				} );
+
+				computeNode = computeTest().compute( 1 ).setName( 'Debug Compute' );
+
+			}
+
 			function toggleClearcoat() {
 
 				material.clearcoat = material.clearcoat === 0 ? 1 : 0;
@@ -234,6 +252,23 @@
 
 			}
 
+			function rebuildCompute() {
+
+				computeVersion ++;
+
+				if ( computeNode !== undefined ) {
+
+					renderer.inspector.nodeMaterialDebug.markComputeDisposed( computeNode );
+					computeNode.dispose();
+
+				}
+
+				renderer.compute( computeNode );
+
+				updateActions();
+
+			}
+
 			function updateActions() {
 
 				document.getElementById( 'clearcoatButton' ).classList.toggle( 'active', material.clearcoat > 0 );
@@ -253,7 +288,7 @@
 
 				} else {
 
-					const actions = [ toggleClearcoat, toggleTransmission, toggleNode, toggleAccentLight ];
+					const actions = [ toggleClearcoat, toggleTransmission, toggleNode, rebuildCompute, toggleAccentLight ];
 
 					actions[ autoDemoStep % actions.length ]();
 					autoDemoStep ++;