shaders 3.0.443 → 3.0.444

package/dist/core/index.js

@@ -1,264 +1,280 @@
-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-0A7CojvN.js";
-import "./glass-BjUqcmHP.js";
-import "./Neon-RDh1tAjH.js";
-import "./Emboss-C8ElxLo3.js";
-import "./Form3D-BZ_vaLWe.js";
-import "./ThinFilm-CEYaV4nn.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-B1jqpcE3.js";
-import "./AngularBlur-CJsRS1Ri.js";
-import "./Arc-CNesL3S9.js";
-import "./Ascii-z7til0PQ.js";
-import "./Aurora-BAuYUYGc.js";
-import "./BarnDoors-DrOAeSqj.js";
-import "./BarShift-qVwbTMcq.js";
-import "./Beam-BW6yblZw.js";
-import "./Bend-B7PMQ3T5.js";
-import "./Blob-CRJ5N0hK.js";
-import "./BlockDissolve-D-6Wy66g.js";
-import "./noiseColor-w3B94vmT.js";
-import "./BlockNoise-Ct9Fae_7.js";
-import "./BlueNoise-Cu7rJuP0.js";
-import "./Blur-BrdVVSPq.js";
-import "./Boids-DIzUaLGM.js";
-import "./BokehBlur-yYb03spN.js";
-import "./BrickPattern-BL_MOS_A.js";
-import "./BrightnessContrast-CiKimIcA.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-DRyn6AvG.js";
-import "./BrushedMetal-dvYjizvg.js";
-import "./Bulge-CogpoPKe.js";
-import "./CarbonFiber-CTy3P-Qk.js";
-import "./Chalkboard-CnHUOHtc.js";
-import "./ChannelBlur-MwnpNLSZ.js";
-import "./Checkerboard-C97ZiLyQ.js";
-import "./CheckerWipe-CCNc70ye.js";
-import "./Chevron-ABT6D1wM.js";
-import "./ChromaFlow-7tJQEFm9.js";
-import "./ChromaticAberration-D7-fxyEd.js";
-import "./Circle-I0DIAypS.js";
-import "./ColorWheel-CEqzzrN-.js";
-import "./CompressionArtifacts-C24nRoC3.js";
-import "./ConcentricSpin-CAu-PGNH.js";
-import "./ConicGradient-n12K5TLj.js";
-import "./ContourLines-FOStIWDr.js";
-import "./CornerPin-DsUVMFcX.js";
-import "./Crescent-9i_5WPA-.js";
-import "./Cross-HiA69xGL.js";
-import "./CRTScreen-X64EnHMB.js";
-import "./Crystal-BBjEm9m4.js";
-import "./CurlNoise-1jifziI0.js";
-import "./CursorRipples-D4agAYHK.js";
-import "./CursorTrail-C-FrY0e2.js";
-import "./DataMosh-DXcM1I4Y.js";
-import "./DiamondGradient-CQ5jeKEc.js";
-import "./DiamondWipe-B1EXgweH.js";
-import "./DiffuseBlur-CmD97dHb.js";
-import "./DisplacementMap-JV_CNJfU.js";
-import "./Dither-NJDWpGb3.js";
-import "./DotGrid-B2w7RFcv.js";
-import "./DropShadow-CLWp-bon.js";
-import "./Duotone-Be2jx-jZ.js";
-import "./Ellipse-BR6qXidK.js";
-import "./Engraving-D67DM--1.js";
-import "./ErosionNoise-FeEMQOkR.js";
-import "./Exposure-CZ1gfqpf.js";
-import "./FallingLines-ifuQ01oA.js";
-import "./FilmGrain-p5sawa_f.js";
-import "./FilmStock-BD5wv1TV.js";
-import "./Flip-MKiLH9jJ.js";
-import "./FloatingParticles-Bn8CmtwG.js";
-import "./Flower-BwDBwcSk.js";
-import "./FlowField-BdFeRmif.js";
-import "./FlowingGradient-RYOS36eB.js";
-import "./FlutedGlass-Ong8W4Ih.js";
-import "./Fog-C-X8msRb.js";
-import "./FractalNoise-BPj8RPkE.js";
-import "./Frost-DmxlFu63.js";
-import "./GaborNoise-Boc8ieHd.js";
-import "./Glass-D5p21MIw.js";
-import "./GlassTiles-BP4CzdI3.js";
-import "./Glitch-cJguD7jS.js";
-import "./Glow-BabfcnwS.js";
-import "./Godrays-BpiKSlNR.js";
-import "./Goo-BaQEtOyr.js";
-import "./GradientMap-BtKtW-4M.js";
-import "./Grayscale-Bgwugyvv.js";
-import "./Grid-5cEDkyWX.js";
-import "./GridDistortion-Byf4G720.js";
-import "./Group-DUEQSUir.js";
-import "./Halftone-BiSLVvGF.js";
-import "./Heart-RAGeVEVH.js";
-import "./Heatmap-Ds65scO7.js";
-import "./HexGrid-H1N5Y1XD.js";
-import "./Hologram-DpDfyeSz.js";
-import "./Holographic-Ckubuqn8.js";
-import "./HTMLInCanvas-uW1O3Z-R.js";
-import "./HueShift-C_a5UVHy.js";
-import "./ImageTexture-CM-dPJQ4.js";
-import "./InkFlow-CY7sCKpI.js";
-import "./Invert-DhHrtwHQ.js";
-import "./IrisWipe-BnOMUdEV.js";
-import "./IsometricCubes-CXPz62PB.js";
-import "./Kaleidoscope-CSgi0E5B.js";
-import "./KeyFrames-C3I4poq8.js";
-import "./LensFlare-DxvbKXgt.js";
-import "./LightEdge-niXz_FAk.js";
-import "./LightLeak-B7Pt1tt4.js";
-import "./LinearBlur-CXNcduWQ.js";
-import "./LinearGradient-CYiaWIXd.js";
-import "./LinearWipe-gwLhEveK.js";
-import "./LiquidMetal-D0sgLjcd.js";
-import "./Liquify-h08a8S-C.js";
-import "./MagneticFilings-BlNWPVwS.js";
-import "./Marble-bps2lOWc.js";
-import "./Mirror-8miSUAyZ.js";
-import "./MultiPointGradient-C-9_Q6CM.js";
-import "./NoiseDissolve-DjlWGdUc.js";
-import "./fonts-BLmvxkGd.js";
-import "./ObjectTracker-DW4aEBRv.js";
-import "./PagePeel-JsbScYi4.js";
-import "./Paper-BGTU0GOF.js";
-import "./Parallelogram-RC3MxzlN.js";
-import "./ParticleField-XypD7Eru.js";
-import "./ParticleFlow-DBw7m9C6.js";
-import "./Particles-CvpZvfe3.js";
-import "./PerlinNoise-CHVaarmz.js";
-import "./Perspective-zyCZAb3_.js";
-import "./Pixelate-D1e7buDQ.js";
-import "./PixelSort-B-zefB9S.js";
-import "./PixelThrow-BZ6erf3G.js";
-import "./Plasma-CBrx8Xu-.js";
-import "./Plastic-CcS4iAJM.js";
-import "./PolarCoordinates-B9SuYLgF.js";
-import "./Polygon-N0l1KfIO.js";
-import "./Posterize-u2et79Pv.js";
-import "./Prism-BnDsPBcD.js";
-import "./ProgressiveBlur-D9FiTJQy.js";
-import "./RadialGradient-C4oB78ya.js";
-import "./RadialWipe-Dzb7i6wy.js";
-import "./RandomBars-DO9j43mN.js";
-import "./ReactionDiffusion-DG1NSPhM.js";
-import "./RectangularCoordinates-Ck1gXdGx.js";
-import "./ReflectivePlane-DFQDgLYC.js";
-import "./Repeater-CT35_BhW.js";
-import "./Ring-DywDgKDv.js";
-import "./Ripples-fTSMeqiE.js";
-import "./RippleWipe-ePWlg-DT.js";
-import "./RoundedRect-B0lxuFfM.js";
-import "./Saturation-ClaD54dk.js";
-import "./Scratches-D8ZIBZ50.js";
-import "./Sharpness-CsnT4s1o.js";
-import "./Shatter-D_V7GBel.js";
-import "./SimplexNoise-tI2G3Wzn.js";
-import "./SineWave-BGsYyEFg.js";
-import "./SliceWipe-s4pWdINK.js";
-import "./Smoke-C3SLe_rD.js";
-import "./SmokeFill-BuKZtbX8.js";
-import "./SmokeFlow-5fnVH2a9.js";
-import "./Solarize-TP85IPV7.js";
-import "./SolidColor-16e4q89i.js";
-import "./Spherize-C4qsnql6.js";
-import "./Spiral-rPHDFACm.js";
-import "./Star-BDFhZWLo.js";
-import "./noiseStylize-4za6Obes.js";
-import "./Stone-CCXo9IgA.js";
-import "./Strands-DCzYUsCX.js";
-import "./Stretch-CjhYXAth.js";
-import "./Stripes-CN2TFWGw.js";
-import "./StudioBackground-I_XxtKjr.js";
-import "./SunBurst-CGQkdsXl.js";
-import "./Surface3D-CpCPTs0u.js";
-import "./Swirl-BCnlG3G8.js";
-import "./Teardrop-DX-YZkNC.js";
-import "./Text-oI5d7_UD.js";
-import "./TiltShift-C8GluqAm.js";
-import "./TimeTrail-CPiSo5Of.js";
-import "./Tint-NA7BO-Qk.js";
-import "./Trapezoid-BOGSQvW5.js";
-import "./TriangularGrid-Zx3I4CqA.js";
-import "./Tritone-Bl69W4Y4.js";
-import "./Truchet-RJI0-v6x.js";
-import "./Twirl-CrIawDs2.js";
-import "./VenetianBlinds-CGfPlhGd.js";
-import "./Vesica-DekjxkHL.js";
-import "./VHS-B12KbScc.js";
-import "./Vibrance-DKKduAD8.js";
-import "./VideoTexture-1xg_a680.js";
-import "./Vignette-CDRCMNb2.js";
-import "./Voronoi-EWj3WFqv.js";
-import "./Water-BdGrOEuE.js";
-import "./Watercolor-BGIcnGZu.js";
-import "./WaveDistortion-BNlrOaur.js";
-import "./WaveletNoise-Jv-694xX.js";
-import "./Weave-HNS6xvOs.js";
-import "./WebcamTexture-DVKxGpWI.js";
-import "./Wool-D7uM0JRs.js";
-import "./WorleyNoise-DsDWmRCp.js";
-import "./ZoomBlur-S2GfQojf.js";
-import { t as getAllShaders } from "./shaderRegistry-BrbiIqjD.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);
-		}
-		if (!replacement) {
-			console.warn("[gpu] injected GPU device was lost — creating a replacement device for recovery");
-			replacement = createOwnRoot();
-			replacementRoots.set(device, replacement);
+		let root = rootsByDevice.get(device);
+		if (!root) {
+			root = tgpu.initFromDevice({ device });
+			rootsByDevice.set(device, root);
 		}
-		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,
@@ -282,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;
@@ -387,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();
@@ -402,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;
 		}
 	}
