rayzee 8.6.0 → 8.6.1

package/package.json

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

package/src/AssetConfig.js

@@ -45,12 +45,13 @@ const config = {
 	// AI upscaler ONNX model base URL. Quality presets resolve relative paths against this.
 	upscalerModelBaseUrl: 'https://huggingface.co/notaneimu/onnx-image-models/resolve/main/',
 
-	// DLSS runtime bundle. A plain script the host serves, not a module: it installs
-	// `globalThis.DLSSRuntime`, so it cannot be imported and the host must publish it somewhere.
-	dlssRuntimeUrl: '/dlss/dlss-runtime.js',
+	// Neural post-pass runtime. A plain script the host serves, not a module: it installs
+	// `globalThis.NeuralRuntime`, so it cannot be imported and the host must publish it somewhere.
+	neuralRuntimeUrl: '/neural/neural-runtime.js',
 
-	// Base for the DLSS weight manifests the runtime fetches (`generated/...` beneath this).
-	dlssAssetBaseUrl: 'https://pub-6e048ff014374f11bef33d76b6c2b5ef.r2.dev/v1',
+	// Base for the neural weight manifests the runtime fetches (`generated/...` beneath this). No
+	// default: the weights are not redistributable, so a host supplies its own copy.
+	neuralAssetBaseUrl: null,
 
 	// Prefix used when the engine writes to client-side stores (IndexedDB, etc).
 	// Set to a unique value to avoid collisions when multiple apps embed the engine on the same origin.

package/src/Passes/OIDNDenoiser.js

@@ -688,6 +688,14 @@ export class OIDNDenoiser extends EventDispatcher {
 		this._computeInputScale( device, width * height );
 		this._applyColorScale( device, width * height );
 
+		// A final denoise is shown tile by tile, so the tiles still to come must show this render
+		// rather than the blank or previous-view picture the output holds between runs.
+		if ( ! continuous && ! this._hasOutput ) {
+
+			this._unpackToTexture( this._gpuInputBuffers.color, width, { x: 0, y: 0, width, height }, false );
+
+		}
+
 		// Pass GPU storage buffers to oidn-web (GPUBuffer path, well-tested)
 		const config = {
 			color: { data: this._gpuInputBuffers.color, width, height },
@@ -996,11 +1004,12 @@ export class OIDNDenoiser extends EventDispatcher {
 	/**
 	 * Writes a rectangle of the denoised buffer into the output picture, on the card.
 	 *
-	 * @param {GPUBuffer} src - denoised rgba32float, full image
+	 * @param {GPUBuffer} src - rgba32float, full image, scaled by the input autoexposure
 	 * @param {number} srcWidth
 	 * @param {{x: number, y: number, width: number, height: number}} rect
+	 * @param {boolean} [denoised=true] - false for the raw render laid under a tiled run
 	 */
-	_unpackToTexture( src, srcWidth, rect ) {
+	_unpackToTexture( src, srcWidth, rect, denoised = true ) {
 
 		const device = this.gpuDevice;
 		if ( ! device || ! this._ensureScalePipelines( device ) ) return;
@@ -1047,7 +1056,7 @@ export class OIDNDenoiser extends EventDispatcher {
 			// Set here rather than when the run resolves: 'end' is dispatched from execute()'s
 			// finally, which runs first, so a listener that waits for the run would see the very
 			// first denoise as having produced nothing.
-			this._hasOutput = true;
+			if ( denoised ) this._hasOutput = true;
 
 		} finally {
 
@@ -1060,8 +1069,7 @@ export class OIDNDenoiser extends EventDispatcher {
 
 	/**
 	 * Promise wrapper around tileExecute for the GPU path. Each tile is written straight into the
-	 * output picture on the card, so there is nothing to await between a tile finishing and it
-	 * being visible.
+	 * output picture on the card; 'tileProgress' is what puts it on screen.
 	 */
 	_executeWithAbortGPU( config, continuous = false ) {
 

package/src/index.js

@@ -99,11 +99,11 @@ export { VideoRenderManager } from './managers/VideoRenderManager.js';
 // Interaction
 export { InteractionManager } from './managers/InteractionManager.js';
 
-// DLSS neural passes. The app drives these through `denoisingManager` — what is exported here is
+// Neural post passes. The app drives these through `denoisingManager` — what is exported here is
 // the offline entry point (`renderUpscaled`, used by the regression bench) plus the two contracts a
 // host needs to build UI against.
-export { renderUpscaled, SR_SCALE, SR_MAX_INPUT } from './dlss/DLSSSuperRes.js';
-export { DLSS_NR_DEFAULTS, DLSS_NR_RANGES, DLSS_NR_MAX_PIXELS } from './dlss/DLSSNeural.js';
+export { renderUpscaled, SR_SCALE, SR_MAX_INPUT } from './neural/NeuralSuperRes.js';
+export { RETOUCH_DEFAULTS, RETOUCH_RANGES, RETOUCH_MAX_PIXELS } from './neural/NeuralRetouch.js';
 
 // ── Colour management ───────────────────────────────────────────────────────────────────────────
 // `app.color` is the instance a host normally uses; these are for building UI against it, and for

package/src/managers/DenoisingManager.js

@@ -4,9 +4,9 @@ import { AIUpscaler } from '../Passes/AIUpscaler.js';
 import { EngineEvents } from '../EngineEvents.js';
 import { createLogger } from '../utils/Logger.js';
 
-// The neural passes live in `../dlss/` but report through the manager that drives them, so they
-// share one namespace: `rayzee.log.only( 'dlss' )` shows the whole chain.
-const dlssLog = createLogger( 'dlss' );
+// The neural passes live in `../neural/` but report through the manager that drives them, so they
+// share one namespace: `rayzee.log.only( 'neural' )` shows the whole chain.
+const neuralLog = createLogger( 'neural' );
 import { ENGINE_DEFAULTS as DEFAULT_STATE, ASVGF_QUALITY_PRESETS, NRD_DEFAULTS, NRD_QUALITY_PRESETS, NRD_PRESET_KEYS } from '../EngineDefaults.js';
 
 // A refresh slower than this is a slideshow, not a live view, so the cadence swaps to a cheaper
@@ -112,16 +112,16 @@ export class DenoisingManager extends EventDispatcher {
 
 		this.denoiser = null;
 		this.upscaler = null;
-		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+		// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 		// super-resolution pass, which is fixed at 2x and needs a denoised source.
 		this.upscalerBackend = 'esrgan';
-		this._dlssUpscaler = null;
+		this._neuralUpscaler = null;
 		// The neural-rendering (detail) pass is independent of the upscaler: it changes appearance,
 		// not resolution, and runs last because its result cannot be read back.
 		this.neuralRendering = false;
 		this.neuralRenderingSettings = {};
-		this._dlssNeural = null;
-		this._dlssModule = null;
+		this._retouch = null;
+		this._superResModule = null;
 		this._neuralPostBusy = false;
 
 		// The tier the finished image uses. The loaded tier is not always this one: while the
@@ -162,6 +162,7 @@ export class DenoisingManager extends EventDispatcher {
 		// Bound event forwarding handlers (stored for removal on re-setup / dispose)
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;
@@ -298,8 +299,21 @@ export class DenoisingManager extends EventDispatcher {
 
 		};
 
+		// The loop has stopped by the time a final denoise runs, so each tile has to redraw the
+		// canvas itself. Not through the display-refresh callback: that restarts the loop, which a
+		// video export drives by hand.
+		this._denoiserTileHandler = e => {
+
+			if ( e.continuous ) return;
+			this._publishOutput();
+			const ctx = this.pipeline?.context;
+			if ( this._stages.compositor && ctx ) this._stages.compositor.render( ctx );
+
+		};
+
 		this.denoiser.addEventListener( 'start', this._denoiserStartHandler );
 		this.denoiser.addEventListener( 'end', this._denoiserEndHandler );
+		this.denoiser.addEventListener( 'tileProgress', this._denoiserTileHandler );
 
 	}
 
@@ -804,20 +818,20 @@ export class DenoisingManager extends EventDispatcher {
 	}
 
 	/**
-	 * Selects the AI upscaler's model. 'dlss' is fixed at 2x and reads the denoised picture, so it
+	 * Selects the AI upscaler's model. 'neural' is fixed at 2x and reads the denoised picture, so it
 	 * is a no-op without a denoiser — feeding it raw Monte-Carlo noise measurably loses to bilinear.
 	 *
-	 * @param {'esrgan'|'dlss'} backend
+	 * @param {'esrgan'|'neural'} backend
 	 */
 	setUpscalerBackend( backend ) {
 
-		const next = backend === 'dlss' ? 'dlss' : 'esrgan';
+		const next = backend === 'neural' ? 'neural' : 'esrgan';
 		if ( next === this.upscalerBackend ) return;
 
 		this.upscalerBackend = next;
 		// Whatever is on screen came from the model being switched away from.
 		this._restoreRenderDisplay();
-		if ( next !== 'dlss' ) this._releaseDLSSUpscaler();
+		if ( next !== 'neural' ) this._releaseNeuralUpscaler();
 
 	}
 
@@ -847,15 +861,15 @@ export class DenoisingManager extends EventDispatcher {
 
 	}
 
-	_releaseDLSSUpscaler() {
+	_releaseNeuralUpscaler() {
 
-		this._dlssUpscaler?.dispose();
-		this._dlssUpscaler = null;
+		this._neuralUpscaler?.dispose();
+		this._neuralUpscaler = null;
 
 		// The frame packer lives on the module, not on the upscaler, and holds two buffers the size
 		// of the render. Nothing else reaches it, so this is its only release point. Guarded on the
 		// module having been loaded, so a teardown never pulls in 1 MB of runtime to call a no-op.
-		this._dlssModule?.releaseDenoisedReader();
+		this._superResModule?.releaseDenoisedReader();
 
 	}
 
@@ -866,17 +880,17 @@ export class DenoisingManager extends EventDispatcher {
 		if ( settings ) this.neuralRenderingSettings = { ...this.neuralRenderingSettings, ...settings };
 		if ( ! this.neuralRendering ) {
 
-			this._releaseDLSSNeural();
+			this._releaseNeuralRetouch();
 			this._restoreRenderDisplay();
 
 		}
 
 	}
 
-	_releaseDLSSNeural() {
+	_releaseNeuralRetouch() {
 
-		this._dlssNeural?.dispose();
-		this._dlssNeural = null;
+		this._retouch?.dispose();
+		this._retouch = null;
 
 	}
 
@@ -894,7 +908,7 @@ export class DenoisingManager extends EventDispatcher {
 	 */
 	async _runNeuralPost( isStillComplete ) {
 
-		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'dlss';
+		const wantSR = this.upscaler?.enabled && this.upscalerBackend === 'neural';
 		const wantNR = this.neuralRendering;
 		if ( ! wantSR && ! wantNR ) return;
 
@@ -904,14 +918,14 @@ export class DenoisingManager extends EventDispatcher {
 
 		if ( ! this.upscalerCanvas ) {
 
-			dlssLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
+			neuralLog.warn( 'neural pass skipped: the engine has no overlay canvas to present on' );
 			return;
 
 		}
 
 		if ( ! this.pipeline?.context?.getTexture( 'oidn:output' ) ) {
 
-			dlssLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
+			neuralLog.warn( 'neural pass skipped: no denoised picture — it needs OIDN' );
 			return;
 
 		}
@@ -921,26 +935,26 @@ export class DenoisingManager extends EventDispatcher {
 
 		try {
 
-			const sr = await import( '../dlss/DLSSSuperRes.js' );
-			this._dlssModule = sr;
+			const sr = await import( '../neural/NeuralSuperRes.js' );
+			this._superResModule = sr;
 
 			// The detail pass has a size ceiling — above it a run takes minutes and then loses every GPU
 			// device in the page. Running it FIRST is what keeps it under: at render size it sees a
 			// quarter of the pixels it would after a 2x upscale, and the render reserve already caps
 			// that at 2048. The check stays as a floor under a raised reserve.
-			const nrModule = wantNR ? await import( '../dlss/DLSSNeural.js' ) : null;
+			const nrModule = wantNR ? await import( '../neural/NeuralRetouch.js' ) : null;
 			const srcSize = this.denoiser?._outTexSize;
 			const nrPixels = ( srcSize?.width ?? 0 ) * ( srcSize?.height ?? 0 );
-			const runNR = wantNR && nrPixels <= nrModule.DLSS_NR_MAX_PIXELS;
+			const runNR = wantNR && nrPixels <= nrModule.RETOUCH_MAX_PIXELS;
 
 			if ( wantNR && ! runNR ) {
 
-				dlssLog.warn(
+				neuralLog.warn(
 					`Neural rendering skipped: the render is ${( nrPixels / 1e6 ).toFixed( 1 )} MP, above the ` +
-					`${( nrModule.DLSS_NR_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
+					`${( nrModule.RETOUCH_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP the pass survives.` +
 					( wantSR ? ' The upscale still ran.' : '' )
 				);
-				this._releaseDLSSNeural();
+				this._releaseNeuralRetouch();
 
 			}
 
@@ -961,16 +975,16 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( wantSR ) {
 
-				if ( this._dlssUpscaler
-					&& ( this._dlssUpscaler.inputWidth !== source.width || this._dlssUpscaler.inputHeight !== source.height ) ) {
+				if ( this._neuralUpscaler
+					&& ( this._neuralUpscaler.inputWidth !== source.width || this._neuralUpscaler.inputHeight !== source.height ) ) {
 
-					this._releaseDLSSUpscaler();
+					this._releaseNeuralUpscaler();
 
 				}
 
-				if ( ! this._dlssUpscaler ) {
+				if ( ! this._neuralUpscaler ) {
 
-					this._dlssUpscaler = await sr.DLSSSuperRes.create( { width: source.width, height: source.height } );
+					this._neuralUpscaler = await sr.NeuralSuperRes.create( { width: source.width, height: source.height } );
 
 				}
 
@@ -979,23 +993,23 @@ export class DenoisingManager extends EventDispatcher {
 			let image = source;
 
 			// Detail first, upscale second. The detail pass hands back scene-referred light (see
-			// `app/public/dlss/PATCHES.md`), so the upscaler still gets the linear HDR it expects —
+			// the runtime's `rayzee-patch` edits), so the upscaler still gets the linear HDR it expects —
 			// which is what makes this order possible at all.
 			if ( runNR ) {
 
 				const result = await nrModule.enhanceFrame( {
 					source: image,
 					settings: this.neuralRenderingSettings,
-					instance: this._dlssNeural,
+					instance: this._retouch,
 					exposure: tone.exposure,
 					tone: wantSR ? null : tone,
 				} );
-				this._dlssNeural = result.instance;
+				this._retouch = result.instance;
 				image = result;
 
 			}
 
-			if ( wantSR ) image = await this._dlssUpscaler.upscaleToRGBA8( image, tone );
+			if ( wantSR ) image = await this._neuralUpscaler.upscaleToRGBA8( image, tone );
 
 			if ( ! isStillComplete() ) {
 
@@ -1024,7 +1038,7 @@ export class DenoisingManager extends EventDispatcher {
 
 		} catch ( error ) {
 
-			dlssLog.warn( 'neural pass failed', error );
+			neuralLog.warn( 'neural pass failed', error );
 
 		} finally {
 
@@ -1060,7 +1074,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			// One owner of the overlay canvas, so the neural chain and the ONNX upscaler are
 			// exclusive. The neural chain also runs on its own when only its detail pass is on.
-			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'dlss' ) ) {
+			if ( this.neuralRendering || ( this.upscaler?.enabled && this.upscalerBackend === 'neural' ) ) {
 
 				this._runNeuralPost( isStillComplete );
 				return;
@@ -1184,8 +1198,8 @@ export class DenoisingManager extends EventDispatcher {
 		// Remove pending completion-chain listener
 		this._cleanupCompletionListener();
 		// Owns a second GPUDevice plus 3 MB of weights, so it must not outlive the manager.
-		this._releaseDLSSUpscaler();
-		this._releaseDLSSNeural();
+		this._releaseNeuralUpscaler();
+		this._releaseNeuralRetouch();
 
 		// Before the denoiser destroys the picture the Compositor would otherwise still sample.
 		this._unpublishOutput();
@@ -1194,6 +1208,7 @@ export class DenoisingManager extends EventDispatcher {
 
 			if ( this._denoiserStartHandler ) this.denoiser.removeEventListener( 'start', this._denoiserStartHandler );
 			if ( this._denoiserEndHandler ) this.denoiser.removeEventListener( 'end', this._denoiserEndHandler );
+			if ( this._denoiserTileHandler ) this.denoiser.removeEventListener( 'tileProgress', this._denoiserTileHandler );
 			this.denoiser.dispose();
 			this.denoiser = null;
 
@@ -1207,15 +1222,16 @@ export class DenoisingManager extends EventDispatcher {
 			if ( this._upscalerEndHandler ) this.upscaler.removeEventListener( 'end', this._upscalerEndHandler );
 			this.upscaler.dispose();
 			this.upscaler = null;
-			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'dlss' is the neural
+			// Which model the AI upscaler runs. 'esrgan' is the ONNX chain; 'neural' is the neural
 			// super-resolution pass, which is fixed at 2x and needs a denoised source.
 			this.upscalerBackend = 'esrgan';
-			this._dlssUpscaler = null;
+			this._neuralUpscaler = null;
 
 		}
 
 		this._denoiserStartHandler = null;
 		this._denoiserEndHandler = null;
+		this._denoiserTileHandler = null;
 		this._upscalerResChangedHandler = null;
 		this._upscalerStartHandler = null;
 		this._upscalerProgressHandler = null;

package/src/{dlss/DLSSNeural.js → neural/NeuralRetouch.js}

@@ -1,5 +1,5 @@
 /**
- * DLSS-NR — the neural-rendering (detail) pass.
+ * Retouch — the neural-rendering (detail) pass.
  *
  * Runs over a finished, denoised image and adjusts its appearance: local tone and structure, and a
  * skin-specific term. It does not change resolution and it does not denoise. Measured on path-traced
@@ -36,7 +36,7 @@ import { getAssetConfig } from '../AssetConfig.js';
  * The model's own settings contract. Every field is numeric and validated hard by the runtime —
  * passing a string throws `"<name> must be finite"`.
  */
-export const DLSS_NR_DEFAULTS = Object.freeze( {
+export const RETOUCH_DEFAULTS = Object.freeze( {
 	enabled: true,
 	intensity: 1,
 	localTone: 1,
@@ -52,7 +52,7 @@ export const DLSS_NR_DEFAULTS = Object.freeze( {
  * How much of the network's own colour to take, 0..1. Ours, not the runtime's.
  *
  * ⚠️ It must be kept OUT of the object handed to the runtime: that one is validated by key and
- * throws `Unknown DLSS-NR setting: colorStrength`. `splitSettings` does the separating.
+ * throws `Unknown Retouch setting: colorStrength`. `splitSettings` does the separating.
  *
  * It is `color_strength` in the composition kernel, blending between the original chroma relit to
  * the network's luminance (`original * ratio`, at 0) and the network's full colour (at 1). At 0 the
@@ -65,13 +65,13 @@ export const DLSS_NR_DEFAULTS = Object.freeze( {
  * are the same at all three, so nothing the pass is actually for is given up. The renderer's chroma
  * is ground truth here; the network's is a guess about a photograph.
  */
-export const DLSS_NR_COLOR_STRENGTH = 0;
+export const RETOUCH_COLOR_STRENGTH = 0;
 
 /** @returns {{runtime: object, colorStrength: number}} */
 function splitSettings( settings = {} ) {
 
-	const { colorStrength = DLSS_NR_COLOR_STRENGTH, ...rest } = settings;
-	return { runtime: { ...DLSS_NR_DEFAULTS, ...rest }, colorStrength };
+	const { colorStrength = RETOUCH_COLOR_STRENGTH, ...rest } = settings;
+	return { runtime: { ...RETOUCH_DEFAULTS, ...rest }, colorStrength };
 
 }
 
@@ -95,12 +95,12 @@ function splitSettings( settings = {} ) {
  * reserve (`MAX_STORAGE_TEXTURE_SIZE`, 2048) already caps that at exactly 4.19 MP. The check below
  * is therefore unreachable today and exists as a floor under a raised reserve.
  */
-const log = createLogger( 'dlss' );
+const log = createLogger( 'neural' );
 
-export const DLSS_NR_MAX_PIXELS = 2048 * 2048;
+export const RETOUCH_MAX_PIXELS = 2048 * 2048;
 
 /** Ranges the runtime clamps to. `skinStructure: -1` means "follow localStructure". */
-export const DLSS_NR_RANGES = Object.freeze( {
+export const RETOUCH_RANGES = Object.freeze( {
 	intensity: [ 0, 1 ],
 	localTone: [ 0, 2 ],
 	localStructure: [ 0, 2 ],
@@ -112,31 +112,32 @@ export const DLSS_NR_RANGES = Object.freeze( {
 let _runtimePromise = null;
 
 /**
- * The runtime is a plain script that installs `globalThis.DLSSRuntime`, not a module, so it has to
+ * The runtime is a plain script that installs `globalThis.NeuralRuntime`, not a module, so it has to
  * be injected rather than imported. Cached: a second tag would re-run a 1 MB bundle.
  */
 function loadRuntime() {
 
 	if ( _runtimePromise ) return _runtimePromise;
 
-	const { dlssRuntimeUrl, dlssAssetBaseUrl } = getAssetConfig();
-	globalThis.__DLSS5_ASSET_BASE__ = dlssAssetBaseUrl;
+	const { neuralRuntimeUrl, neuralAssetBaseUrl } = getAssetConfig();
+	if ( ! neuralAssetBaseUrl ) return Promise.reject( new Error( 'No neural model location: set neuralAssetBaseUrl with configureAssets()' ) );
+	globalThis.__NEURAL_ASSET_BASE__ = neuralAssetBaseUrl;
 
 	_runtimePromise = new Promise( ( resolve, reject ) => {
 
-		if ( globalThis.DLSSRuntime?.getSrNrChain ) return resolve( globalThis.DLSSRuntime.getSrNrChain() );
+		if ( globalThis.NeuralRuntime?.getSrNrChain ) return resolve( globalThis.NeuralRuntime.getSrNrChain() );
 
 		const el = document.createElement( 'script' );
-		el.src = dlssRuntimeUrl;
+		el.src = neuralRuntimeUrl;
 		el.onload = () => {
 
-			const factory = globalThis.DLSSRuntime?.getSrNrChain;
-			if ( ! factory ) return reject( new Error( 'DLSS runtime loaded but exposed no neural-rendering entry' ) );
+			const factory = globalThis.NeuralRuntime?.getSrNrChain;
+			if ( ! factory ) return reject( new Error( 'Neural runtime loaded but exposed no retouch entry' ) );
 			resolve( factory() );
 
 		};
 
-		el.onerror = () => reject( new Error( `Failed to load the DLSS runtime from ${dlssRuntimeUrl}` ) );
+		el.onerror = () => reject( new Error( `Failed to load the neural runtime from ${neuralRuntimeUrl}` ) );
 		document.head.appendChild( el );
 
 	} );
@@ -183,7 +184,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  * Holds a GPUDevice of its own (the runtime builds it) plus ~140 MB of weights, so it must be
  * disposed rather than dropped.
  */
-export class DLSSNeural {
+export class NeuralRetouch {
 
 	constructor( chain, canvas ) {
 
@@ -232,15 +233,15 @@ export class DLSSNeural {
 
 		if ( ! Number.isInteger( width ) || ! Number.isInteger( height ) || width < 1 || height < 1 ) {
 
-			throw new Error( 'DLSSNeural.create: width and height must be positive integers' );
+			throw new Error( 'NeuralRetouch.create: width and height must be positive integers' );
 
 		}
 
-		if ( width * height > DLSS_NR_MAX_PIXELS ) {
+		if ( width * height > RETOUCH_MAX_PIXELS ) {
 
 			throw new Error(
-				`DLSSNeural.create: ${width}x${height} is ${( width * height / 1e6 ).toFixed( 1 )} MP, above the ` +
-				`${( DLSS_NR_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP this pass survives. Past it the run takes minutes ` +
+				`NeuralRetouch.create: ${width}x${height} is ${( width * height / 1e6 ).toFixed( 1 )} MP, above the ` +
+				`${( RETOUCH_MAX_PIXELS / 1e6 ).toFixed( 1 )} MP this pass survives. Past it the run takes minutes ` +
 				'and then loses every GPU device in the page.'
 			);
 
@@ -256,7 +257,7 @@ export class DLSSNeural {
 			surface, width, height, onProgress, splitSettings( settings ).runtime,
 		);
 
-		const instance = new DLSSNeural( chain, surface );
+		const instance = new NeuralRetouch( chain, surface );
 		instance._allocate();
 		return instance;
 
@@ -267,7 +268,7 @@ export class DLSSNeural {
 		const { validWidth, validHeight } = this.chain.pipeline.geometry;
 
 		this.source = this.device.createBuffer( {
-			label: 'rayzee:dlss-nr-source',
+			label: 'rayzee:retouch-source',
 			size: validWidth * validHeight * 8,
 			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
 		} );
@@ -276,34 +277,34 @@ export class DLSSNeural {
 
 		const bytes = validWidth * validHeight * 4;
 		this._readbackStorage = this.device.createBuffer( {
-			label: 'rayzee:dlss-nr-readback',
+			label: 'rayzee:retouch-readback',
 			size: bytes,
 			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
 		} );
 		this._readbackMap = this.device.createBuffer( {
-			label: 'rayzee:dlss-nr-readback-map',
+			label: 'rayzee:retouch-readback-map',
 			size: bytes,
 			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
 		} );
 		this._readbackPipeline = this.device.createComputePipeline( {
-			label: 'rayzee:dlss-nr-readback',
+			label: 'rayzee:retouch-readback',
 			layout: 'auto',
 			compute: { module: this.device.createShaderModule( { code: READBACK_WGSL } ), entryPoint: 'main' },
 		} );
 
 		const hdrBytes = validWidth * validHeight * 8;
 		this._hdrStorage = this.device.createBuffer( {
-			label: 'rayzee:dlss-nr-hdr',
+			label: 'rayzee:retouch-hdr',
 			size: hdrBytes,
 			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
 		} );
 		this._hdrMap = this.device.createBuffer( {
-			label: 'rayzee:dlss-nr-hdr-map',
+			label: 'rayzee:retouch-hdr-map',
 			size: hdrBytes,
 			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
 		} );
 		this._hdrPipeline = this.device.createComputePipeline( {
-			label: 'rayzee:dlss-nr-hdr',
+			label: 'rayzee:retouch-hdr',
 			layout: 'auto',
 			compute: { module: this.device.createShaderModule( { code: HDR_READBACK_WGSL } ), entryPoint: 'main' },
 		} );
@@ -317,8 +318,8 @@ export class DLSSNeural {
 		if ( ! texture ) {
 
 			throw new Error(
-				'DLSSNeural: the runtime has no scene-referred output. Either no frame has been produced yet, '
-				+ 'or dlss-runtime.js was re-vendored without the patch described in its PATCHES.md.'
+				'NeuralRetouch: the runtime has no scene-referred output. Either no frame has been produced yet, '
+				+ 'or neural-runtime.js was re-vendored without its `rayzee-patch` edits.'
 			);
 
 		}
@@ -331,7 +332,7 @@ export class DLSSNeural {
 			],
 		} );
 
-		const encoder = this.device.createCommandEncoder( { label: 'rayzee:dlss-nr-hdr' } );
+		const encoder = this.device.createCommandEncoder( { label: 'rayzee:retouch-hdr' } );
 		const pass = encoder.beginComputePass();
 		pass.setPipeline( this._hdrPipeline );
 		pass.setBindGroup( 0, group );
@@ -346,7 +347,7 @@ export class DLSSNeural {
 	 * The pass's result as scene-referred light, packed the way the upscaler wants it.
 	 *
 	 * Reads `hdrOutput`, the `rgba16float` texture the vendored runtime gained in
-	 * `app/public/dlss/PATCHES.md` — the value one statement before its own 8-bit store, so nothing
+	 * its `rayzee-patch` edits — the value one statement before its own 8-bit store, so nothing
 	 * has been clamped, quantised or pushed through the model's hardcoded ACES curve yet.
 	 *
 	 * This is what lets the pass run FIRST, at render size, where it is ~10x cheaper than on an
@@ -381,7 +382,7 @@ export class DLSSNeural {
 		const { validWidth: w, validHeight: h } = this.chain.pipeline.geometry;
 		await this._packHDR( w, h );
 
-		this._toneMapper ??= new PackedToneMapper( this.device, 'rayzee:dlss-nr-tonemap' );
+		this._toneMapper ??= new PackedToneMapper( this.device, 'rayzee:retouch-tonemap' );
 		this._toneMapper.ensureSize( w, h );
 
 		const rgba8 = await this._toneMapper.toRGBA8( this._hdrStorage, {
@@ -403,7 +404,7 @@ export class DLSSNeural {
 
 		const { validWidth: w, validHeight: h } = this.chain.pipeline.geometry;
 		const texture = this.chain.pipeline.slots[ this.slot ]?.output;
-		if ( ! texture ) throw new Error( 'DLSSNeural.readOutput: the pass has not produced a frame yet' );
+		if ( ! texture ) throw new Error( 'NeuralRetouch.readOutput: the pass has not produced a frame yet' );
 
 		const group = this.device.createBindGroup( {
 			layout: this._readbackPipeline.getBindGroupLayout( 0 ),
@@ -413,7 +414,7 @@ export class DLSSNeural {
 			],
 		} );
 
-		const encoder = this.device.createCommandEncoder( { label: 'rayzee:dlss-nr-readback' } );
+		const encoder = this.device.createCommandEncoder( { label: 'rayzee:retouch-readback' } );
 		const pass = encoder.beginComputePass();
 		pass.setPipeline( this._readbackPipeline );
 		pass.setBindGroup( 0, group );
@@ -477,7 +478,7 @@ const MAX_EXPOSURE = 20;
  * @param {{half: Uint16Array, width: number, height: number}} opts.source
  * @param {number} [opts.exposure=1] clamped to `MAX_EXPOSURE`
  * @param {{exposure: number, toneMapping: number, saturation: number}} [opts.tone] engine display state
- * @param {DLSSNeural} [opts.instance] reuse a network already built for this size
+ * @param {NeuralRetouch} [opts.instance] reuse a network already built for this size
  * @returns {Promise<object>} `{ instance, width, height, ms }` plus `rgba8` or `half`
  */
 export async function enhanceFrame( {
@@ -494,7 +495,7 @@ export async function enhanceFrame( {
 
 	if ( ! nr ) {
 
-		nr = await DLSSNeural.create( {
+		nr = await NeuralRetouch.create( {
 			width: source.width, height: source.height, settings, onProgress,
 		} );
 
@@ -505,7 +506,7 @@ export async function enhanceFrame( {
 
 	if ( ! source.half || source.half.length !== dst.length ) {
 
-		throw new Error( `DLSSNeural: expected ${dst.length} packed halfs, got ${source.half?.length}` );
+		throw new Error( `NeuralRetouch: expected ${dst.length} packed halfs, got ${source.half?.length}` );
 
 	}
 
@@ -519,7 +520,7 @@ export async function enhanceFrame( {
 	nr.chain.pipeline.colorStrength = colorStrength;
 
 	const started = performance.now();
-	const encoder = nr.device.createCommandEncoder( { label: 'rayzee:dlss-nr' } );
+	const encoder = nr.device.createCommandEncoder( { label: 'rayzee:retouch' } );
 	await nr.chain.encode( encoder, nr.slot, { buffer: nr.source }, merged, () => {}, { reset: true } );
 	nr.device.queue.submit( [ encoder.finish() ] );
 	await nr.device.queue.onSubmittedWorkDone();