shaders 3.0.442 → 3.0.444

package/dist/core/index.js

@@ -1,242 +1,280 @@
-import { B as createComputeDispatcher, Bt as boundingBoxToUVParams, Ht as screenUVToBoxLocal$1, Mt as collectStructuralHashInputs, Nt as composeNodeTree, Ot as SHARED_SAMPLER_LAYOUT, Vt as needsTransformation, an as FieldHandle, bt as getAnimatedTimeState, cn as updateFieldValue, on as createUniformStore, p as maxPixelRatioForDevice, t as SystemUniforms, vt as packConvertedStops, yt as packStops } from "./coords-DLZT4HVT.js";
-import "./glass-CGThMEIa.js";
-import "./Neon-CgA9zX4Y.js";
-import "./Emboss-C3NBF44G.js";
-import "./Form3D-Csuoy7Rq.js";
-import "./ThinFilm-C28dTgXR.js";
-import { o as transformColorSpace } from "./transformations-P50Uo_Ju.js";
-import { _ as sortStops, a as buildDimensionalPlan, c as isDimensionalValue, d as colorToRGBA, f as setColorSpaceModeGpu, g as resolveStops, h as colorStopsTransform, i as boxHalfExtentsUV, l as resolveDimensionalProp, n as rootPassthrough, o as buildExtraSizeProps, p as MAX_COLOR_STOPS, r as createGpuUniformsMap, s as isDimensionalProp, u as setShaderCanvasDimensions } from "./porters-DdcOi7BN.js";
-import "./AngularBlur-BDxGVOMQ.js";
-import "./Arc-C981IGmm.js";
-import "./Ascii-C_-Jn2_c.js";
-import "./Aurora-D66-fTnE.js";
-import "./BarShift-DLaO6DjV.js";
-import "./Beam-mVVEXCwG.js";
-import "./Blob-BnBDJJ84.js";
-import "./noiseColor-kVjc2DJn.js";
-import "./BlockNoise-DINAV0qg.js";
-import "./BlueNoise-B9jPJ1s5.js";
-import "./Blur-DDWaY0Ld.js";
-import "./BrickPattern-DGsAflLE.js";
-import "./BrightnessContrast-CEHGmtvm.js";
-import { a as SVG3D_TYPES, c as isVolumetricShapeType, i as SVG3D_DEFAULTS, l as shape3dBoundingRadius, n as SHAPE3D_DEFAULTS, o as is3dShapeType, r as SHAPE3D_TYPES, s as isSvg3dShapeType } from "./shapeEffectBounds-BglTGD4B.js";
-import "./BrushedMetal-CcpOuWtJ.js";
-import "./Bulge-B3noQSAj.js";
-import "./CarbonFiber-CSHN_f_N.js";
-import "./Chalkboard-BSLaGFyY.js";
-import "./ChannelBlur-CDigdYX8.js";
-import "./Checkerboard-DlZGigj6.js";
-import "./Chevron-BuOn9mA1.js";
-import "./ChromaFlow-BOB8M0bU.js";
-import "./ChromaticAberration-gtezUw88.js";
-import "./Circle-Vb7e3gL-.js";
-import "./ColorWheel-jc1jsi5U.js";
-import "./CompressionArtifacts-DlwHUO-X.js";
-import "./ConcentricSpin-BLIJre0M.js";
-import "./ConicGradient-BcNQlquk.js";
-import "./ContourLines-CkGvhac3.js";
-import "./CornerPin-DYy3m7oY.js";
-import "./Crescent-CrWVqQDf.js";
-import "./Cross-DUznb_Y-.js";
-import "./CRTScreen-DL5luEsd.js";
-import "./Crystal-CgDpYkhN.js";
-import "./CurlNoise-DAYJuMmN.js";
-import "./CursorRipples-CNP8wzdR.js";
-import "./CursorTrail-B1VULW3E.js";
-import "./DataMosh-BYwbcTxJ.js";
-import "./DiamondGradient-BB7ajCKo.js";
-import "./DiffuseBlur-KE2fGEND.js";
-import "./Dither-B8yxWNxE.js";
-import "./DOMTexture-DROf41BI.js";
-import "./DotGrid-Doh7yuqR.js";
-import "./DropShadow-DhHQBpiK.js";
-import "./Duotone-DA3IudVy.js";
-import "./Ellipse-m1D5EVjj.js";
-import "./Engraving-Bz503L4R.js";
-import "./ErosionNoise-DOOt5U2Z.js";
-import "./Exposure-DkQ4kanv.js";
-import "./FallingLines-BE6S1TUf.js";
-import "./FilmGrain-9-Mgc2Ri.js";
-import "./Flip-Dpi0pVGo.js";
-import "./FloatingParticles-Qh0dQBmA.js";
-import "./Flower-DJLgm11L.js";
-import "./FlowField-0UUp41dK.js";
-import "./FlowingGradient-C01NbZ16.js";
-import "./FlutedGlass-DIwsLgXX.js";
-import "./Fog-BwPDTYRv.js";
-import "./FractalNoise-B9usxoBx.js";
-import "./Frost-Bhd3oWES.js";
-import "./GaborNoise-CQX_VPTg.js";
-import "./Glass-tFOQd3eV.js";
-import "./GlassTiles-C-yPKp5B.js";
-import "./Glitch-0i5BtHaq.js";
-import "./Glow-CMz4cv5I.js";
-import "./Godrays-D0euidZr.js";
-import "./Goo-AMjCwSDQ.js";
-import "./GradientMap-BU4kVWfH.js";
-import "./Grayscale-iaDYz9To.js";
-import "./Grid-BwbSPDqS.js";
-import "./GridDistortion-B3S8D94q.js";
-import "./Group-0BcuiZZM.js";
-import "./Halftone-ClxolEhO.js";
-import "./Heart-BdSnsqq-.js";
-import "./Heatmap-CFEEphb2.js";
-import "./HexGrid-D8CgLdgw.js";
-import "./Hologram-IJhpMkKa.js";
-import "./Holographic-BbrHmA39.js";
-import "./HueShift-Bv6qzKH0.js";
-import "./ImageTexture-Dh6VPuYy.js";
-import "./Invert-B8gtmw54.js";
-import "./IsometricCubes-BL0ZvkwZ.js";
-import "./Kaleidoscope-D4VzDZni.js";
-import "./KeyFrames-C-nnFGBw.js";
-import "./LensFlare-D_LFHDo0.js";
-import "./LightEdge-Ck4lGBye.js";
-import "./LightLeak-DuaMzzKh.js";
-import "./LinearBlur-CHioFPql.js";
-import "./LinearGradient-CEz9WjgA.js";
-import "./LiquidMetal-CtbGXpkb.js";
-import "./Liquify-B0rCOoDY.js";
-import "./Marble-BJp6F6BF.js";
-import "./Mirror-9fC_SqqB.js";
-import "./MultiPointGradient-BuDBY6Ax.js";
-import "./fonts-3F3pIODs.js";
-import "./ObjectTracker-D1qrJe0c.js";
-import "./PagePeel-YA6Q8kM0.js";
-import "./Paper-Bu3J7_h8.js";
-import "./Parallelogram-8VWcTkAt.js";
-import "./Particles-BG7Z-4in.js";
-import "./PerlinNoise-gV2dOb_o.js";
-import "./Perspective-m70JnY4Z.js";
-import "./Pixelate-CcBgoqXj.js";
-import "./PixelSort-tKcoDnMz.js";
-import "./PixelThrow-CzelDKa4.js";
-import "./Plasma-Bsei8uLa.js";
-import "./Plastic-D9qe3OWm.js";
-import "./PolarCoordinates-C9WxI22k.js";
-import "./Polygon-D58HZRzJ.js";
-import "./Posterize-DxR6F30M.js";
-import "./Prism-JLQP5dhZ.js";
-import "./ProgressiveBlur-DpERTuHY.js";
-import "./RadialGradient-N4mHVX7b.js";
-import "./ReactionDiffusion-BpLbPwbw.js";
-import "./RectangularCoordinates-Bt9H7sBE.js";
-import "./ReflectivePlane-Cumbz3x2.js";
-import "./Repeater-DuRfWt9x.js";
-import "./Ring-Cg_pZTin.js";
-import "./Ripples-BtenteeG.js";
-import "./RoundedRect-C0ETFLNc.js";
-import "./Saturation-BbOceqP3.js";
-import "./Scratches-B2Q_mgvt.js";
-import "./Sharpness-Bhb9aDxA.js";
-import "./Shatter-zxLD4RY8.js";
-import "./SimplexNoise-DTCJ__Jt.js";
-import "./SineWave-JNTzGGXH.js";
-import "./Smoke-BX4EcQdI.js";
-import "./SmokeFill-9SqGHgJt.js";
-import "./SmokeFlow-Cfs5EVW_.js";
-import "./Solarize-BQq15L3x.js";
-import "./SolidColor-8aFR9Ecl.js";
-import "./Spherize-Czfb_NCO.js";
-import "./Spiral-CO_pymky.js";
-import "./Star-CgLpQtzz.js";
-import "./noiseStylize-BMnwulEm.js";
-import "./Stone-Bl9-bI0G.js";
-import "./Strands-BdSTwZXc.js";
-import "./Stretch-BCZ_vkQn.js";
-import "./Stripes-OLW9XYEW.js";
-import "./StudioBackground-ksKsEcWQ.js";
-import "./SunBurst-B_mkcjjh.js";
-import "./Surface3D-D6D9L3et.js";
-import "./Swirl-DMQ-Iq-_.js";
-import "./Teardrop-Dz5aCCyM.js";
-import "./Text-9v36CCo0.js";
-import "./TiltShift-Df93B2bk.js";
-import "./Tint-e-sF3Q5L.js";
-import "./Trapezoid-B6r05rcQ.js";
-import "./TriangularGrid-CX7hnKpa.js";
-import "./Tritone-CccAEZZ2.js";
-import "./Truchet-DG3fNF5b.js";
-import "./Twirl-CtFo8Cjm.js";
-import "./Vesica-D1HOV75v.js";
-import "./VHS-CKc1qc0j.js";
-import "./Vibrance-E9-pYAwh.js";
-import "./VideoTexture-Df7BPBe-.js";
-import "./Vignette-DOVH3O7h.js";
-import "./Voronoi-BYmYkJfN.js";
-import "./Water-DAQnd09w.js";
-import "./Watercolor-B1iwfQSH.js";
-import "./WaveDistortion-BNkgWs3D.js";
-import "./WaveletNoise-ByqzdG-6.js";
-import "./Weave-DeItcIeX.js";
-import "./WebcamTexture-BAeqZ7pH.js";
-import "./Wool-Br5Ajlvr.js";
-import "./WorleyNoise-D1piyiG2.js";
-import "./ZoomBlur-ZEtNzn4_.js";
-import { t as getAllShaders } from "./shaderRegistry-Gsachoy8.js";
+import { Dt as packConvertedStops, Ht as composeNodeTree, Lt as SHARED_SAMPLER_LAYOUT, Ot as packStops, S as maxPixelRatioForDevice, Vt as collectStructuralHashInputs, Xt as needsTransformation, Y as createComputeDispatcher, Yt as boundingBoxToUVParams, Zt as screenUVToBoxLocal$1, kt as getAnimatedTimeState, t as SystemUniforms, vn as FieldHandle, xn as updateFieldValue, yn as createUniformStore } from "./coords-CLqRuQwC.js";
+import { a as getWebGPUSupport, c as isWebGPUSupported, i as getGpuUnusableReason, l as markGpuUnusable, n as debugError, o as isGpuUnavailableError, r as debugWarn, s as isShadersDebug, t as GpuUnavailableError, u as setShadersDebug } from "./support-6QRFK3xB.js";
+import "./glass-BLc74dQi.js";
+import "./Neon-DAPbLlBN.js";
+import "./Emboss-BNhsz2v0.js";
+import "./Form3D-BqMINp_g.js";
+import "./ThinFilm-Cfx6eANY.js";
+import { o as transformColorSpace } from "./transformations-t0d2-uSX.js";
+import { _ as sortStops, a as buildDimensionalPlan, c as isDimensionalValue, d as colorToRGBA, f as setColorSpaceModeGpu, g as resolveStops, h as colorStopsTransform, i as boxHalfExtentsUV, l as resolveDimensionalProp, n as rootPassthrough, o as buildExtraSizeProps, p as MAX_COLOR_STOPS, r as createGpuUniformsMap, s as isDimensionalProp, u as setShaderCanvasDimensions } from "./porters-u50QU6Yv.js";
+import "./AngularBlur-D-tt4pvi.js";
+import "./Arc-DrBTn2ft.js";
+import "./Ascii-cHzx_Cgc.js";
+import "./Aurora-15z76vsc.js";
+import "./BarnDoors-CBzse00V.js";
+import "./BarShift-s7HgQwz5.js";
+import "./Beam-DZgWUuTC.js";
+import "./Bend-CHTYK8SA.js";
+import "./Blob-A8bKkEG1.js";
+import "./BlockDissolve-Bb4aDV5s.js";
+import "./noiseColor-CFYtKwDd.js";
+import "./BlockNoise-BnnsS95j.js";
+import "./BlueNoise-DTOarEL0.js";
+import "./Blur-DEwHcGOu.js";
+import "./Boids-BWJXVflR.js";
+import "./BokehBlur-pQJN6FFd.js";
+import "./BrickPattern-Kwmx3pdx.js";
+import "./BrightnessContrast-CAkwN3s1.js";
+import { a as SVG3D_TYPES, c as isVolumetricShapeType, i as SVG3D_DEFAULTS, l as shape3dBoundingRadius, n as SHAPE3D_DEFAULTS, o as is3dShapeType, r as SHAPE3D_TYPES, s as isSvg3dShapeType } from "./shapeEffectBounds-DIjA_-15.js";
+import "./BrushedMetal-B4qfaTCf.js";
+import "./Bulge-CLBhicOs.js";
+import "./CarbonFiber-zA6_ZDg8.js";
+import "./Chalkboard-DwkX3ZL3.js";
+import "./ChannelBlur-KHDU8WCn.js";
+import "./Checkerboard-CvP8BKcu.js";
+import "./CheckerWipe-CNlqWp0y.js";
+import "./Chevron-BFmKhIws.js";
+import "./ChromaFlow-C8I4PtcP.js";
+import "./ChromaticAberration-CGPfHEFI.js";
+import "./Circle-ChmepdP_.js";
+import "./ColorWheel-D5V4ozig.js";
+import "./CompressionArtifacts--GdHELg8.js";
+import "./ConcentricSpin-DIWQ80K5.js";
+import "./ConicGradient-DjMQDAT6.js";
+import "./ContourLines-Pq1zDmlf.js";
+import "./CornerPin-C-x2z8H5.js";
+import "./Crescent-C6COUHa5.js";
+import "./Cross-Cgw13Sga.js";
+import "./CRTScreen-Cj2H2mXK.js";
+import "./Crystal-RnN4Y5Tf.js";
+import "./CurlNoise-jaIscgOF.js";
+import "./CursorRipples-Gv0B1S-h.js";
+import "./CursorTrail-BMHsUYwx.js";
+import "./DataMosh-CaqYFxYA.js";
+import "./DiamondGradient-D388xLbc.js";
+import "./DiamondWipe-BRXj3gon.js";
+import "./DiffuseBlur-CM5Qy5JM.js";
+import "./DisplacementMap-Cr1fauBv.js";
+import "./Dither-CubXhMES.js";
+import "./DotGrid-D6We1dqv.js";
+import "./DropShadow-C8v9KJgy.js";
+import "./Duotone-BfVi04d4.js";
+import "./Ellipse-fTV0CAVg.js";
+import "./Engraving-DYTr1YbV.js";
+import "./ErosionNoise-CxsXwPPE.js";
+import "./Exposure-DISAOzQ5.js";
+import "./FallingLines-DBGk9U7l.js";
+import "./FilmGrain-Ban-r5as.js";
+import "./FilmStock-BlOwC5zb.js";
+import "./Flip-CAt9CFWn.js";
+import "./FloatingParticles-Cppgg6I0.js";
+import "./Flower-iLK4UwZa.js";
+import "./FlowField-b0PcB7MV.js";
+import "./FlowingGradient-CZc_z9cL.js";
+import "./FlutedGlass-DMl2A42x.js";
+import "./Fog-BBc52yrL.js";
+import "./FractalNoise-BjGa9I7_.js";
+import "./Frost-ttMO1uGc.js";
+import "./GaborNoise-CSC24alr.js";
+import "./Glass-DHkb-2UB.js";
+import "./GlassTiles-CTSmg7gD.js";
+import "./Glitch-O5FZxlBV.js";
+import "./Glow-Cj9SzOqq.js";
+import "./Godrays-XW1fNiSU.js";
+import "./Goo-Bc43zAec.js";
+import "./GradientMap-BxSv1OOf.js";
+import "./Grayscale-CNM0GlQN.js";
+import "./Grid-reIQAyFU.js";
+import "./GridDistortion-tJym6OIr.js";
+import "./Group-8iAuPA0-.js";
+import "./Halftone-Dlk16PsH.js";
+import "./Heart-C3Uas8c_.js";
+import "./Heatmap-CE7IB_4g.js";
+import "./HexGrid-BiXYpVNp.js";
+import "./Hologram-BjKBncw8.js";
+import "./Holographic-CCTmTYXb.js";
+import "./HTMLInCanvas-CAHfLRAz.js";
+import "./HueShift-CE5RgaBc.js";
+import "./ImageTexture-BrjlwuWY.js";
+import "./InkFlow-DS92HgM9.js";
+import "./Invert-e1Z9IfPo.js";
+import "./IrisWipe-CCK_EamC.js";
+import "./IsometricCubes-BA-cN4bC.js";
+import "./Kaleidoscope-Cin7yxd7.js";
+import "./KeyFrames-D4-678xR.js";
+import "./LensFlare-UNNiSfiz.js";
+import "./LightEdge-GUFdnqjh.js";
+import "./LightLeak-DWv0ec7B.js";
+import "./LinearBlur-DBKjOKVV.js";
+import "./LinearGradient--Vy79Fs_.js";
+import "./LinearWipe-PZcYib77.js";
+import "./LiquidMetal-cUxfJdju.js";
+import "./Liquify-B1o-_MJZ.js";
+import "./MagneticFilings-B1Qvnw6t.js";
+import "./Marble-CD5fqEce.js";
+import "./Mirror-QJoYnzu6.js";
+import "./MultiPointGradient-CLRPS8u7.js";
+import "./NoiseDissolve-jdMIvdYS.js";
+import "./fonts-BtGjHq1w.js";
+import "./ObjectTracker-BD_l_g6R.js";
+import "./PagePeel-YyWAE0am.js";
+import "./Paper-DOFhG3gq.js";
+import "./Parallelogram-CKlvs9a_.js";
+import "./ParticleField-R--x794f.js";
+import "./ParticleFlow-DY8g2n2d.js";
+import "./Particles-D6-MCj-7.js";
+import "./PerlinNoise-DKBJst5k.js";
+import "./Perspective-DH5aV7fh.js";
+import "./Pixelate-DgPtCErp.js";
+import "./PixelSort-DRd4GE4_.js";
+import "./PixelThrow-CRizzpOr.js";
+import "./Plasma-8zXLjhIr.js";
+import "./Plastic-Dv-N6_Nv.js";
+import "./PolarCoordinates-lw0yBeJq.js";
+import "./Polygon-DQxmxfqr.js";
+import "./Posterize-C4qpmou-.js";
+import "./Prism-C0qW3WgL.js";
+import "./ProgressiveBlur-C_xtFzmP.js";
+import "./RadialGradient-DetBcKps.js";
+import "./RadialWipe-Cmv05uxE.js";
+import "./RandomBars-CrPfWF8l.js";
+import "./ReactionDiffusion-Dc_uVKMg.js";
+import "./RectangularCoordinates-C1sbpWlI.js";
+import "./ReflectivePlane-DyTDDfvN.js";
+import "./Repeater-CzvIt5Gw.js";
+import "./Ring-6gd4orX0.js";
+import "./Ripples-D7Y__Ls8.js";
+import "./RippleWipe-BU-dDvBK.js";
+import "./RoundedRect-DMzr6z4F.js";
+import "./Saturation-BZ5ZmmKo.js";
+import "./Scratches-wRRWI1-5.js";
+import "./Sharpness-BQu_GeV6.js";
+import "./Shatter-HTHPxq07.js";
+import "./SimplexNoise-arMv2IxX.js";
+import "./SineWave-crFYxXPS.js";
+import "./SliceWipe-D-Rnm4ce.js";
+import "./Smoke-Cyjm_hFb.js";
+import "./SmokeFill-CMBAFeM8.js";
+import "./SmokeFlow-DfytXLC4.js";
+import "./Solarize-BNuZoWV5.js";
+import "./SolidColor-DB8l6xRl.js";
+import "./Spherize-LIfupaEj.js";
+import "./Spiral-B-Kz6zOG.js";
+import "./Star-Bxi6VOuZ.js";
+import "./noiseStylize-BsZQT7ig.js";
+import "./Stone-CrdhdOWf.js";
+import "./Strands-CgOVvjKk.js";
+import "./Stretch-CWpqkWdT.js";
+import "./Stripes-DnmkVdJi.js";
+import "./StudioBackground-BR7HA0ot.js";
+import "./SunBurst-2tbvTvoR.js";
+import "./Surface3D-BDN9t6UU.js";
+import "./Swirl-BO63keY-.js";
+import "./Teardrop-Cj9wbWNj.js";
+import "./Text-DDpqrXsw.js";
+import "./TiltShift-DtDGS05n.js";
+import "./TimeTrail-CH7CMyxo.js";
+import "./Tint-RTSV6Aiu.js";
+import "./Trapezoid-B8YUl-8U.js";
+import "./TriangularGrid-B_P_Bn6J.js";
+import "./Tritone-zbDA_LBO.js";
+import "./Truchet-QdRvWfkQ.js";
+import "./Twirl-M1ylLxnB.js";
+import "./VenetianBlinds-DyBouRcb.js";
+import "./Vesica-DYkOtRW9.js";
+import "./VHS-BbpH5MH8.js";
+import "./Vibrance-DYCb_3Vb.js";
+import "./VideoTexture-B5QB_7wK.js";
+import "./Vignette-CWNEqMe7.js";
+import "./Voronoi-DJIf5qyN.js";
+import "./Water-D7FpFPfD.js";
+import "./Watercolor-B4bOV2pY.js";
+import "./WaveDistortion-C9K0iLOy.js";
+import "./WaveletNoise-MxVl5SGH.js";
+import "./Weave-DMvmkoDF.js";
+import "./WebcamTexture-ylP8AAV1.js";
+import "./Wool-DKuYNXvU.js";
+import "./WorleyNoise-C-8TphM9.js";
+import "./ZoomBlur-BxPekTQP.js";
+import { t as getAllShaders } from "./shaderRegistry-QNzuz_fH.js";
 import * as d from "typegpu/data";
 import tgpu, { common } from "typegpu";
 var OPTIONAL_FEATURES = ["float32-filterable", "timestamp-query"];
 var rootsByDevice = /* @__PURE__ */ new WeakMap();
 var lostCallbacks = /* @__PURE__ */ new WeakMap();
 var lostDevices = /* @__PURE__ */ new WeakSet();
