shaders 3.0.443 → 3.0.444

package/dist/js/createShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createShader.d.ts","sourceRoot":"","sources":["../src/createShader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,cAAc,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAgC5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,cAAc,CAAC,CAuXzB"}
+{"version":3,"file":"createShader.d.ts","sourceRoot":"","sources":["../src/createShader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,cAAc,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAgC5D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,cAAc,CAAC,CAgczB"}

package/dist/js/createShader.js

@@ -1,4 +1,4 @@
-import { createGpuUniformsMap, resolveBoundingBox, rootPassthrough, shaderRendererGPU } from "../core/index.js";
+import { createGpuUniformsMap, debugError, resolveBoundingBox, rootPassthrough, shaderRendererGPU } from "../core/index.js";
 import { getAllShaders } from "../core/registry.js";
 import { isExternalUser, startTelemetry } from "../core/telemetry/index.js";
 function isPropDriver(value) {
@@ -42,6 +42,25 @@ async function createShader(canvas, preset, options) {
 	let current = null;
 	let destroyed = false;
 	let rebuilding = false;
+	const MAX_DEVICE_LOSS_REBUILDS = 3;
+	const DEVICE_LOSS_BURST_WINDOW_MS = 6e4;
+	let rebuildAttempts = 0;
+	let lastDeviceLossAt = 0;
+	let unavailable = null;
+	function notify(reason) {
+		try {
+			options?.onError?.(reason);
+		} catch (e) {
+			debugError("[createShader] onError callback threw:", e);
+		}
+	}
+	let reportedTerminal = false;
+	function goDown(reason) {
+		if (reportedTerminal) return;
+		reportedTerminal = true;
+		unavailable = reason;
+		notify(reason);
+	}
 	function registerComponent(renderer, nodeEntryMap, component, parentId, renderOrder) {
 		const componentDef = componentRegistry.get(component.type);
 		if (!componentDef) {
@@ -94,6 +113,10 @@ async function createShader(canvas, preset, options) {
 		const renderer = shaderRendererGPU();
 		const nodeEntryMap = /* @__PURE__ */ new Map();
 		if (options?.onReady) renderer.setOnReady(options.onReady);
+		renderer.setOnUnavailable((reason) => {
+			if (destroyed) return;
+			goDown(reason);
+		});
 		await renderer.initialize({
 			canvas,
 			resizeTarget: canvas,
@@ -110,13 +133,19 @@ async function createShader(canvas, preset, options) {
 			telemetryStartTimeout: null
 		};
 		renderer.setOnDeviceLost((reason) => {
-			if (destroyed || rebuilding) return;
+			if (destroyed || rebuilding || unavailable) return;
 			if (current !== null && current !== state) return;
 			rebuilding = true;
-			try {
-				options?.onError?.(reason);
-			} catch (e) {
-				console.error("[createShader] onError callback threw:", e);
+			notify(reason);
+			const now = Date.now();
+			if (now - lastDeviceLossAt > DEVICE_LOSS_BURST_WINDOW_MS) rebuildAttempts = 0;
+			lastDeviceLossAt = now;
+			if (++rebuildAttempts > MAX_DEVICE_LOSS_REBUILDS) {
+				teardownState(state);
+				current = null;
+				rebuilding = false;
+				goDown("unrecoverable");
+				return;
 			}
 			(async () => {
 				try {
@@ -130,10 +159,8 @@ async function createShader(canvas, preset, options) {
 					}
 					current = next;
 				} catch (rebuildErr) {
-					console.error("[createShader] rebuild after device loss failed:", rebuildErr);
-					try {
-						options?.onError?.("rebuild_failed");
-					} catch {}
+					debugError("[createShader] rebuild after device loss failed:", rebuildErr);
+					goDown("rebuild_failed");
 				} finally {
 					rebuilding = false;
 				}
@@ -145,13 +172,15 @@ async function createShader(canvas, preset, options) {
 			registerComponent(renderer, nodeEntryMap, component, rootId, index);
 		});
 		if (isExternalUser()) {
+			const MAX_TELEMETRY_POLLS = 40;
+			let telemetryPolls = 0;
 			const checkRendering = () => {
-				if (destroyed || current !== state) {
+				if (destroyed || unavailable || current !== state || ++telemetryPolls > MAX_TELEMETRY_POLLS) {
 					state.telemetryStartTimeout = null;
 					return;
 				}
 				if (renderer.getPerformanceStats().fps > 0) {
-					state.telemetryCollector = startTelemetry(renderer, "3.0.443", options?.disableTelemetry || false, false);
+					state.telemetryCollector = startTelemetry(renderer, "3.0.444", options?.disableTelemetry || false, false);
 					if (state.telemetryCollector) state.telemetryCollector.start();
 					state.telemetryStartTimeout = null;
 				} else state.telemetryStartTimeout = setTimeout(checkRendering, 500);
@@ -249,7 +278,8 @@ async function createShader(canvas, preset, options) {
 		resize,
 		pause,
 		resume,
-		destroy
+		destroy,
+		getFailureReason: () => unavailable
 	};
 }
 export { createShader };

package/dist/js/createSharedDevice.d.ts

@@ -1,14 +1,16 @@
 /**
- * Create a shared GPU device + adapter that can be passed to multiple
- * `createShader` calls via the `gpu` option. Sharing a device lets WebGPU's
- * pipeline cache, resource pools, and submission queue be reused across
- * shader instances — first-paint compile cost amortizes (the same shader's
- * pipeline is compiled once, not once per instance), submission overhead
- * drops, and the page stays under browser-imposed context limits.
+ * Create a GPU device + adapter you own, to pass to `createShader` via the `gpu`
+ * option.
  *
- * Recommended for pages that load many shader instances (e.g., a design
- * tool with multiple shader tiles). For a single shader instance there's
- * no benefit and you can skip this entirely.
+ * **You almost certainly don't need this.** Device sharing is automatic: every
+ * shader on a page already adopts one lazily-created device, so pipelines compile
+ * once for the page and survive component unmounts (which is what keeps SPA route
+ * changes fast). Calling this changes *who owns* the device, not whether sharing
+ * happens.
+ *
+ * Reach for it only when you need explicit control — interoperating with another
+ * WebGPU renderer that must share the same device, requesting a specific
+ * `powerPreference`, or managing the device's lifetime yourself.
  *
  * Returns `null` if WebGPU is unavailable on this device — in that case
  * callers should pass no `gpu` option and let each shader fall back to its

package/dist/js/createSharedDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSharedDevice.d.ts","sourceRoot":"","sources":["../src/createSharedDevice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,CAAC,EAAE;IACR,gFAAgF;IAChF,eAAe,CAAC,EAAE,kBAAkB,CAAA;CACrC,GACA,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GAAG,IAAI,CAAC,CA4B5D"}
+{"version":3,"file":"createSharedDevice.d.ts","sourceRoot":"","sources":["../src/createSharedDevice.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,CAAC,EAAE;IACR,gFAAgF;IAChF,eAAe,CAAC,EAAE,kBAAkB,CAAA;CACrC,GACA,OAAO,CAAC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GAAG,IAAI,CAAC,CA+B5D"}

package/dist/js/createSharedDevice.js

@@ -1,3 +1,4 @@
+import { debugWarn } from "../core/index.js";
 async function createSharedDevice(options) {
 	if (typeof navigator === "undefined" || !navigator.gpu) return null;
 	try {
@@ -8,7 +9,7 @@ async function createSharedDevice(options) {
 			adapter
 		};
 	} catch (err) {
-		console.warn("[shaders] createSharedDevice failed; callers should fall back to per-instance device:", err);
+		debugWarn("[shaders] createSharedDevice failed; callers should fall back to per-instance device:", err);
 		return null;
 	}
 }

package/dist/js/index.d.ts

@@ -3,4 +3,6 @@ export { createPreview } from './createPreview';
 export { createSharedDevice } from './createSharedDevice';
 export type { ShaderInstance, ShaderOptions, PreviewOptions } from './types';
 export type { PresetConfig, ComponentConfig } from '../core';
+export { isWebGPUSupported, getWebGPUSupport, setShadersDebug, isShadersDebug } from '../core';
+export type { GpuFailureReason, WebGPUSupportInfo } from '../core';
 //# sourceMappingURL=index.d.ts.map

package/dist/js/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACzD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC5E,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACzD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC5E,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAIjE,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AACnG,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA"}

package/dist/js/index.js

@@ -1,4 +1,5 @@
 import { createShader } from "./createShader.js";
 import { createPreview } from "./createPreview.js";
 import { createSharedDevice } from "./createSharedDevice.js";
-export { createPreview, createShader, createSharedDevice };
+import { getWebGPUSupport, isShadersDebug, isWebGPUSupported, setShadersDebug } from "../core/index.js";
+export { createPreview, createShader, createSharedDevice, getWebGPUSupport, isShadersDebug, isWebGPUSupported, setShadersDebug };

package/dist/js/types.d.ts

@@ -7,17 +7,37 @@ export interface ShaderOptions {
     isPreview?: boolean;
     onReady?: () => void;
     /**
-     * Fires when the underlying GPU device/context is lost — e.g. Chrome
-     * evicting a backgrounded tab's WebGPU device, an OS-level GPU reset,
-     * driver crash, or `webglcontextlost` on the WebGL fallback path. By the
-     * time this callback runs the instance has already started rebuilding
-     * itself transparently against the same canvas and preset; the existing
-     * `update / pause / resume / resize / destroy` references continue to work
-     * once the rebuild completes. The callback is informational — surface a
-     * toast, write a log, no action required.
+     * Fires when something goes wrong with the GPU. Two flavours:
      *
-     * @param reason Best-effort string from the underlying API
-     *   (e.g. `'destroyed'`, `'webglcontextlost'`, GPU error message).
+     * **Recoverable** — the device was lost (Chrome evicting a backgrounded tab's
+     * WebGPU device, an OS-level GPU reset, a driver crash). By the time this runs
+     * the instance has already started rebuilding itself transparently against the
+     * same canvas and preset; your existing `update / pause / resume / resize /
+     * destroy` references keep working once the rebuild completes. Informational —
+     * surface a toast, write a log, no action required. `reason` is a best-effort
+     * string from the underlying API.
+     *
+     * **Terminal** — the shader will never draw and has released everything. The
+     * canvas is left as-is (transparent, if it never rendered). This is the moment
+     * to swap in a static fallback. `reason` is one of:
+     *
+     * - `'unsupported'`    — the browser has no WebGPU at all
+     * - `'no-adapter'`     — WebGPU exists but no GPU adapter was granted
+     * - `'no-device'`      — an adapter exists but the device request failed
+     * - `'init-failed'`    — start-up threw for some other reason
+     * - `'device-lost'`    — lost with no recovery possible
+     * - `'out-of-memory'`  — the GPU refused an allocation
+     * - `'gpu-error'`      — sustained device errors; the GPU is not usable
+     * - `'render-failed'`  — repeated exceptions while composing or drawing
+     * - `'limit-exceeded'` — the composition needs more of some GPU resource than this device
+     *                        allows (today: more uniform bytes than a single binding permits).
+     *                        Unlike the others this is about the CONTENT — fewer layers would run
+     * - `'unrecoverable'`  — too many device losses in a row; we stopped retrying
+     * - `'rebuild_failed'` — a device-loss rebuild itself failed
+     *
+     * A terminal reason is reported exactly once. Check {@link isWebGPUSupported} or
+     * `getWebGPUSupport()` before mounting if you'd rather not create the shader at
+     * all on an unsupported browser.
      */
     onError?: (reason: string) => void;
     /** When false, disables automatic ResizeObserver and IntersectionObserver.
@@ -93,6 +113,16 @@ export interface PreviewInstance extends ShaderInstance {
     setConfiguration(configuration: Record<string, unknown>): void;
 }
 export interface ShaderInstance {
+    /**
+     * Why the shader gave up, or `null` while it is healthy. Non-null means the canvas will
+     * never draw and every GPU resource has been released — `update / resize / pause / resume`
+     * become safe no-ops from that point on.
+     *
+     * The same value is delivered to {@link ShaderOptions.onError} the moment it happens; this
+     * is the pull-based equivalent, for code that runs later and just wants to ask (a fallback
+     * component mounting after the shader, a health check, a test).
+     */
+    getFailureReason(): string | null;
     update(componentId: string, props: Record<string, any>): void;
     /**
      * Sync the renderer to the canvas's current dimensions.

package/dist/js/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEjE,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,WAAW,GAAG,MAAM,CAAA;IACjC,WAAW,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAA;IAChG,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;;;kBAKc;IACd,GAAG,CAAC,EAAE;QACJ,MAAM,EAAE,SAAS,CAAA;QACjB,OAAO,EAAE,UAAU,CAAA;KACpB,CAAA;CACF;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAA;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,iGAAiG;IACjG,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC/D;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAA;IAC7D;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7C,mFAAmF;IACnF,KAAK,IAAI,IAAI,CAAA;IACb,kDAAkD;IAClD,MAAM,IAAI,IAAI,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEjE,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,EAAE,WAAW,GAAG,MAAM,CAAA;IACjC,WAAW,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAA;IAChG,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;;;kBAKc;IACd,GAAG,CAAC,EAAE;QACJ,MAAM,EAAE,SAAS,CAAA;QACjB,OAAO,EAAE,UAAU,CAAA;KACpB,CAAA;CACF;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAA;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,iGAAiG;IACjG,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC/D;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;;;;OAQG;IACH,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAAA;IACjC,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAA;IAC7D;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7C,mFAAmF;IACnF,KAAK,IAAI,IAAI,CAAA;IACb,kDAAkD;IAClD,MAAM,IAAI,IAAI,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB"}

package/dist/react/Shader.js

@@ -1,10 +1,10 @@
 import { createContext, useEffect, useId, useMemo, useRef } from "react";
-import { rootPassthrough, shaderRendererGPU } from "../core/index.js";
+import { debugWarn, rootPassthrough, shaderRendererGPU } from "../core/index.js";
 import { setColorSpaceMode } from "../core/utilities/transformations/index.js";
 import { isExternalUser, startTelemetry } from "../core/telemetry/index.js";
 import { jsx, jsxs } from "react/jsx-runtime";
 const ShaderContext = createContext(null);
-const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear", toneMapping = "linear", isPreview = false, onReady, style = {}, className = "",...rest }) => {
+const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear", toneMapping = "linear", isPreview = false, onReady, onUnavailable, style = {}, className = "",...rest }) => {
 	const containerRef = useRef(null);
 	const canvasRef = useRef(null);
 	const reactId = useId();
@@ -13,6 +13,9 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 	if (rendererRef.current === null) rendererRef.current = shaderRendererGPU();
 	const onReadyRef = useRef(onReady);
 	onReadyRef.current = onReady;
+	const onUnavailableRef = useRef(onUnavailable);
+	onUnavailableRef.current = onUnavailable;
+	const gpuUnavailableRef = useRef(null);
 	useEffect(() => {
 		rendererRef.current.setOnReady(() => onReadyRef.current?.());
 		return () => {
@@ -81,14 +84,16 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 	const isCleanedUpRef = useRef(false);
 	const wasVisibleRef = useRef(false);
 	const visibilityObserverRef = useRef(null);
+	const MAX_TELEMETRY_POLLS = 40;
 	const startTelemetryWhenReady = () => {
+		let polls = 0;
 		const checkRendering = () => {
-			if (isCleanedUpRef.current || !rendererRef.current) {
+			if (isCleanedUpRef.current || !rendererRef.current || gpuUnavailableRef.current || ++polls > MAX_TELEMETRY_POLLS) {
 				telemetryStartTimeoutRef.current = null;
 				return;
 			}
 			if (rendererRef.current.getPerformanceStats().fps > 0) {
-				telemetryCollectorRef.current = startTelemetry(rendererRef.current, "3.0.443", disableTelemetry, isPreview);
+				telemetryCollectorRef.current = startTelemetry(rendererRef.current, "3.0.444", disableTelemetry, isPreview);
 				if (telemetryCollectorRef.current) telemetryCollectorRef.current.start();
 				telemetryStartTimeoutRef.current = null;
 			} else telemetryStartTimeoutRef.current = window.setTimeout(checkRendering, 500);
@@ -97,24 +102,35 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 	};
 	const initializeRenderer = async () => {
 		const canvas = canvasRef.current;
-		if (!canvas || isInitializedRef.current || isInitializingRef.current) return;
+		if (!canvas || isInitializedRef.current || isInitializingRef.current || gpuUnavailableRef.current) return;
 		isInitializingRef.current = true;
 		try {
 			const renderer = rendererRef.current;
+			renderer.setOnUnavailable((reason) => {
+				gpuUnavailableRef.current = reason;
+				try {
+					onUnavailableRef.current?.(reason);
+				} catch (err) {
+					debugWarn("[Shaders] onUnavailable callback threw:", err);
+				}
+			});
 			if (!renderer.isInitialized()) await renderer.initialize({
 				canvas,
 				colorSpace,
 				toneMapping
 			});
+			if (renderer.getFailureReason()) {
+				isInitializingRef.current = false;
+				return;
+			}
 			renderer.registerNode(rootId, rootPassthrough.fragment, null, null, {}, rootPassthrough);
 			isInitializedRef.current = true;
 			isInitializingRef.current = false;
 			if (shouldSendTelemetryRef.current === null) shouldSendTelemetryRef.current = isExternalUser();
 			if (shouldSendTelemetryRef.current && !telemetryCollectorRef.current) startTelemetryWhenReady();
 		} catch (err) {
-			console.error("[Shader] Initialization failed:", err);
+			debugWarn("[Shaders] renderer initialization failed:", err);
 			isInitializingRef.current = false;
-			throw err;
 		}
 	};
 	const setupVisibilityObserver = () => {
@@ -129,7 +145,7 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 				if (rendererRef.current.isInitialized()) {
 					rendererRef.current.startAnimation();
 					if (shouldSendTelemetryRef.current && !telemetryCollectorRef.current && !telemetryStartTimeoutRef.current) startTelemetryWhenReady();
-				} else initializeRenderer().catch(console.error);
+				} else initializeRenderer();
 				wasVisibleRef.current = true;
 			} else if (!isCurrentlyVisible && wasVisibleRef.current) {
 				rendererRef.current.stopAnimation();
@@ -144,7 +160,7 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 		if (!container) return;
 		const rect = container.getBoundingClientRect();
 		if (rect.width > 0 && rect.height > 0) {
-			initializeRenderer().catch(console.error);
+			initializeRenderer();
 			wasVisibleRef.current = true;
 		} else wasVisibleRef.current = false;
 		setupVisibilityObserver();
@@ -183,7 +199,7 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 			try {
 				rendererRef.current.cleanup();
 				isInitializedRef.current = false;
-				initializeRenderer().catch(console.error);
+				initializeRenderer();
 			} catch (err) {
 				console.error("[Shader] Error updating colorSpace:", err);
 			}
@@ -198,7 +214,7 @@ const Shader = ({ children, disableTelemetry = false, colorSpace = "p3-linear",
 		if (rendererRef.current && isInitializedRef.current) try {
 			rendererRef.current.cleanup();
 			isInitializedRef.current = false;
-			initializeRenderer().catch(console.error);
+			initializeRenderer();
 		} catch (err) {
 			console.error("[Shader] Error updating toneMapping:", err);
 		}