@@ -436,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;
 		}
 	}
@@ -462,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({
@@ -552,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;
@@ -1141,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();
@@ -1149,7 +1171,7 @@ var globalEventManager = (() => {
 			try {
 				cb[key](arg);
 			} catch (error) {
-				console.error("[Shaders] Error in pointer handler:", error);
+				debugError("[Shaders] Error in pointer handler:", error);
 			}
 		});
 	};
@@ -1261,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,
@@ -1816,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;
@@ -1858,6 +1887,7 @@ function shaderRendererGPU() {
 		requestRender();
 	};
 	const requestRender = () => {
+		if (failureReason) return;
 		if (frameLoop.running) return;
 		if (pendingRenderRAF !== null) return;
 		if (typeof requestAnimationFrame !== "function") return;
@@ -1867,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) {
@@ -2287,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());
@@ -2371,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;
@@ -2398,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);
@@ -2435,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 {
@@ -2463,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();
 	};
@@ -2587,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;
@@ -2625,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;
@@ -2688,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;
@@ -2721,6 +2832,10 @@ function shaderRendererGPU() {
 			pendingRenderRAF = null;
 		}
 		stopAnimation();
+		detachUncapturedErrorHandler();
+		try {
+			rootCtx?.release?.();
+		} catch {}
 		pipelineCache.clear();
 		for (const c of [...liveCompositions]) disposeComposition(c);
 		boundComposition = null;
@@ -2764,6 +2879,8 @@ function shaderRendererGPU() {
 		firstRenderPending = false;
 		onDeviceLostCallback = null;
 		deviceLostFired = false;
+		uncapturedValidationErrors = 0;
+		consecutiveRenderErrors = 0;
 	};
 	const getPerformanceStats = () => {
 		const nodeCount = Math.max(0, nodes.size - 1);
@@ -2866,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,
@@ -2957,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) => {
@@ -3031,7 +3163,9 @@ function createRendererFromJSON(preset, options) {
 		renderFrame,
 		updatePreset,
 		getGPUContext,
-		dispose
+		dispose,
+		setOnUnavailable: coreRenderer.setOnUnavailable,
+		getFailureReason: coreRenderer.getFailureReason
 	};
 }
 function resolveMaskDependencies(nodes) {
@@ -3148,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 };