-var replacementRoots = /* @__PURE__ */ new WeakMap();
+var defaultRootPromise = null;
+var destroyedDefaultRoots = /* @__PURE__ */ new WeakSet();
 async function acquireRoot(options = {}) {
-	if (options.device) {
+	if (options.device && !lostDevices.has(options.device)) {
 		const device = options.device;
-		if (!lostDevices.has(device)) {
-			let root = rootsByDevice.get(device);
-			if (!root) {
-				root = tgpu.initFromDevice({ device });
-				rootsByDevice.set(device, root);
-			}
-			wireDeviceLost(root, options.onDeviceLost);
-			return {
-				root,
-				device,
-				adapter: options.adapter,
-				createdDevice: false
-			};
-		}
-		let replacement;
-		for (;;) {
-			const cached = replacementRoots.get(device);
-			if (!cached) break;
-			const cachedCtx = await cached.catch(() => null);
-			if (cachedCtx && !lostDevices.has(cachedCtx.device)) {
-				replacement = cached;
-				break;
-			}
-			if (replacementRoots.get(device) === cached) replacementRoots.delete(device);
+		let root = rootsByDevice.get(device);
+		if (!root) {
+			root = tgpu.initFromDevice({ device });
+			rootsByDevice.set(device, root);
 		}
-		if (!replacement) {
-			console.warn("[gpu] injected GPU device was lost — creating a replacement device for recovery");
-			replacement = createOwnRoot();
-			replacementRoots.set(device, replacement);
-		}
-		const ctx$1 = await replacement;
-		wireDeviceLost(ctx$1.root, options.onDeviceLost);
+		const release$1 = wireDeviceLost(root, options.onDeviceLost);
 		return {
-			root: ctx$1.root,
-			device: ctx$1.device,
-			adapter: ctx$1.adapter,
-			createdDevice: false
+			root,
+			device,
+			adapter: options.adapter,
+			createdDevice: false,
+			release: release$1
 		};
 	}
-	const ctx = await createOwnRoot();
-	wireDeviceLost(ctx.root, options.onDeviceLost);
+	if (options.device) debugWarn("[gpu] injected GPU device was lost — falling back to the shared default device");
+	const ctx = await acquireDefaultRoot();
+	const release = wireDeviceLost(ctx.root, options.onDeviceLost);
 	return {
-		...ctx,
-		adapter: options.adapter,
-		createdDevice: true
+		root: ctx.root,
+		device: ctx.device,
+		adapter: ctx.adapter,
+		createdDevice: false,
+		release
 	};
 }
+async function acquireDefaultRoot() {
+	for (;;) {
+		const cached = defaultRootPromise;
+		if (!cached) break;
+		const ctx = await cached.catch(() => null);
+		if (ctx && !destroyedDefaultRoots.has(cached) && !lostDevices.has(ctx.device)) return ctx;
+		if (defaultRootPromise === cached) defaultRootPromise = null;
+	}
+	const pending = createOwnRoot();
+	defaultRootPromise = pending;
+	try {
+		return await pending;
+	} catch (error) {
+		if (defaultRootPromise === pending) defaultRootPromise = null;
+		throw error;
+	}
+}
+function destroyDefaultGpuDevice() {
+	const pending = defaultRootPromise;
+	defaultRootPromise = null;
+	if (!pending) return;
+	destroyedDefaultRoots.add(pending);
+	pending.then((ctx) => {
+		lostDevices.add(ctx.device);
+		try {
+			ctx.root.destroy();
+		} catch {}
+	}).catch(() => {});
+}
 async function createOwnRoot() {
-	if (typeof navigator === "undefined" || !navigator.gpu) throw new Error("[gpu] WebGPU is not available in this environment (navigator.gpu is undefined). This renderer is WebGPU-only.");
-	const root = await tgpu.init({
-		adapter: { powerPreference: "high-performance" },
-		device: { optionalFeatures: OPTIONAL_FEATURES }
-	});
+	if (typeof navigator === "undefined" || !navigator.gpu) throw new GpuUnavailableError("unsupported", "[gpu] WebGPU is not available in this environment (navigator.gpu is undefined).");
+	let root;
+	try {
+		root = await tgpu.init({
+			adapter: { powerPreference: "high-performance" },
+			device: { optionalFeatures: OPTIONAL_FEATURES }
+		});
+	} catch (error) {
+		const info = await getWebGPUSupport();
+		throw new GpuUnavailableError(info.supported ? "no-device" : info.reason ?? "init-failed", void 0, { cause: error });
+	}
+	if (!root.device) throw new GpuUnavailableError("no-device", "[gpu] adapter returned no device.");
 	rootsByDevice.set(root.device, root);
 	return {
 		root,
@@ -260,10 +298,13 @@ function wireDeviceLost(root, onDeviceLost) {
 		root.device.lost.then((info) => {
 			lostDevices.add(device);
 			if (info.reason === "destroyed") return;
-			for (const cb of lostCallbacks.get(device) ?? []) cb(info);
+			for (const cb of [...lostCallbacks.get(device) ?? []]) cb(info);
 		});
 	}
-	if (onDeviceLost) callbacks.add(onDeviceLost);
+	if (!onDeviceLost) return () => {};
+	const set = callbacks;
+	set.add(onDeviceLost);
+	return () => set.delete(onDeviceLost);
 }
 function structuralHash(inputs) {
 	let h = 2166136261;
@@ -365,7 +406,8 @@ function createPassManager(root, options) {
 	const { textureManager, dispatcher } = options;
 	const canvasFormat = options.canvasFormat ?? preferredCanvasFormat();
 	const rttFormat = options.rttFormat ?? "rgba16float";
-	const maxSampled = options.maxSampledTextures ?? 16;
+	const deviceMaxSampled = root.device?.limits?.maxSampledTexturesPerShaderStage;
+	const maxSampled = options.maxSampledTextures ?? (typeof deviceMaxSampled === "number" && deviceMaxSampled > 0 ? deviceMaxSampled : 16);
 	const vertex = options.fullScreenTriangle ?? common.fullScreenTriangle;
 	const rttTextures = /* @__PURE__ */ new Map();
 	const liveTextures = /* @__PURE__ */ new Set();
@@ -380,7 +422,7 @@ function createPassManager(root, options) {
 				nearestRepeat: s.nearestRepeat
 			});
 		} catch (e) {
-			console.error(`[${LABEL}] failed to build sampler bind group:`, e);
+			debugError(`[${LABEL}] failed to build sampler bind group:`, e);
 			return;
 		}
 	}
@@ -414,16 +456,16 @@ function createPassManager(root, options) {
 			const media = mediaResources?.[key];
 			const resource = rt ?? media;
 			if (!resource) {
-				console.error(`[${LABEL}] pass "${fragment.entry}" reads unknown texture "${key}"`);
+				debugError(`[${LABEL}] pass "${fragment.entry}" reads unknown texture "${key}"`);
 				return;
 			}
 			entries[key] = resource.texture;
 		}
-		if (fragment.reads.length > maxSampled) console.warn(`[${LABEL}] pass samples ${fragment.reads.length} textures (> device limit ~${maxSampled}); composition may fail on this device.`);
+		if (fragment.reads.length > maxSampled) debugWarn(`[${LABEL}] pass samples ${fragment.reads.length} textures (> device limit ~${maxSampled}); composition may fail on this device.`);
 		try {
 			return root.createBindGroup(fragment.textureLayout, entries);
 		} catch (e) {
-			console.error(`[${LABEL}] failed to build texture bind group:`, e);
+			debugError(`[${LABEL}] failed to build texture bind group:`, e);
 			return;
 		}
 	}
@@ -440,7 +482,7 @@ function createPassManager(root, options) {
 		if (keys.length === 1) {
 			const getSource = externalSources.get(keys[0]);
 			if (!getSource) {
-				console.error(`[${LABEL}] external read "${keys[0]}" has no registered source`);
+				debugError(`[${LABEL}] external read "${keys[0]}" has no registered source`);
 				return;
 			}
 			return textureManager.createExternalTextureBinding({
@@ -530,7 +572,7 @@ function createPassManager(root, options) {
 			const bg = pass.externalBinding?.update() ?? null;
 			if (!bg) {
 				if (!pass.externalSkipLogged) {
-					console.warn(`[${LABEL}] external texture not ready — skipping pass (${pass.fragment.externalReads.join(", ")})`);
+					debugWarn(`[${LABEL}] external texture not ready — skipping pass (${pass.fragment.externalReads.join(", ")})`);
 					pass.externalSkipLogged = true;
 				}
 				return;
@@ -1119,6 +1161,8 @@ var PerformanceTracker = class {
 		this.lastGpuTime = null;
 	}
 };
+var MAX_UNCAPTURED_VALIDATION_ERRORS = 32;
+var MAX_CONSECUTIVE_RENDER_ERRORS = 5;
 var globalEventManager = (() => {
 	let instanceCount = 0;
 	const callbacks = /* @__PURE__ */ new Set();
@@ -1127,12 +1171,14 @@ var globalEventManager = (() => {
 			try {
 				cb[key](arg);
 			} catch (error) {
-				console.error("[Shaders] Error in pointer handler:", error);
+				debugError("[Shaders] Error in pointer handler:", error);
 			}
 		});
 	};
 	const onMove = (e) => fan("onMouseMove", e);
 	const onTouch = (e) => fan("onTouchMove", e);
+	const onDown = (e) => fan("onMouseDown", e);
+	const onStart = (e) => fan("onTouchStart", e);
 	const onUp = () => fan("onMouseUp");
 	const onEnd = () => fan("onTouchEnd");
 	return { register(handlers) {
@@ -1141,8 +1187,10 @@ var globalEventManager = (() => {
 		if (instanceCount === 1 && typeof window !== "undefined") {
 			window.addEventListener("mousemove", onMove);
 			window.addEventListener("touchmove", onTouch);
-			window.addEventListener("mouseup", onUp);
-			window.addEventListener("touchend", onEnd);
+			window.addEventListener("mousedown", onDown, true);
+			window.addEventListener("touchstart", onStart, true);
+			window.addEventListener("mouseup", onUp, true);
+			window.addEventListener("touchend", onEnd, true);
 		}
 		return () => {
 			callbacks.delete(handlers);
@@ -1150,8 +1198,10 @@ var globalEventManager = (() => {
 			if (instanceCount === 0 && typeof window !== "undefined") {
 				window.removeEventListener("mousemove", onMove);
 				window.removeEventListener("touchmove", onTouch);
-				window.removeEventListener("mouseup", onUp);
-				window.removeEventListener("touchend", onEnd);
+				window.removeEventListener("mousedown", onDown, true);
+				window.removeEventListener("touchstart", onStart, true);
+				window.removeEventListener("mouseup", onUp, true);
+				window.removeEventListener("touchend", onEnd, true);
 			}
 		};
 	} };
@@ -1233,6 +1283,13 @@ function shaderRendererGPU() {
 	let firstRenderPending = false;
 	let onDeviceLostCallback = null;
 	let deviceLostFired = false;
+	let failureReason = null;
+	let onUnavailableCallback = null;
+	let hasNotifiedUnavailable = false;
+	let uncapturedErrorDevice = null;
+	let uncapturedErrorHandler = null;
+	let uncapturedValidationErrors = 0;
+	let consecutiveRenderErrors = 0;
 	const performanceTracker = new PerformanceTracker();
 	const frameParams = {
 		deltaTime: 0,
@@ -1419,6 +1476,22 @@ function shaderRendererGPU() {
 		node.mouseDriverState[prop] = s;
 		return s;
 	};
+	const ensureDriverState = (node) => {
+		const maps = node.metadata.maps;
+		if (!maps) return;
+		for (const [prop, driver] of Object.entries(maps)) {
+			if (!(prop in node.uniforms)) continue;
+			if (driver.type === "map") ensureMapValues(node, prop, driver);
+			else if (driver.type === "mouse-position") ensureMouseState(node, prop, driver);
+			else if (driver.type === "mouse") {
+				ensureMouseState(node, prop, driver);
+				ensureMapValues(node, prop, driver);
+			} else if (driver.type === "auto-animate") {
+				if (!node.autoAnimateState[prop]) node.autoAnimateState[prop] = {};
+				ensureMapValues(node, prop, driver);
+			}
+		}
+	};
 	const animatedTimeKey = (node) => {
 		const at = node.definition.animatedTime;
 		return (at ? node.uniforms[at.speed] : void 0) ?? node;
@@ -1484,58 +1557,59 @@ function shaderRendererGPU() {
 			});
 		}
 		const maps = node.metadata.maps;
-		if (maps) for (const [prop, driver] of Object.entries(maps)) {
-			if (!(prop in node.uniforms)) continue;
-			if (driver.type === "map") {
-				const mv = ensureMapValues(node, prop, driver);
-				inits.push({
-					name: `_map_${prop}_inputMin`,
-					schema: d.f32,
-					initial: mv.inputMin
-				});
-				inits.push({
-					name: `_map_${prop}_inputMax`,
-					schema: d.f32,
-					initial: mv.inputMax
-				});
-				inits.push({
-					name: `_map_${prop}_outputMin`,
-					schema: d.f32,
-					initial: mv.outputMin
-				});
-				inits.push({
-					name: `_map_${prop}_outputMax`,
-					schema: d.f32,
-					initial: mv.outputMax
-				});
-				inits.push({
-					name: `_map_${prop}_curve`,
-					schema: d.f32,
-					initial: mv.curve
-				});
-			} else if (driver.type === "mouse-position") {
-				const s = ensureMouseState(node, prop, driver);
-				inits.push({
-					name: `_smoothed_${prop}`,
-					schema: d.vec2f,
-					initial: [s.currentX, 1 - s.currentY]
-				});
-			} else if (driver.type === "mouse") {
-				ensureMouseState(node, prop, driver);
-				const mv = ensureMapValues(node, prop, driver);
-				inits.push({
-					name: `_smoothed_${prop}`,
-					schema: d.f32,
-					initial: mv.outputMin
-				});
-			} else if (driver.type === "auto-animate") {
-				if (!node.autoAnimateState[prop]) node.autoAnimateState[prop] = {};
-				const mv = ensureMapValues(node, prop, driver);
-				inits.push({
-					name: `_smoothed_${prop}`,
-					schema: d.f32,
-					initial: mv.outputMin
-				});
+		if (maps) {
+			ensureDriverState(node);
+			for (const [prop, driver] of Object.entries(maps)) {
+				if (!(prop in node.uniforms)) continue;
+				if (driver.type === "map") {
+					const mv = node.mapValues[prop];
+					inits.push({
+						name: `_map_${prop}_inputMin`,
+						schema: d.f32,
+						initial: mv.inputMin
+					});
+					inits.push({
+						name: `_map_${prop}_inputMax`,
+						schema: d.f32,
+						initial: mv.inputMax
+					});
+					inits.push({
+						name: `_map_${prop}_outputMin`,
+						schema: d.f32,
+						initial: mv.outputMin
+					});
+					inits.push({
+						name: `_map_${prop}_outputMax`,
+						schema: d.f32,
+						initial: mv.outputMax
+					});
+					inits.push({
+						name: `_map_${prop}_curve`,
+						schema: d.f32,
+						initial: mv.curve
+					});
+				} else if (driver.type === "mouse-position") {
+					const s = node.mouseDriverState[prop];
+					inits.push({
+						name: `_smoothed_${prop}`,
+						schema: d.vec2f,
+						initial: [s.currentX, 1 - s.currentY]
+					});
+				} else if (driver.type === "mouse") {
+					const mv = node.mapValues[prop];
+					inits.push({
+						name: `_smoothed_${prop}`,
+						schema: d.f32,
+						initial: mv.outputMin
+					});
+				} else if (driver.type === "auto-animate") {
+					const mv = node.mapValues[prop];
+					inits.push({
+						name: `_smoothed_${prop}`,
+						schema: d.f32,
+						initial: mv.outputMin
+					});
+				}
 			}
 		}
 		return inits;
@@ -1771,17 +1845,17 @@ function shaderRendererGPU() {
 		try {
 			for (const cb of bc.ir.onCleanup) cb();
 		} catch (e) {
-			console.error("[gpu] composition onCleanup error:", e);
+			debugError("[gpu] composition onCleanup error:", e);
 		}
 		try {
 			bc.passManager.dispose();
 		} catch (e) {
-			console.error("[gpu] passManager dispose error:", e);
+			debugError("[gpu] passManager dispose error:", e);
 		}
 		try {
 			bc.store.destroy();
 		} catch (e) {
-			console.error("[gpu] store destroy error:", e);
+			debugError("[gpu] store destroy error:", e);
 		}
 		liveCompositions.delete(bc);
 		if (boundComposition === bc) boundComposition = null;
@@ -1799,6 +1873,7 @@ function shaderRendererGPU() {
 		if (!bc.fresh) {
 			for (const node of nodes.values()) {
 				for (const [propName, u] of Object.entries(node.uniforms)) writePropHandle(node, propName, u.value);
+				ensureDriverState(node);
 				writeNodeSynthetic(node);
 			}
 			bc.store.writeAll();
@@ -1812,6 +1887,7 @@ function shaderRendererGPU() {
 		requestRender();
 	};
 	const requestRender = () => {
+		if (failureReason) return;
 		if (frameLoop.running) return;
 		if (pendingRenderRAF !== null) return;
 		if (typeof requestAnimationFrame !== "function") return;
@@ -1821,6 +1897,7 @@ function shaderRendererGPU() {
 		});
 	};
 	const registerNode = (id, fragmentNodeFunc, parentId, metadata, uniforms = {}, componentDefinition, domCanvas) => {
+		if (failureReason) return;
 		if (fragmentNodeFunc === null) {
 			const queueIndex = pendingRegistrationQueue.findIndex((item) => item.id === id);
 			if (queueIndex !== -1) {
@@ -2241,7 +2318,7 @@ function shaderRendererGPU() {
 				height: bufH
 			});
 		} catch (e) {
-			console.error("[gpu] composition onResize error:", e);
+			debugError("[gpu] composition onResize error:", e);
 		}
 		for (const node of nodes.values()) {
 			if (transformActive(node)) writeSyntheticScalar(node, "_xform_aspectRatio", aspectRatio());
@@ -2325,11 +2402,11 @@ function shaderRendererGPU() {
 		for (const cb of callbacks) try {
 			cb(frameParams);
 		} catch (e) {
-			console.error("[gpu] render callback error:", e);
+			debugError("[gpu] render callback error:", e);
 		}
 	};
 	const renderFrameInternal = (overrideDeltaTime) => {
-		if (!canRender()) return;
+		if (failureReason || !canRender()) return;
 		const now = performance.now();
 		let delta;
 		if (overrideDeltaTime !== void 0) delta = overrideDeltaTime;
@@ -2352,29 +2429,29 @@ function shaderRendererGPU() {
 		frameParams.dimensions.height = currentHeight;
 		let built = null;
 		let renderComp = null;
-		runFrameSequence({
-			updateDrivers: () => {
-				updateMouseDrivers();
-				updateAnimatedTime();
-				updateChildBounds();
-			},
-			ensureComposition: () => {
-				if (structuralDirty || desiredHash === null) {
-					desiredHash = computeStructuralHash();
-					structuralDirty = false;
-				}
-				if (desiredHash === null) return false;
-				built = pipelineCache.getOrBuild(desiredHash, () => buildComposition(desiredHash));
-				bindComposition(built);
-				return !!boundComposition;
-			},
-			beforeRender: () => runCallbacks(boundComposition.ir.onBeforeRender),
-			flush: () => {
-				writeSystemUniforms(boundComposition.store);
-				boundComposition.store.flush();
-			},
-			render: () => {
-				try {
+		try {
+			runFrameSequence({
+				updateDrivers: () => {
+					updateMouseDrivers();
+					updateAnimatedTime();
+					updateChildBounds();
+				},
+				ensureComposition: () => {
+					if (structuralDirty || desiredHash === null) {
+						desiredHash = computeStructuralHash();
+						structuralDirty = false;
+					}
+					if (desiredHash === null) return false;
+					built = pipelineCache.getOrBuild(desiredHash, () => buildComposition(desiredHash));
+					bindComposition(built);
+					return !!boundComposition;
+				},
+				beforeRender: () => runCallbacks(boundComposition.ir.onBeforeRender),
+				flush: () => {
+					writeSystemUniforms(boundComposition.store);
+					boundComposition.store.flush();
+				},
+				render: () => {
 					if (enablePerformanceTracking) performance.mark("shader-gpu-start");
 					renderComp = pipelineCache.renderValue ?? built;
 					renderComp?.passManager.render(context, frameParams);
@@ -2389,20 +2466,22 @@ function shaderRendererGPU() {
 							performance.clearMarks("shader-gpu-end");
 						} catch {}
 					}
-				} catch (error) {
-					console.error("[gpu] render frame error:", error);
-				}
-			},
-			markReady: () => {
-				pipelineCache.markReady(desiredHash);
-				if (firstRenderPending && !hasEmittedReady) {
-					hasEmittedReady = true;
-					firstRenderPending = false;
-					if (onReadyCallback) queueMicrotask(onReadyCallback);
-				}
-			},
-			afterRender: () => runCallbacks((renderComp ?? boundComposition).ir.onAfterRender)
-		});
+				},
+				markReady: () => {
+					pipelineCache.markReady(desiredHash);
+					if (firstRenderPending && !hasEmittedReady) {
+						hasEmittedReady = true;
+						firstRenderPending = false;
+						if (onReadyCallback) queueMicrotask(onReadyCallback);
+					}
+				},
+				afterRender: () => runCallbacks((renderComp ?? boundComposition).ir.onAfterRender)
+			});
+			consecutiveRenderErrors = 0;
+		} catch (error) {
+			noteRenderFailure(error);
+			return;
+		}
 		if (enablePerformanceTracking) {
 			performance.mark("shader-cpu-end");
 			try {
@@ -2417,21 +2496,22 @@ function shaderRendererGPU() {
 		performanceTracker.recordFrame(performance.now() - now);
 	};
 	const renderFrame = () => renderFrameInternal(void 0);
-	const renderAndWait = async () => {
+	const renderAndWait = async (options) => {
+		if (failureReason) return;
 		if (!canRender()) throw new Error("Renderer is not ready");
 		const wasAnimating = frameLoop.running;
 		if (wasAnimating) stopAnimation();
 		lastRenderTime = 0;
 		renderFrame();
-		if (root) await awaitGpuIdle(root);
+		if (root && options?.waitForGpu !== false) await awaitGpuIdle(root);
 		if (wasAnimating) startAnimation();
 	};
-	const renderSyntheticFrame = async (deltaSeconds) => {
+	const renderSyntheticFrame = async (deltaSeconds, options) => {
 		renderFrameInternal(deltaSeconds);
-		if (root) await awaitGpuIdle(root);
+		if (root && options?.waitForGpu !== false) await awaitGpuIdle(root);
 	};
 	const startAnimation = () => {
-		if (frameLoop.running || !shouldAnimate) return;
+		if (failureReason || frameLoop.running || !shouldAnimate) return;
 		performanceTracker.setRendering(true);
 		frameLoop.start();
 	};
@@ -2476,12 +2556,24 @@ function shaderRendererGPU() {
 		pointerActive = false;
 		requestRender();
 	};
-	const onPointerDown = () => {
+	const pressWithinCanvas = (clientX, clientY) => {
+		if (!isInitialized || !canvasElement) return false;
+		const rect = canvasElement.getBoundingClientRect();
+		if (rect.width === 0 || rect.height === 0) return false;
+		return clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
+	};
+	const onPointerDown = (event) => {
+		if (event.button !== 0) return;
+		if (!pressWithinCanvas(event.clientX, event.clientY)) return;
 		pointerActive = true;
+		updatePointerCoords(event);
 		requestRender();
 	};
-	const onTouchStart = () => {
+	const onTouchStart = (event) => {
+		if (event.touches.length === 0) return;
+		if (!pressWithinCanvas(event.touches[0].clientX, event.touches[0].clientY)) return;
 		pointerActive = true;
+		updatePointerCoords(event);
 		requestRender();
 	};
 	const updateMouseListenerRegistration = () => {
@@ -2507,26 +2599,20 @@ function shaderRendererGPU() {
 		}
 		if (needsMouse && !mouseListenersNeeded) {
 			mouseListenersNeeded = true;
-			if (!globalEventUnregister && canvasElement) {
-				globalEventUnregister = globalEventManager.register({
-					onMouseMove: onPointerMove,
-					onTouchMove,
-					onMouseUp: onPointerUp,
-					onTouchEnd
-				});
-				canvasElement.addEventListener("mousedown", onPointerDown);
-				canvasElement.addEventListener("touchstart", onTouchStart);
-			}
+			if (!globalEventUnregister && canvasElement) globalEventUnregister = globalEventManager.register({
+				onMouseMove: onPointerMove,
+				onTouchMove,
+				onMouseDown: onPointerDown,
+				onTouchStart,
+				onMouseUp: onPointerUp,
+				onTouchEnd
+			});
 		} else if (!needsMouse && mouseListenersNeeded) {
 			mouseListenersNeeded = false;
 			if (globalEventUnregister) {
 				globalEventUnregister();
 				globalEventUnregister = null;
 			}
-			if (canvasElement) {
-				canvasElement.removeEventListener("mousedown", onPointerDown);
-				canvasElement.removeEventListener("touchstart", onTouchStart);
-			}
 		}
 	};
 	const processQueuedRegistrations = () => {
@@ -2535,22 +2621,94 @@ function shaderRendererGPU() {
 		pendingRegistrationQueue = [];
 		for (const q of queue) registerNode(q.id, q.definition.fragment, q.parentId, q.metadata, q.uniforms, q.definition, q.domCanvas);
 	};
+	const fail = (reason, error) => {
+		if (failureReason) return;
+		failureReason = reason;
+		markGpuUnusable(reason);
+		debugError(`[gpu] renderer stopped (${reason}):`, error);
+		try {
+			cleanup();
+		} catch (e) {
+			debugError("[gpu] cleanup during failure threw:", e);
+		}
+		if (!hasNotifiedUnavailable && onUnavailableCallback) {
+			hasNotifiedUnavailable = true;
+			const cb = onUnavailableCallback;
+			queueMicrotask(() => {
+				try {
+					cb(reason, error);
+				} catch (e) {
+					debugError("[gpu] onUnavailable callback threw:", e);
+				}
+			});
+		}
+	};
+	const noteRenderFailure = (error) => {
+		if (isGpuUnavailableError(error)) {
+			fail(error.reason, error);
+			return;
+		}
+		consecutiveRenderErrors++;
+		if (consecutiveRenderErrors === 1) debugError("[gpu] render error:", error);
+		if (consecutiveRenderErrors >= MAX_CONSECUTIVE_RENDER_ERRORS) fail("render-failed", error);
+	};
+	const attachUncapturedErrorHandler = (device) => {
+		if (!device || typeof device.addEventListener !== "function") return;
+		detachUncapturedErrorHandler();
+		uncapturedErrorDevice = device;
+		uncapturedErrorHandler = (event) => {
+			try {
+				event.preventDefault();
+			} catch {}
+			const gpuError = event.error;
+			debugError("[gpu] uncaptured device error:", gpuError);
+			if (typeof GPUOutOfMemoryError !== "undefined" && gpuError instanceof GPUOutOfMemoryError) {
+				fail("out-of-memory", gpuError);
+				return;
+			}
+			if (typeof GPUInternalError !== "undefined" && gpuError instanceof GPUInternalError) {
+				fail("gpu-error", gpuError);
+				return;
+			}
+			uncapturedValidationErrors++;
+			if (uncapturedValidationErrors >= MAX_UNCAPTURED_VALIDATION_ERRORS) fail("gpu-error", gpuError);
+		};
+		device.addEventListener("uncapturederror", uncapturedErrorHandler);
+	};
+	const detachUncapturedErrorHandler = () => {
+		if (uncapturedErrorDevice && uncapturedErrorHandler) try {
+			uncapturedErrorDevice.removeEventListener("uncapturederror", uncapturedErrorHandler);
+		} catch {}
+		uncapturedErrorDevice = null;
+		uncapturedErrorHandler = null;
+	};
 	const fireDeviceLost = (reason) => {
 		if (deviceLostFired) return;
 		deviceLostFired = true;
 		try {
 			stopAnimation();
 		} catch {}
-		if (onDeviceLostCallback) queueMicrotask(() => {
-			try {
-				onDeviceLostCallback?.(reason);
-			} catch (e) {
-				console.error("[gpu] onDeviceLost callback threw:", e);
-			}
-		});
+		if (onDeviceLostCallback) {
+			const cb = onDeviceLostCallback;
+			queueMicrotask(() => {
+				try {
+					cb(reason);
+				} catch (e) {
+					debugError("[gpu] onDeviceLost callback threw:", e);
+				}
+			});
+			return;
+		}
+		fail("device-lost", reason);
 	};
 	const initialize = async (options) => {
 		if (options.context !== void 0) throw new Error("[gpu] initialize({ context }) is not supported — this renderer is WebGPU-only. Remove the WebGL `context` option.");
+		if (failureReason) return;
+		const pageWide = getGpuUnusableReason();
+		if (pageWide) {
+			fail(pageWide);
+			return;
+		}
 		if (isInitialized || isInitializing) return;
 		const { canvas, resizeTarget, enablePerformanceTracking: enableTracking = false, colorSpace = "p3-linear", toneMapping = "linear", gpu, forceFullFrameRate: forceFullFps = false, observeElement: shouldObserveElement = true, timeOrigin: initialTimeOrigin } = options;
 		if (initialTimeOrigin != null) sharedTimeOrigin = initialTimeOrigin;
@@ -2573,6 +2731,7 @@ function shaderRendererGPU() {
 			});
 			if (abort.signal.aborted) return;
 			root = rootCtx.root;
+			attachUncapturedErrorHandler(root.device);
 			pixelRatio = basePixelRatio();
 			const lim = root.device.limits?.maxTextureDimension2D;
 			if (typeof lim === "number" && lim > 0) cachedMaxTextureDim = lim;
@@ -2636,7 +2795,11 @@ function shaderRendererGPU() {
 			if (currentWidth > 0 && currentHeight > 0) renderFrame();
 			if (shouldAnimate) startAnimation();
 		} catch (error) {
-			console.error("[gpu] initialization error:", error);
+			const reason = isGpuUnavailableError(error) ? error.reason : "init-failed";
+			isInitializing = false;
+			if (initializationAbortController === abort) initializationAbortController = null;
+			fail(reason, error);
+			return;
 		} finally {
 			isInitializing = false;
 			if (initializationAbortController === abort) initializationAbortController = null;
@@ -2656,10 +2819,6 @@ function shaderRendererGPU() {
 			globalEventUnregister();
 			globalEventUnregister = null;
 		}
-		if (canvasElement) {
-			canvasElement.removeEventListener("mousedown", onPointerDown);
-			canvasElement.removeEventListener("touchstart", onTouchStart);
-		}
 		if (unloadHandler && typeof window !== "undefined") {
 			window.removeEventListener("beforeunload", unloadHandler);
 			unloadHandler = null;
@@ -2673,6 +2832,10 @@ function shaderRendererGPU() {
 			pendingRenderRAF = null;
 		}
 		stopAnimation();
+		detachUncapturedErrorHandler();
+		try {
+			rootCtx?.release?.();
+		} catch {}
 		pipelineCache.clear();
 		for (const c of [...liveCompositions]) disposeComposition(c);
 		boundComposition = null;
@@ -2710,11 +2873,14 @@ function shaderRendererGPU() {
 		pointerX = .5;
 		pointerY = .5;
 		pointerActive = false;
+		mouseListenersNeeded = false;
 		onReadyCallback = null;
 		hasEmittedReady = false;
 		firstRenderPending = false;
 		onDeviceLostCallback = null;
 		deviceLostFired = false;
+		uncapturedValidationErrors = 0;
+		consecutiveRenderErrors = 0;
 	};
 	const getPerformanceStats = () => {
 		const nodeCount = Math.max(0, nodes.size - 1);
@@ -2817,6 +2983,21 @@ function shaderRendererGPU() {
 		setOnDeviceLost: (callback) => {
 			onDeviceLostCallback = callback;
 		},
+		setOnUnavailable: (callback) => {
+			onUnavailableCallback = callback;
+			if (callback && failureReason && !hasNotifiedUnavailable) {
+				hasNotifiedUnavailable = true;
+				const reason = failureReason;
+				queueMicrotask(() => {
+					try {
+						callback(reason);
+					} catch (e) {
+						debugError("[gpu] onUnavailable callback threw:", e);
+					}
+				});
+			}
+		},
+		getFailureReason: () => failureReason,
 		__testing: {
 			needsTransformation,
 			findChildNodes,
@@ -2824,6 +3005,14 @@ function shaderRendererGPU() {
 				const node = nodes.get(id);
 				return node ? buildFieldInits(node) : null;
 			},
+			ensureDriverState: (id) => {
+				const node = nodes.get(id);
+				if (node) ensureDriverState(node);
+			},
+			stepMouseDrivers: (deltaTime) => {
+				frameParams.deltaTime = deltaTime;
+				updateMouseDrivers();
+			},
 			stepAnimatedTime: (deltaTime) => {
 				frameParams.deltaTime = deltaTime;
 				updateAnimatedTime();
@@ -2900,12 +3089,12 @@ function createRendererFromJSON(preset, options) {
 		registerPresetNodes();
 		coreRenderer.stopAnimation();
 	}
-	async function renderFrame() {
+	async function renderFrame(options$1) {
 		if (!coreRenderer.isInitialized()) {
-			console.warn("[presetRenderer] Renderer not yet initialized, skipping frame");
+			debugWarn("[presetRenderer] Renderer not yet initialized, skipping frame");
 			return;
 		}
-		await coreRenderer.renderAndWait();
+		await coreRenderer.renderAndWait(options$1);
 	}
 	function updatePreset(newPreset) {
 		nodeIdMap.forEach((_, nodeId) => {
@@ -2974,7 +3163,9 @@ function createRendererFromJSON(preset, options) {
 		renderFrame,
 		updatePreset,
 		getGPUContext,
-		dispose
+		dispose,
+		setOnUnavailable: coreRenderer.setOnUnavailable,
+		getFailureReason: coreRenderer.getFailureReason
 	};
 }
 function resolveMaskDependencies(nodes) {
@@ -3091,4 +3282,4 @@ function resolveBoundingBox(bbox) {
 		...bbox.lockAspect !== void 0 ? { lockAspect: bbox.lockAspect } : {}
 	};
 }
-export { DEFAULT_BOUNDING_BOX, MAX_COLOR_STOPS, SHAPE3D_DEFAULTS, SHAPE3D_TYPES, SVG3D_DEFAULTS, SVG3D_TYPES, boxLocalToScreenUV, createGpuUniformsMap, createRendererFromJSON, is3dShapeType, isDimensionalValue, isSvg3dShapeType, isVolumetricShapeType, resolveBoundingBox, resolveMaskDependencies, resolveStops, rootPassthrough, screenUVToBoxLocal, shaderRendererGPU, shape3dBoundingRadius, sortStops };
+export { DEFAULT_BOUNDING_BOX, GpuUnavailableError, MAX_COLOR_STOPS, SHAPE3D_DEFAULTS, SHAPE3D_TYPES, SVG3D_DEFAULTS, SVG3D_TYPES, boxLocalToScreenUV, createGpuUniformsMap, createRendererFromJSON, debugError, debugWarn, destroyDefaultGpuDevice, getWebGPUSupport, is3dShapeType, isDimensionalValue, isGpuUnavailableError, isShadersDebug, isSvg3dShapeType, isVolumetricShapeType, isWebGPUSupported, resolveBoundingBox, resolveMaskDependencies, resolveStops, rootPassthrough, screenUVToBoxLocal, setShadersDebug, shaderRendererGPU, shape3dBoundingRadius, sortStops };