shaders 3.0.443 → 3.0.445

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 { $t as resolveBoundingBox, Cn as FieldHandle, Dt as packConvertedStops, En as updateFieldValue, Ot as packStops, Qt as isIdentityBoundingBox, S as maxPixelRatioForDevice, Ut as collectStructuralHashInputs, Wt as composeNodeTree, Y as createComputeDispatcher, Zt as DEFAULT_BOUNDING_BOX, en as boundingBoxToUVParams, kt as getAnimatedTimeState, nn as screenUVToBoxLocal$1, t as SystemUniforms, tn as needsTransformation, wn as createUniformStore, zt as SHARED_SAMPLER_LAYOUT } from "./coords-BkIjixe_.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-sOqjtPJD.js";
+import "./Neon-BjBSg2FR.js";
+import "./Emboss-RxgVyKyU.js";
+import "./Form3D-CJKutcFA.js";
+import "./ThinFilm-DhQXCGw9.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-Bl3WB9VW.js";
+import "./AngularBlur-D33jrcZd.js";
+import "./Arc-BG8Bpknl.js";
+import "./Ascii-DE0vAAOX.js";
+import "./Aurora-Cu4JGjCD.js";
+import "./BarnDoors-JraHuTwe.js";
+import "./BarShift-o_IvV0t_.js";
+import "./Beam-DshQatlM.js";
+import "./Bend-KJzYWEJV.js";
+import "./Blob-BJxkqvOO.js";
+import "./BlockDissolve-CsIQWUpY.js";
+import "./noiseColor-CY6QVFgB.js";
+import "./BlockNoise-DVI-0PnC.js";
+import "./BlueNoise-CzBN6i38.js";
+import "./Blur-W95k4Lxz.js";
+import "./Boids-BJ6wxFC8.js";
+import "./BokehBlur-CbOO__cN.js";
+import "./BrickPattern-eQv5DrKE.js";
+import "./BrightnessContrast-CmH2DvaZ.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-Cl58vRlg.js";
+import "./BrushedMetal-D-7M7ZuM.js";
+import "./Bulge-KmBnaVMx.js";
+import "./CarbonFiber-D4jap49E.js";
+import "./Chalkboard-H6-0OXC3.js";
+import "./ChannelBlur-BKJfnu91.js";
+import "./Checkerboard-NwKMLVHe.js";
+import "./CheckerWipe-acIaflfK.js";
+import "./Chevron-eBbFV2ud.js";
+import "./ChromaFlow-ex7l4tTK.js";
+import "./ChromaticAberration-Bbi9vNxS.js";
+import "./Circle-DdFWEti1.js";
+import "./ColorWheel-BqcyPqcj.js";
+import "./CompressionArtifacts-DqWq-4h8.js";
+import "./ConcentricSpin-CtI1hKio.js";
+import "./ConicGradient-HmImN4LO.js";
+import "./ContourLines-BMom2vMu.js";
+import "./CornerPin-D_-luriU.js";
+import "./Crescent-CY6MeN9V.js";
+import "./Cross-ClImej9a.js";
+import "./CRTScreen-t7dyfO5u.js";
+import "./Crystal-CMrqHLFD.js";
+import "./CurlNoise-C_QZBT5m.js";
+import "./CursorRipples-Bmlex_IF.js";
+import "./CursorTrail-B68x1Cv-.js";
+import "./DataMosh-FZQWg5Ui.js";
+import "./DiamondGradient-C0hD1lNN.js";
+import "./DiamondWipe-B8rFSwsV.js";
+import "./DiffuseBlur--Gn4bDwC.js";
+import "./DisplacementMap-DQk8S4sK.js";
+import "./Dither-rB9M7FS7.js";
+import "./DotGrid-DszAbmy5.js";
+import "./DropShadow-BS3S178o.js";
+import "./Duotone-Cf_ybegD.js";
+import "./Ellipse-DY8FgSSx.js";
+import "./Engraving-C0OuioUr.js";
+import "./ErosionNoise-B-I3VFiY.js";
+import "./Exposure-360tdOrT.js";
+import "./FallingLines-4sVKJMDj.js";
+import "./FilmGrain-CgzuRidb.js";
+import "./FilmStock-BW9k3EPE.js";
+import "./Flip-DqdxtYHS.js";
+import "./FloatingParticles-BI8Y9Gcv.js";
+import "./Flower-IaNzANoa.js";
+import "./FlowField-CV0Is569.js";
+import "./FlowingGradient-CEAAa11t.js";
+import "./FlutedGlass-CF6mZMq4.js";
+import "./Fog-D9OYGwhY.js";
+import "./FractalNoise-DelBWQyb.js";
+import "./Frost-Br7b9n4L.js";
+import "./GaborNoise-DViNgIse.js";
+import "./Glass-IwPea9h1.js";
+import "./GlassTiles-DpPHPKv7.js";
+import "./Glitch-CKmX-agV.js";
+import "./Glow-CVcVetaa.js";
+import "./Godrays-CNNHJzNz.js";
+import "./Goo-BUXnhwTk.js";
+import "./GradientMap-DqGEXRl9.js";
+import "./Grayscale-DiJAjdx3.js";
+import "./Grid-utmP7uyR.js";
+import "./GridDistortion-Bn6D5dfC.js";
+import "./Group-u-o7qE0Y.js";
+import "./Halftone-C5La06l6.js";
+import "./Heart-CGLx1F8D.js";
+import "./Heatmap-CE5DLeJp.js";
+import "./HexGrid-CqB-yMWN.js";
+import "./Hologram-CctodmpA.js";
+import "./Holographic-DSz4qfkn.js";
+import "./HTMLInCanvas-sK9HN-gI.js";
+import "./HueShift-Cfq-ijQP.js";
+import "./ImageTexture-DdzAYFTi.js";
+import "./InkFlow-CCPfoQXs.js";
+import "./Invert-CtUHcYmv.js";
+import "./IrisWipe-DWVFMn81.js";
+import "./IsometricCubes-m-mYnbqN.js";
+import "./Kaleidoscope-DMNLVgx6.js";
+import "./KeyFrames-jgrfR3Hj.js";
+import "./LensFlare-CuWJsfwE.js";
+import "./LightEdge-WMxb-xKB.js";
+import "./LightLeak-DfOngFp7.js";
+import "./LinearBlur-iLXYGof_.js";
+import "./LinearGradient-DLrJban6.js";
+import "./LinearWipe-C_fWBl4i.js";
+import "./LiquidMetal-DHM8kVNr.js";
+import "./Liquify-FQWL8j4t.js";
+import "./MagneticFilings-BUzSkycD.js";
+import "./Marble-BnHffB3C.js";
+import "./Mirror-B_v4FunG.js";
+import "./MultiPointGradient-5NGBm90u.js";
+import "./NoiseDissolve-kDP6-h9F.js";
+import "./fonts-BtGjHq1w.js";
+import "./ObjectTracker-vU1bVmIJ.js";
+import "./PagePeel-BgDvgtIV.js";
+import "./Paper-_alN4JdS.js";
+import "./Parallelogram--Cil139y.js";
+import "./ParticleField-DZ7um7tu.js";
+import "./ParticleFlow-CmRP2S8W.js";
+import "./Particles-DFw2E9SE.js";
+import "./PerlinNoise-BmNpwJtM.js";
+import "./Perspective-DVcUW7jR.js";
+import "./Pixelate-D-eWrHTE.js";
+import "./PixelSort-Bz5dIrqH.js";
+import "./PixelThrow-DEMX8VOw.js";
+import "./Plasma-C_EIkpQi.js";
+import "./Plastic-CYeefb91.js";
+import "./PolarCoordinates-DmpUBdGX.js";
+import "./Polygon-DEEUdZd6.js";
+import "./Posterize-B8oVbNZL.js";
+import "./Prism-Btijlm0t.js";
+import "./ProgressiveBlur-BoRFh6Tn.js";
+import "./RadialGradient-CNDiMPZM.js";
+import "./RadialWipe-C213vCrJ.js";
+import "./RandomBars-hOY9hNS7.js";
+import "./ReactionDiffusion--UjME4_r.js";
+import "./RectangularCoordinates-DB7rPJ2Z.js";
+import "./ReflectivePlane-D92GjNLR.js";
+import "./Repeater-CJjylN6O.js";
+import "./Ring-CJYQP2Qm.js";
+import "./Ripples-Brj67b7H.js";
+import "./RippleWipe-DJlrObO0.js";
+import "./RoundedRect-3vfFsHAl.js";
+import "./Saturation-lx3DV3Up.js";
+import "./Scratches-CMFr8AfL.js";
+import "./Sharpness-ByZbUAd0.js";
+import "./Shatter-B1_rLacw.js";
+import "./SimplexNoise-zItLLG1j.js";
+import "./SineWave-BvrhRcvv.js";
+import "./SliceWipe-9bUWTClo.js";
+import "./Smoke-YixCTJbh.js";
+import "./SmokeFill-Cccbyi4g.js";
+import "./SmokeFlow-DJ3sQPH1.js";
+import "./Solarize-CZeTsJG8.js";
+import "./SolidColor-DB8l6xRl.js";
+import "./Spherize-BdYP0Auv.js";
+import "./Spiral-PPqgFMRM.js";
+import "./Star-mgLhY4e_.js";
+import "./noiseStylize-BsZQT7ig.js";
+import "./Stone-CehIcoVu.js";
+import "./Strands-Dzj-5h31.js";
+import "./Stretch-C82iJhQu.js";
+import "./Stripes-C3XL9mWC.js";
+import "./StudioBackground-CDpLmvMH.js";
+import "./SunBurst-fFeTV8O4.js";
+import "./Surface3D-BFGuR3YZ.js";
+import "./Swirl-DGZs_YDx.js";
+import "./Teardrop-DN7t-3HU.js";
+import "./Text-DuQnSDiW.js";
+import "./TiltShift-CpHBxw5I.js";
+import "./TimeTrail-j89dMqNU.js";
+import "./Tint-WmBROyUm.js";
+import "./Trapezoid-RrEwHfyH.js";
+import "./TriangularGrid-D7r3Nhss.js";
+import "./Tritone-BREi33uL.js";
+import "./Truchet-CTjP4x60.js";
+import "./Twirl-Bvk8-3JT.js";
+import "./VenetianBlinds-Bv0f2lFw.js";
+import "./Vesica-BV2Sz5VV.js";
+import "./VHS-et86dWDU.js";
+import "./Vibrance-Q9Mrvfs-.js";
+import "./VideoTexture-BUY69Gqp.js";
+import "./Vignette-DyScJQWj.js";
+import "./Voronoi-DxoT7iRa.js";
+import "./Water-CE1rY4LR.js";
+import "./Watercolor-Buk5FkKR.js";
+import "./WaveDistortion-Ca6y77xt.js";
+import "./WaveletNoise-Y7LdptK_.js";
+import "./Weave-CTpPvAhK.js";
+import "./WebcamTexture-85gdzpo_.js";
+import "./Wool-DJJkx7S2.js";
+import "./WorleyNoise-C_CHhfMF.js";
+import "./ZoomBlur-8tmVWx1n.js";
+import { t as getAllShaders } from "./shaderRegistry-CSTwovjI.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,
@@ -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,
@@ -1351,7 +1380,7 @@ function shaderRendererGPU() {
 			aspectRatio: aspectRatio()
 		};
 	};
