dsh-deepseek-style-theme 2.0.84 → 2.0.86

package/THIRD-PARTY-NOTICES.md

@@ -23,16 +23,36 @@ dispersion / specular-parallax subsystem of **dsh-theme-mineradio v2.3.8**:
 Only naming and external dependencies were adapted: plugin-scoped identifiers
 were renamed to this plugin's `dshome-` prefix, and the upstream settings/theme
 store and React layer were replaced by function parameters. **The GLSL shader
-sources are copies of upstream, with one recorded deviation (v2.0.74): the
-`precision mediump float;` qualifier in FLOW_SHADER and DISPLAY_SHADER was
-changed to `precision highp float;`.** The reason is a rendering defect, not a
-feature: under ANGLE/D3D11 on Intel integrated GPUs `mediump` is a real 16-bit
-float (`min16float`), and the display shader's noise --
-`fract(sin(dot(st, vec2(12.9898,78.233))) * 43758.5453123)` -- needs roughly 24
-bits of mantissa, so at 16 bits the hash collapses into constant plateaus and the
-noise lattice shows up as large drifting squares. WebGL2 guarantees highp in
-fragment shaders, and on GPUs that promoted mediump to 32 bits the change is a
-no-op. Every other line of every shader is unchanged.
+sources are copies of upstream, with two recorded deviations:**
+
+1. **(v2.0.74)** the `precision mediump float;` qualifier in FLOW_SHADER and
+   DISPLAY_SHADER was changed to `precision highp float;`. The reason is a
+   rendering defect, not a feature: under ANGLE/D3D11 on Intel integrated GPUs
+   `mediump` is a real 16-bit float (`min16float`), and the display shader's noise
+   needs roughly 24 bits of mantissa, so at 16 bits the hash collapses into
+   constant plateaus and the noise lattice shows up as large drifting squares.
+   WebGL2 guarantees highp in fragment shaders, and on GPUs that promoted mediump
+   to 32 bits the change is a no-op.
+2. **(v2.0.86)** DISPLAY_SHADER's `random(vec2 st)` -- upstream's classic
+   `fract(sin(dot(st, vec2(12.9898,78.233))) * 43758.5453123)` -- was replaced by
+   Dave Hoskins' sin-free hash (`fract(vec3(p.xyx) * 0.1031)` plus one dot and one
+   multiply). The reason is the same class of defect, one layer down and this time
+   precision-independent: this shader scales the noise coordinate to ~1e5
+   (`uv *= ns * u_resolution`, doubled again for `n2`), and at that magnitude the
+   error left by `sin()`'s argument reduction in float32 is multiplied by 43758
+   into ~100 units, so neighbouring cells receive nearly the same value and the
+   warp field degenerates into flat plateaus with hard edges (measured on an Intel
+   Arc 130V: 39.6% flat 8x8 blocks, an 800x1000px plateau, 60-90/255 jumps along
+   its boundary -- the user's 大方块). The sin-free hash keeps every intermediate
+   small, so it behaves identically on every GPU, and it preserves upstream's
+   per-cell white noise rather than shrinking the domain warp (which would cure the
+   symptom by removing the effect). `noise()`'s interpolation and every other line
+   of every shader are unchanged.
+
+The two deviations are related on purpose: deviation 1 fixed a 16-bit intermediate
+precision collapse, deviation 2 the 32-bit argument-magnitude collapse that
+survived it. Both were diagnosed from the same symptom on the same machine class,
+and both were verified there rather than assumed.
 
 Upstream notes that its fluid shader is itself a faithful port of the
 `ds-join-shader-bg` shader in the deepseek.com site bundle, with the shader

package/lib/client.js

@@ -238,7 +238,27 @@ out vec4 fragColor;
 #define PI 3.14159265358979323846
 
 vec2 rotate(vec2 uv, float th) { return mat2(cos(th), sin(th), -sin(th), cos(th)) * uv; }
-float random(vec2 st) { return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123); }
+/* Upstream's hash is the classic fract(sin(dot(st, vec2(12.9898, 78.233))) * 43758.5453123)
+   -- no backticks in this comment: it lives inside a template literal, and a pair of
+   them ends the literal (tools/parse-smoke.mjs exists because that has happened three
+   times). Its argument is NOT small in this shader: uv is scaled by ns * u_resolution
+   (about 2900 at the user's viewport) and doubled again for n2, so dot() reaches ~2e5.
+   At that magnitude float32 leaves ~2.5e-3 of error inside sin(), the 43758x multiplier
+   turns it into ~100 units, and the hash stops behaving like a hash: neighbouring cells
+   receive almost the same value, so the warp field degenerates into flat plateaus with
+   hard edges -- the 大方块 of the 2026-09-16 fluid report, measured on an Intel Arc 130V
+   as 39.6% flat 8x8 blocks, an 800x1000px plateau, and 60-90/255 jumps along its
+   boundary (the two earlier fixes, mediump -> highp and RGBA8 -> RGBA16F, were both
+   verified active on that machine and the blocks survived, which is what pointed here).
+   This is Dave Hoskins' sin-free hash: every intermediate stays small, so it behaves the
+   same on every GPU and keeps upstream's per-cell white noise instead of deleting the
+   domain warp (the ablation's noDistort variant cures the symptom by removing the
+   effect). Recorded as deviation #2 in THIRD-PARTY-NOTICES.md. */
+float random(vec2 st) {
+  vec3 p3 = fract(vec3(st.xyx) * 0.1031);
+  p3 += dot(p3, p3.yzx + 33.33);
+  return fract((p3.x + p3.y) * p3.z);
+}
 float noise(vec2 st) {
   vec2 i = floor(st); vec2 f = fract(st);
   float a = random(i), b = random(i + vec2(1,0)), c = random(i + vec2(0,1)), d = random(i + vec2(1,1));
@@ -758,7 +778,16 @@ void main() {
 		// a separate constant so the frosted recipe keeps receiving 60.
 		var LIQUID_REF_SCALE = 104;
 		var EDGE_DX = -14;
-		var TINT_OPACITY = 0.45;
+		// The lens tint. It is mixed into `|backdrop - backdrop shifted by EDGE_DX|`,
+		// which is meant to be non-zero only along a hard edge -- but over a GRADIENT
+		// backdrop (the `bold` background recipe is exactly that) the difference is
+		// non-zero across the WHOLE pane, so the tint stopped being an edge fringe and
+		// became a wash: the first user to see it (2.0.84 restored the mount after ATTR
+		// had been missing since 1.43.6) reported "我的玻璃怎么变成凝胶了" with a
+		// screenshot of a solid pink composer. 0.45 -> 0.16 keeps the fringing (that
+		// comes from the per-channel chromatic displacement, not from the tint) while
+		// the wash drops to a hint.
+		var TINT_OPACITY = 0.16;
 		var TINT_SAT = 0.85;
 		var TINT_LIGHT = 0.6;
 		var DEFAULT_TINT_HUE = 44;
@@ -2378,12 +2407,37 @@ html[data-dshome-blur="off"] body{
 		//     recipe. Both recipes tilt now, and because the liquid sheet used to be
 		//     the only place carrying `transition: transform`, the motion carries
 		//     its own transition (TILT_TRANSITION) so a recipe cannot lose it.
+		//   * 2.0.85 makes ENGAGEMENT GEOMETRIC and the gates honest. Engagement used
+		//     to need a `pointerover` whose target was inside the card; that is a
+		//     chain of assumptions about product markup (a wrapper with role=button,
+		//     a swapped card node, a portal, an overlay) which a theme cannot verify,
+		//     and failing it looks exactly like a broken effect -- reported as
+		//     "把我的对话框随着鼠标位置而变化的效果补回来". `spotAt()` decides from the
+		//     card's own rectangle on every pointermove, so a missed event costs one
+		//     frame instead of the whole effect; `controlAt()` remains the single hit
+		//     test, and only to answer "is a control under the pointer". The two
+		//     SILENT gates are reported now: `__dshomeTilt()` includes `reducedMotion`
+		//     (an OS setting that disables the effect and looks like a bug) and
+		//     `spots` (0 means the composer no longer matches TILT_SELECTOR), and the
+		//     reduced-motion case logs one info line instead of vanishing.
 		const TILT_SELECTOR = '[data-composer-card],.uV2eYG_card';
-		const TILT_MAX = 0.0175;
+		// 0.0175 rad was upstream's conservative lean, and after 2.0.85 finally made
+		// the effect reachable the verdict was "倾斜效果很微弱" -- fair, at ~4 degrees
+		// end to end over a pane this wide it reads as a wobble, not as depth. Raised
+		// ~1.7x, with TILT_RELEASE_PAD keeping the stronger movement from feeding a loop.
+		const TILT_MAX = 0.03;
 		const TILT_PERSPECTIVE = 800;
-		const TILT_SCALE = 1.01;
+		const TILT_SCALE = 1.015;
 		const TILT_SETTLE_MS = 240;
 		const TILT_COOLDOWN_MS = 200;
+		/**
+		* How far outside the card's own rectangle the pointer must travel before the
+		* lean is released. Engagement is geometric (see spotAt), so without a pad the
+		* lean's own movement could carry the card's edge past a stationary pointer:
+		* out -> release -> back in -> engage, at frame rate. 8px is comfortably more
+		* than the lift moves an edge (1.5% of a ~112px pane is under 2px).
+		*/
+		const TILT_RELEASE_PAD = 8;
 		/** The lean's own easing. Mirrors the liquid sheet's values, and is removed
 		* together with the inline transform so nothing keeps animating afterwards. */
 		const TILT_TRANSITION = 'transform .24s cubic-bezier(.2,.8,.2,1),background-color .18s ease,box-shadow .18s ease';
@@ -2407,13 +2461,28 @@ html[data-dshome-blur="off"] body{
 			const tilted = new WeakSet();
 			const settle = new Map();
 			const reduced = typeof window.matchMedia === 'function' && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
-			if (reduced) return () => {};
-			// Readable from the page: the effect is guarded twice, so "it is missing"
-			// is otherwise a guess about which guard ate it. `__dshomeTilt()` answers
-			// that in one call (and reports the recipe it is running under).
+			// Readable from the page: the effect is guarded several times over, so "it
+			// is missing" is otherwise a guess about which guard ate it.
+			// `__dshomeTilt()` answers that in one call -- including the two SILENT
+			// gates, which is why `reduced` and `spots` are in here at all: an OS-level
+			// "reduce motion" or a composer whose markup no longer matches
+			// TILT_SELECTOR both look exactly like a broken effect.
 			try {
-				window.__dshomeTilt = () => ({ recipe: dsttGetGlass(), leaning: current !== null, frozen, engagements, sinceRelease: releasedAt === -Infinity ? null : Math.round(performance.now() - releasedAt) });
+				window.__dshomeTilt = () => ({
+					recipe: dsttGetGlass(),
+					reducedMotion: reduced,
+					spots: document.querySelectorAll(TILT_SELECTOR).length,
+					leaning: current !== null,
+					frozen,
+					engagements,
+					sinceRelease: releasedAt === -Infinity ? null : Math.round(performance.now() - releasedAt)
+				});
 			} catch (error) {}
+			if (reduced) {
+				// Never silent: this is the one gate a user cannot see in any setting.
+				console.info('[dsh-deepseek-style-theme] composer tilt disabled: the system asks for reduced motion (prefers-reduced-motion: reduce)');
+				return () => {};
+			}
 			const release = (spot) => {
 				const pending = settle.get(spot);
 				if (pending !== undefined) {
@@ -2452,21 +2521,48 @@ html[data-dshome-blur="off"] body{
 					tilted.add(spot);
 				});
 			};
+			/**
+			* Which tilt spot contains a point, by RECTANGLE -- deliberately not by
+			* walking `event.target` up to a selector. Engagement used to depend on a
+			* `pointerover` whose target was inside the card, and that is a chain of
+			* assumptions about the product's markup (a wrapper with role=button, a
+			* swapped-in card node, a portal, an overlay) that a theme cannot verify.
+			* The reported symptom of getting it wrong is indistinguishable from a
+			* broken effect: the box just never leans. Geometry is the one thing the
+			* theme can measure for itself.
+			*/
+			const spotAt = (clientX, clientY) => {
+				for (const spot of document.querySelectorAll(TILT_SELECTOR)) {
+					const rect = spot.getBoundingClientRect();
+					if (rect.width <= 0 || rect.height <= 0) continue;
+					if (clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom) continue;
+					return { spot, rect };
+				}
+				return null;
+			};
+			/** The topmost element at a point, used only to decide "is this a control". */
+			const controlAt = (clientX, clientY) => {
+				let node = null;
+				try { node = document.elementFromPoint(clientX, clientY); } catch (error) { node = null; }
+				if (node === null || typeof node.closest !== 'function') return false;
+				return node.closest(TILT_CONTROLS) !== null;
+			};
 			const onOver = (event) => {
+				// Kept for the one thing it does better than a move: it fires the
+				// moment the pointer arrives, before any movement. Everything it
+				// decides is re-derived from geometry, so a missed event costs one
+				// frame, not the effect.
 				const target = event.target;
 				if (target === null || typeof target.closest !== 'function') return;
 				const spot = target.closest(TILT_SELECTOR);
 				if (spot === null) return;
-				// A control is under the pointer: hold the lean exactly where it is.
-				// Releasing here is what used to feed the ~8 Hz hover loop.
-				if (target.closest(TILT_CONTROLS) !== null) {
+				const rect = spot.getBoundingClientRect();
+				if (event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom) return;
+				if (controlAt(event.clientX, event.clientY)) {
 					if (current === spot) frozen = true;
 					return;
 				}
-				// The cooldown gates a fresh engagement only, never an ongoing lean.
 				if (!tilted.has(spot) && performance.now() - releasedAt < TILT_COOLDOWN_MS) return;
-				const rect = spot.getBoundingClientRect();
-				if (event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom) return;
 				const pending = settle.get(spot);
 				if (pending !== undefined) {
 					clearTimeout(pending);
@@ -2477,24 +2573,48 @@ html[data-dshome-blur="off"] body{
 				paint(spot, rect, event.clientX, event.clientY);
 			};
 			const onMove = (event) => {
-				if (current === null) return;
-				const target = event.target;
-				if (target !== null && typeof target.closest === 'function' && target.closest(TILT_CONTROLS) !== null) {
-					frozen = true;
+				const hit = spotAt(event.clientX, event.clientY);
+				if (hit === null) {
+					// Off the card: release the lean, but only past the release pad --
+					// the lean's own movement must not be able to hand the card back
+					// and forth under a stationary pointer.
+					if (current !== null) {
+						const rect = current.getBoundingClientRect();
+						const outside = event.clientX < rect.left - TILT_RELEASE_PAD || event.clientX > rect.right + TILT_RELEASE_PAD
+							|| event.clientY < rect.top - TILT_RELEASE_PAD || event.clientY > rect.bottom + TILT_RELEASE_PAD;
+						if (outside) {
+							release(current);
+							current = null;
+						}
+					}
+					return;
+				}
+				const { spot, rect } = hit;
+				if (controlAt(event.clientX, event.clientY)) {
+					// A control is under the pointer: hold the lean exactly where it is
+					// (releasing here is what used to feed the ~8 Hz hover loop).
+					if (current === spot) frozen = true;
 					return;
 				}
+				// The cooldown gates a fresh engagement only, never an ongoing lean.
+				if (!tilted.has(spot) && current !== spot && performance.now() - releasedAt < TILT_COOLDOWN_MS) return;
+				if (current !== spot) {
+					if (current !== null) release(current);
+					const pending = settle.get(spot);
+					if (pending !== undefined) {
+						clearTimeout(pending);
+						settle.delete(spot);
+					}
+					current = spot;
+				}
 				frozen = false;
-				paint(current, current.getBoundingClientRect(), event.clientX, event.clientY);
+				paint(spot, rect, event.clientX, event.clientY);
 			};
 			const onOut = (event) => {
 				if (current === null) return;
-				const target = event.target;
-				if (target !== null && typeof target.closest === 'function') {
-					const spot = target.closest(TILT_SELECTOR);
-					if (spot !== null && spot !== current) return;
-				}
 				const rect = current.getBoundingClientRect();
-				if (event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom) return;
+				if (event.clientX >= rect.left - TILT_RELEASE_PAD && event.clientX <= rect.right + TILT_RELEASE_PAD
+					&& event.clientY >= rect.top - TILT_RELEASE_PAD && event.clientY <= rect.bottom + TILT_RELEASE_PAD) return;
 				release(current);
 				current = null;
 			};
@@ -2531,7 +2651,7 @@ html[data-dshome-blur="off"] body{
 			if (!supportsWebgl2()) return startParticles();
 			// Which build is running, readable from the page (see README). One line in
 			// the console answers "is the bundle I just installed actually live?".
-			try { window.__dshomeBuild = '2.0.84 bug-report-fixes'; } catch (error) {}
+			try { window.__dshomeBuild = '2.0.86 glass-on noise-fix'; } catch (error) {}
 			const canvas = document.createElement('canvas');
 			canvas.setAttribute('data-dsh-deepseek-canvas', '');
 			const style = canvas.style;
@@ -2573,17 +2693,6 @@ html[data-dshome-blur="off"] body{
 			// `attachFluidInteractions` is therefore NOT wired — it is kept in the
 			// file, unmodified, because re-enabling button ripples is one call, but
 			// nothing in this theme uses it today.
-			const stopSpotter = startSpecularSpotter();
-			const stopParallax = startSpecularParallax();
-			const dispersion = startGlassDispersion({ hue: FLUID_HUES[dshomeColor()] });
-			// Both recipes share one filter pair, so the recipe selects the scale:
-			// 104 for liquid (visible edge refraction) and the untouched 60 for
-			// frosted, which is what the pane has always used.
-			const applyGlass = () => {
-				dispersion.setRefraction(dsttGetGlass() === 'liquid' ? LIQUID_REF_SCALE : DEFAULT_REF_SCALE);
-			};
-			applyGlass();
-			const unsubscribeGlass = dsttSubscribe(applyGlass);
 			// ── palette reconciliation ────────────────────────────────────────────
 			// One reader for BOTH inputs the palette depends on: the colour token on
 			// <body> and the dark marker. Reported symptom: "切主题模式背景不变 /
@@ -2608,7 +2717,6 @@ html[data-dshome-blur="off"] body{
 			};
 			const unsubscribeColor = subscribeColor((color) => {
 				syncFluid();
-				try { dispersion.setTint(FLUID_HUES[color] ?? FLUID_HUES.green); } catch (error) {}
 			});
 			const unsubscribeDark = darkSync === null ? null : darkSync.subscribe(syncFluid);
 			// The colour driver writes the token as an attribute; watching it as well
@@ -2624,19 +2732,90 @@ html[data-dshome-blur="off"] body{
 			return () => {
 				unsubscribeColor();
 				if (unsubscribeDark !== null) unsubscribeDark();
+				if (tokenMirror !== null) tokenMirror.disconnect();
+				clearInterval(fluidSync);
+				fluid.dispose();
+				canvas.remove();
+			};
+		}
+
+		/**
+		* The cursor-following half of the glass: the specular spotter (which marks
+		* the surfaces the highlight may land on), the parallax that writes
+		* `--dshome-spec-x/y` for the hovered surface, and the SVG edge refraction.
+		*
+		* These used to be mounted INSIDE {@link startAmbient}, which tied them to
+		* the fluid layer: turning 「动态背景」 off -- which is exactly what the user
+		* did to stop the iGPU squares -- or choosing ③ 自选背景, or landing on an
+		* engine without WebGL2 (the particle fallback returns before them), silently
+		* took the dialog's cursor-following highlight and its edge refraction with
+		* it. Reported as "把我的对话框随着鼠标位置而变化的效果补回来". They belong to
+		* the glass, not to the flow field, so they mount on their own and survive
+		* every background recipe.
+		*/
+		function startGlassExtras() {
+			const stopSpotter = startSpecularSpotter();
+			const stopParallax = startSpecularParallax();
+			/**
+			* The refraction is OPT-IN, and `off` means "do not mount it at all".
+			*
+			* Two measured reasons, both from the user's machine (2.0.84, the first
+			* build that mounted it since 1.43.6): the tint washed the whole composer
+			* ("玻璃怎么变成凝胶了"), and the SVG filter inside `backdrop-filter` took the
+			* BLUR down with it -- a `url()` that fails to render invalidates the whole
+			* declaration, so the pane lost its frost and read as plain translucency
+			* ("没有背景模糊效果"). A decorative filter must never be able to cost a
+			* surface its glass, so the chain stays out of the DOM unless asked for, and
+			* the switch covers all four surfaces rather than only the composer.
+			*/
+			const dispersion = dsttGetComposer() === 'off'
+				? { setTint() {}, setRefraction() {}, dispose() {} }
+				: startGlassDispersion({ hue: FLUID_HUES[dshomeColor()] });
+			// Readable from the page, next to __dshomeBuild / __dshomeFluidFormat /
+			// __dshomeTilt: "is the refraction in the DOM, and what is driving it" is
+			// the first question any glass report needs answered.
+			try {
+				window.__dshomeDispersion = () => ({
+					composer: dsttGetComposer(),
+					mounted: document.documentElement.hasAttribute(ATTR),
+					filters: document.querySelectorAll('svg filter').length,
+					recipe: dsttGetGlass()
+				});
+			} catch (error) {}
+			// Both recipes share one filter pair, so the recipe selects the scale:
+			// 104 for liquid (visible edge refraction) and the untouched 60 for
+			// frosted, which is what the pane has always used.
+			const applyGlass = () => {
+				dispersion.setRefraction(dsttGetGlass() === 'liquid' ? LIQUID_REF_SCALE : DEFAULT_REF_SCALE);
+			};
+			applyGlass();
+			const unsubscribeGlass = dsttSubscribe(applyGlass);
+			// The tint follows the DSTT colour token. Same belt-and-braces as the
+			// fluid palette: subscribe AND watch the attribute the driver writes,
+			// because the colour driver writes it before this mount exists.
+			const syncTint = () => {
+				try { dispersion.setTint(FLUID_HUES[dshomeColor()] ?? FLUID_HUES.green); } catch (error) {}
+			};
+			const unsubscribeColor = subscribeColor(syncTint);
+			let tokenMirror = null;
+			try {
+				tokenMirror = new MutationObserver(syncTint);
+				tokenMirror.observe(document.body, { attributes: true, attributeFilter: ['data-dshome-color'] });
+			} catch (error) {
+				tokenMirror = null;
+			}
+			return () => {
+				unsubscribeColor();
 				unsubscribeGlass();
 				if (tokenMirror !== null) tokenMirror.disconnect();
 				dispersion.dispose();
 				stopParallax();
 				stopSpotter();
-				clearInterval(fluidSync);
-				fluid.dispose();
-				canvas.remove();
 			};
 		}
 
 		function startParticles() {
-			try { window.__dshomeBuild = '2.0.84 bug-report-fixes'; } catch (error) {}
+			try { window.__dshomeBuild = '2.0.86 glass-on noise-fix'; } catch (error) {}
 			const canvas = document.createElement('canvas');
 			canvas.setAttribute('data-dsh-deepseek-canvas', '');
 			const style = canvas.style;
@@ -4029,7 +4208,7 @@ body[data-dshome-dark] .${CLS}{background:rgba(14,30,60,.94);box-shadow:0 18px 4
 		// `origin` was this option's first id and is still accepted from a settings
 		// file written before the rename; it reads back as `wide`.
 		const DSTT_COMPOSER = ["narrow", "wide", "off"];
-		const DSTT_COMPOSER_DEFAULT = "narrow";
+		const DSTT_COMPOSER_DEFAULT = "off";
 		const DSTT_COMPOSER_LABELS = {
 			narrow: { zh: "窄 8px", en: "Narrow 8px" },
 			wide: { zh: "宽 16px", en: "Wide 16px" },
@@ -4943,6 +5122,18 @@ body[data-dshome-dark] .${CLS}{background:rgba(14,30,60,.94);box-shadow:0 18px 4
 					if (stop !== null) { try { stop(); } catch (error) {} }
 				};
 			}, 'deepseek-style-theme: fluid background');
+			// The cursor-following half of the glass mounts ON ITS OWN, with no
+			// dependence on the fluid layer: see startGlassExtras for why (turning
+			// 「动态背景」 off, or ③ 自选背景, or a machine without WebGL2 used to take
+			// the dialog's cursor-following highlight and the edge refraction with it).
+			ctx.effect(() => {
+				try {
+					return startGlassExtras();
+				} catch (error) {
+					console.error('[dsh-deepseek-style-theme] glass extras failed to mount:', error);
+					return () => {};
+				}
+			}, 'deepseek-style-theme: glass extras (specular + dispersion)');
 			// The composer's hover tilt is independent of the background: it must
 			// survive a machine without WebGL2, where startAmbient() falls back to
 			// the 2D particle field.