-	const bboxActive = (node) => !!node.metadata.boundingBox && !!node.boundingBoxDeclaration;
+	const bboxActive = (node) => !!node.metadata.boundingBox && !!node.boundingBoxDeclaration && !isIdentityBoundingBox(node.metadata.boundingBox);
 	const computeNodeBoundsUV = (node) => {
 		const decl = node.boundingBoxDeclaration;
 		if (!decl || !node.uniforms) return null;
@@ -1756,7 +1785,7 @@ function shaderRendererGPU() {
 		const parts = [];
 		for (const [id, node] of nodes) {
 			const m = node.metadata;
-			if (node.hasUvRemap || node.acceptsUVContext) parts.push(`aopac:${id}:${(m.opacity ?? 1) < 1}`);
+			parts.push(`aopac:${id}:${(m.opacity ?? 1) < 1}`);
 			const sc = node.uniforms.stopCount?.value;
 			if (typeof sc === "number") parts.push(`stops:${id}:${sc > 1 ? sc : 0}`);
 			for (const [prop, u] of Object.entries(node.uniforms)) {
@@ -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) {
@@ -2017,7 +2048,7 @@ function shaderRendererGPU() {
 			const newOpacity = metadata.opacity;
 			node.metadata.opacity = newOpacity;
 			writeSyntheticScalar(node, "_opacity", newOpacity);
-			if ((node.hasUvRemap || node.acceptsUVContext) && oldOpacity >= 1 !== newOpacity >= 1) needsRecompose = true;
+			if (oldOpacity >= 1 !== newOpacity >= 1) needsRecompose = true;
 		}
 		if (metadata.renderOrder !== void 0 && node.metadata.renderOrder !== metadata.renderOrder) {
 			node.metadata.renderOrder = metadata.renderOrder;
@@ -2104,10 +2135,12 @@ function shaderRendererGPU() {
 		if (metadata.boundingBox !== void 0 && metadata.boundingBox !== null && node.boundingBoxDeclaration !== void 0) {
 			const wasActive = bboxActive(node);
 			node.metadata.boundingBox = metadata.boundingBox;
-			if (wasActive) {
+			const nowActive = bboxActive(node);
+			if (wasActive !== nowActive) needsRecompose = true;
+			else if (nowActive) {
 				const bb = bboxFieldValues(node);
 				if (bb) for (const [k, v] of Object.entries(bb)) writeSyntheticScalar(node, `_bbox_${k}`, v);
-			} else needsRecompose = true;
+			}
 		} else if (metadata.boundingBox === null) {
 			if (node.metadata.boundingBox !== void 0) {
 				node.metadata.boundingBox = void 0;
@@ -2287,7 +2320,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 +2404,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 +2431,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 +2468,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 +2498,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 +2623,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 +2733,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 +2797,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 +2834,10 @@ function shaderRendererGPU() {
 			pendingRenderRAF = null;
 		}
 		stopAnimation();
+		detachUncapturedErrorHandler();
+		try {
+			rootCtx?.release?.();
+		} catch {}
 		pipelineCache.clear();
 		for (const c of [...liveCompositions]) disposeComposition(c);
 		boundComposition = null;
@@ -2764,6 +2881,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 +2985,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 +3091,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 +3165,9 @@ function createRendererFromJSON(preset, options) {
 		renderFrame,
 		updatePreset,
 		getGPUContext,
-		dispose
+		dispose,
+		setOnUnavailable: coreRenderer.setOnUnavailable,
+		getFailureReason: coreRenderer.getFailureReason
 	};
 }
 function resolveMaskDependencies(nodes) {
@@ -3111,41 +3247,4 @@ const boxLocalToScreenUV = (bx, by, g) => {
 		y: sqy + g.centerY
 	};
 };
-const DEFAULT_BOUNDING_BOX = {
-	x: {
-		value: 0,
-		unit: "uv"
-	},
-	y: {
-		value: 0,
-		unit: "uv"
-	},
-	width: {
-		value: 1,
-		unit: "uv"
-	},
-	height: {
-		value: 1,
-		unit: "uv"
-	},
-	origin: "top-left",
-	rotation: 0
-};
-function resolveBoundingBox(bbox) {
-	if (!bbox || typeof bbox !== "object") return void 0;
-	const dim = (d$1, fallback) => d$1 && typeof d$1 === "object" ? {
-		value: d$1.value ?? fallback.value,
-		unit: d$1.unit ?? fallback.unit
-	} : { ...fallback };
-	return {
-		x: dim(bbox.x, DEFAULT_BOUNDING_BOX.x),
-		y: dim(bbox.y, DEFAULT_BOUNDING_BOX.y),
-		width: dim(bbox.width, DEFAULT_BOUNDING_BOX.width),
-		height: dim(bbox.height, DEFAULT_BOUNDING_BOX.height),
-		origin: bbox.origin ?? "top-left",
-		rotation: bbox.rotation ?? 0,
-		...bbox.cornerRadius ? { cornerRadius: bbox.cornerRadius } : {},
-		...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 };