@react-three/fiber 10.0.0-canary.2c50459 → 10.0.0-canary.4bc4a97

package/dist/index.mjs

@@ -1,22 +1,21 @@
 import * as webgpu from 'three/webgpu';
-import { RenderTarget, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, Scene, WebGLCubeRenderTarget, HalfFloatType, Color, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer } from 'three/webgpu';
-import { WebGLRenderTarget, WebGLRenderer } from 'three';
+import { CubeRenderTarget, RenderTarget, Frustum, Matrix4, Group, BoxGeometry, MeshBasicNodeMaterial, Mesh, Node, NodeUpdateType, Layers, ShaderMaterial, Uniform, SRGBColorSpace, RGBAFormat, UnsignedByteType, Vector3, Vector2, TextureLoader, Texture as Texture$1, CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader, CanvasTarget, Raycaster, OrthographicCamera, PerspectiveCamera, Scene, PCFShadowMap, VSMShadowMap, BasicShadowMap, ACESFilmicToneMapping, WebGPURenderer, HalfFloatType, Color } from 'three/webgpu';
+import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer } from 'three';
 import { Inspector } from 'three/addons/inspector/Inspector.js';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 import * as React from 'react';
-import React__default, { useLayoutEffect, useRef, useMemo, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
+import React__default, { useRef, useMemo, useLayoutEffect, useEffect, useContext, useImperativeHandle, useCallback, useState } from 'react';
 import useMeasure from 'react-use-measure';
 import { useFiber, useContextBridge, traverseFiber, FiberProvider } from 'its-fine';
-import { useThree as useThree$1, useLoader as useLoader$1, useFrame as useFrame$1, createPortal as createPortal$1, applyProps as applyProps$1, extend as extend$1 } from '@react-three/fiber';
+import { createWithEqualityFn } from 'zustand/traditional';
+import { getScheduler } from '@pmndrs/scheduler';
+export { Scheduler, getScheduler } from '@pmndrs/scheduler';
+import Tb, { unstable_getCurrentPriorityLevel, unstable_IdlePriority, unstable_LowPriority, unstable_NormalPriority, unstable_UserBlockingPriority, unstable_ImmediatePriority, unstable_scheduleCallback } from 'scheduler';
 import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
 import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
 import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
 import { UltraHDRLoader } from 'three/examples/jsm/loaders/UltraHDRLoader.js';
 import { GainMapLoader } from '@monogrid/gainmap-js';
-import Tb, { unstable_scheduleCallback, unstable_IdlePriority } from 'scheduler';
-import { createWithEqualityFn } from 'zustand/traditional';
-import { getScheduler } from '@pmndrs/scheduler';
-export { Scheduler, getScheduler } from '@pmndrs/scheduler';
 import { suspend, preload, clear } from 'suspend-react';
 
 function _mergeNamespaces(n, m) {
@@ -36,10 +35,13 @@ const R3F_BUILD_WEBGPU = true;
 
 const THREE = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
+  CubeRenderTarget: CubeRenderTarget,
+  CubeRenderTargetCompat: CubeRenderTarget,
   Inspector: Inspector,
   R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
   R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
   RenderTargetCompat: RenderTarget,
+  WebGLCubeRenderTarget: WebGLCubeRenderTarget,
   WebGLRenderTarget: WebGLRenderTarget,
   WebGLRenderer: WebGLRenderer
 }, [webgpu]);
@@ -102,550 +104,223 @@ function getPrimaryIds() {
   return Array.from(primaryRegistry.keys());
 }
 
-const presetsObj = {
-  apartment: "lebombo_1k.hdr",
-  city: "potsdamer_platz_1k.hdr",
-  dawn: "kiara_1_dawn_1k.hdr",
-  forest: "forest_slope_1k.hdr",
-  lobby: "st_fagans_interior_1k.hdr",
-  night: "dikhololo_night_1k.hdr",
-  park: "rooitou_park_1k.hdr",
-  studio: "studio_small_03_1k.hdr",
-  sunset: "venice_sunset_1k.hdr",
-  warehouse: "empty_warehouse_01_1k.hdr"
-};
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
+function useMutableCallback(fn) {
+  const ref = React.useRef(fn);
+  useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
+  return ref;
+}
+function useBridge() {
+  const fiber = useFiber();
+  const ContextBridge = useContextBridge();
+  return React.useMemo(
+    () => ({ children }) => {
+      const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
+      const Root = strict ? React.StrictMode : React.Fragment;
+      return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
+    },
+    [fiber, ContextBridge]
+  );
+}
+function Block({ set }) {
+  useIsomorphicLayoutEffect(() => {
+    set(new Promise(() => null));
+    return () => set(false);
+  }, [set]);
+  return null;
+}
+const ErrorBoundary = /* @__PURE__ */ (() => {
+  var _a;
+  return _a = class extends React.Component {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "state", { error: false });
+    }
+    componentDidCatch(err) {
+      this.props.set(err);
+    }
+    render() {
+      return this.state.error ? null : this.props.children;
+    }
+  }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
+})();
 
-const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
-const isArray = (arr) => Array.isArray(arr);
-const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
-function useEnvironment({
-  files = defaultFiles,
-  path = "",
-  preset = void 0,
-  colorSpace = void 0,
-  extensions
-} = {}) {
-  if (preset) {
-    validatePreset(preset);
-    files = presetsObj[preset];
-    path = CUBEMAP_ROOT;
-  }
-  const multiFile = isArray(files);
-  const { extension, isCubemap } = getExtension(files);
-  const loader = getLoader$1(extension);
-  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
-  const renderer = useThree$1((state) => state.renderer);
-  useLayoutEffect(() => {
-    if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
-    function clearGainmapTexture() {
-      useLoader$1.clear(loader, multiFile ? [files] : files);
+const is = {
+  obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
+  fun: (a) => typeof a === "function",
+  str: (a) => typeof a === "string",
+  num: (a) => typeof a === "number",
+  boo: (a) => typeof a === "boolean",
+  und: (a) => a === void 0,
+  nul: (a) => a === null,
+  arr: (a) => Array.isArray(a),
+  equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
+    if (typeof a !== typeof b || !!a !== !!b) return false;
+    if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
+    const isObj = is.obj(a);
+    if (isObj && objects === "reference") return a === b;
+    const isArr = is.arr(a);
+    if (isArr && arrays === "reference") return a === b;
+    if ((isArr || isObj) && a === b) return true;
+    let i;
+    for (i in a) if (!(i in b)) return false;
+    if (isObj && arrays === "shallow" && objects === "shallow") {
+      for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
+    } else {
+      for (i in strict ? b : a) if (a[i] !== b[i]) return false;
     }
-    renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
-  }, [extension, files, loader, multiFile, renderer.domElement]);
-  const loaderResult = useLoader$1(
-    loader,
-    multiFile ? [files] : files,
-    (loader2) => {
-      if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
-        loader2.setRenderer?.(renderer);
-      }
-      loader2.setPath?.(path);
-      if (extensions) extensions(loader2);
+    if (is.und(i)) {
+      if (isArr && a.length === 0 && b.length === 0) return true;
+      if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
+      if (a !== b) return false;
     }
-  );
-  let texture = multiFile ? (
-    // @ts-ignore
-    loaderResult[0]
-  ) : loaderResult;
-  if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
-    texture = texture.renderTarget?.texture;
-  }
-  texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
-  texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
-  return texture;
-}
-const preloadDefaultOptions = {
-  files: defaultFiles,
-  path: "",
-  preset: void 0,
-  extensions: void 0
-};
-useEnvironment.preload = (preloadOptions) => {
-  const options = { ...preloadDefaultOptions, ...preloadOptions };
-  let { files, path = "" } = options;
-  const { preset, extensions } = options;
-  if (preset) {
-    validatePreset(preset);
-    files = presetsObj[preset];
-    path = CUBEMAP_ROOT;
-  }
-  const { extension } = getExtension(files);
-  if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
-    throw new Error("useEnvironment: Preloading gainmaps is not supported");
-  }
-  const loader = getLoader$1(extension);
-  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
-  useLoader$1.preload(loader, isArray(files) ? [files] : files, (loader2) => {
-    loader2.setPath?.(path);
-    if (extensions) extensions(loader2);
-  });
-};
-const clearDefaultOptins = {
-  files: defaultFiles,
-  preset: void 0
-};
-useEnvironment.clear = (clearOptions) => {
-  const options = { ...clearDefaultOptins, ...clearOptions };
-  let { files } = options;
-  const { preset } = options;
-  if (preset) {
-    validatePreset(preset);
-    files = presetsObj[preset];
+    return true;
   }
-  const { extension } = getExtension(files);
-  const loader = getLoader$1(extension);
-  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
-  useLoader$1.clear(loader, isArray(files) ? [files] : files);
 };
-function validatePreset(preset) {
-  if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
+const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
+const isRef$1 = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
+const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
+const isObject3D = (object) => object?.isObject3D;
+const isTexture = (value) => !!value?.isTexture;
+const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
+const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
+const hasConstructor = (object) => !!object?.constructor;
+
+function calculateDpr(dpr) {
+  const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
+  return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
 }
-function getExtension(files) {
-  const isCubemap = isArray(files) && files.length === 6;
-  const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
-  const firstEntry = isArray(files) ? files[0] : files;
-  const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
-  return { extension, isCubemap, isGainmap };
+function getUuidPrefix(uuid) {
+  return uuid.split("-")[0];
 }
-function getLoader$1(extension) {
-  const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
-  return loader;
+function updateCamera(camera, size) {
+  if (camera.manual) return;
+  if (isOrthographicCamera(camera)) {
+    camera.left = size.width / -2;
+    camera.right = size.width / 2;
+    camera.top = size.height / 2;
+    camera.bottom = size.height / -2;
+  } else {
+    camera.aspect = size.width / size.height;
+  }
+  camera.updateProjectionMatrix();
 }
-
-const isRef$1 = (obj) => obj.current && obj.current.isScene;
-const resolveScene = (scene) => isRef$1(scene) ? scene.current : scene;
-function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
-  sceneProps = {
-    backgroundBlurriness: 0,
-    backgroundIntensity: 1,
-    backgroundRotation: [0, 0, 0],
-    environmentIntensity: 1,
-    environmentRotation: [0, 0, 0],
-    ...sceneProps
-  };
-  const target = resolveScene(scene || defaultScene);
-  const oldbg = target.background;
-  const oldenv = target.environment;
-  const oldSceneProps = {
-    // @ts-ignore
-    backgroundBlurriness: target.backgroundBlurriness,
-    // @ts-ignore
-    backgroundIntensity: target.backgroundIntensity,
-    // @ts-ignore
-    backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
-    // @ts-ignore
-    environmentIntensity: target.environmentIntensity,
-    // @ts-ignore
-    environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
-  };
-  if (background !== "only") target.environment = texture;
-  if (background) target.background = texture;
-  applyProps$1(target, sceneProps);
-  return () => {
-    if (background !== "only") target.environment = oldenv;
-    if (background) target.background = oldbg;
-    applyProps$1(target, oldSceneProps);
-  };
+const frustumMatrix = new Matrix4();
+function updateFrustum(camera, frustum) {
+  const target = frustum ?? new Frustum();
+  frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+  target.setFromProjectionMatrix(frustumMatrix);
+  return target;
 }
-function EnvironmentMap({ scene, background = false, map, ...config }) {
-  const defaultScene = useThree$1((state) => state.scene);
-  React.useLayoutEffect(() => {
-    if (map) return setEnvProps(background, scene, defaultScene, map, config);
-  });
-  return null;
+
+const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
+function findInitialRoot(instance) {
+  let root = instance.root;
+  while (root.getState().previousRoot) root = root.getState().previousRoot;
+  return root;
 }
-function EnvironmentCube({
-  background = false,
-  scene,
-  blur,
-  backgroundBlurriness,
-  backgroundIntensity,
-  backgroundRotation,
-  environmentIntensity,
-  environmentRotation,
-  ...rest
-}) {
-  const texture = useEnvironment(rest);
-  const defaultScene = useThree$1((state) => state.scene);
-  React.useLayoutEffect(() => {
-    return setEnvProps(background, scene, defaultScene, texture, {
-      backgroundBlurriness: blur ?? backgroundBlurriness,
-      backgroundIntensity,
-      backgroundRotation,
-      environmentIntensity,
-      environmentRotation
+function getRootState(obj) {
+  let state = obj.__r3f?.root.getState();
+  if (!state) {
+    obj.traverseAncestors((ancestor) => {
+      const parentState = ancestor.__r3f?.root.getState();
+      if (parentState) {
+        state = parentState;
+        return false;
+      }
     });
-  });
-  React.useEffect(() => {
-    return () => {
-      texture.dispose();
-    };
-  }, [texture]);
-  return null;
+  }
+  return state;
 }
-function EnvironmentPortal({
-  children,
-  near = 0.1,
-  far = 1e3,
-  resolution = 256,
-  frames = 1,
-  map,
-  background = false,
-  blur,
-  backgroundBlurriness,
-  backgroundIntensity,
-  backgroundRotation,
-  environmentIntensity,
-  environmentRotation,
-  scene,
-  files,
-  path,
-  preset = void 0,
-  extensions
-}) {
-  const gl = useThree$1((state) => state.gl);
-  const defaultScene = useThree$1((state) => state.scene);
-  const camera = React.useRef(null);
-  const [virtualScene] = React.useState(() => new Scene());
-  const fbo = React.useMemo(() => {
-    const fbo2 = new WebGLCubeRenderTarget(resolution);
-    fbo2.texture.type = HalfFloatType;
-    return fbo2;
-  }, [resolution]);
-  React.useEffect(() => {
-    return () => {
-      fbo.dispose();
-    };
-  }, [fbo]);
-  React.useLayoutEffect(() => {
-    if (frames === 1) {
-      const autoClear = gl.autoClear;
-      gl.autoClear = true;
-      camera.current.update(gl, virtualScene);
-      gl.autoClear = autoClear;
-    }
-    return setEnvProps(background, scene, defaultScene, fbo.texture, {
-      backgroundBlurriness: blur ?? backgroundBlurriness,
-      backgroundIntensity,
-      backgroundRotation,
-      environmentIntensity,
-      environmentRotation
+function buildGraph(object) {
+  const data = { nodes: {}, materials: {}, meshes: {} };
+  if (object) {
+    object.traverse((obj) => {
+      if (obj.name) data.nodes[obj.name] = obj;
+      if (obj.material) {
+        const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
+        const nameAlreadyUsed = data.materials[material.name];
+        let materialName = material.name;
+        if (nameAlreadyUsed) {
+          materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
+          material.userData.materialCacheName = materialName;
+        }
+        data.materials[materialName] = material;
+      }
+      if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
     });
-  }, [
-    children,
-    virtualScene,
-    fbo.texture,
-    scene,
-    defaultScene,
-    background,
-    frames,
-    gl,
-    blur,
-    backgroundBlurriness,
-    backgroundIntensity,
-    backgroundRotation,
-    environmentIntensity,
-    environmentRotation
-  ]);
-  let count = 1;
-  useFrame$1(() => {
-    if (frames === Infinity || count < frames) {
-      const autoClear = gl.autoClear;
-      gl.autoClear = true;
-      camera.current.update(gl, virtualScene);
-      gl.autoClear = autoClear;
-      count++;
-    }
-  });
-  return /* @__PURE__ */ jsx(Fragment, { children: createPortal$1(
-    /* @__PURE__ */ jsxs(Fragment, { children: [
-      children,
-      /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
-      files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
-    ] }),
-    virtualScene
-  ) });
-}
-function EnvironmentGround(props) {
-  const textureDefault = useEnvironment(props);
-  const texture = props.map || textureDefault;
-  React.useMemo(() => extend$1({ GroundProjectedEnvImpl: GroundedSkybox }), []);
-  React.useEffect(() => {
-    return () => {
-      textureDefault.dispose();
-    };
-  }, [textureDefault]);
-  const height = props.ground?.height ?? 15;
-  const radius = props.ground?.radius ?? 60;
-  const scale = props.ground?.scale ?? 1e3;
-  const args = React.useMemo(
-    () => [texture, height, radius],
-    [texture, height, radius]
-  );
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
-    /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
-  ] });
-}
-function EnvironmentColor({ color, scene }) {
-  const defaultScene = useThree$1((state) => state.scene);
-  React.useLayoutEffect(() => {
-    if (color === void 0) return;
-    const target = resolveScene(scene || defaultScene);
-    const oldBg = target.background;
-    target.background = new Color(color);
-    return () => {
-      target.background = oldBg;
-    };
-  });
-  return null;
-}
-function EnvironmentDualSource(props) {
-  const { backgroundFiles, ...envProps } = props;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
-    /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
-  ] });
+  }
+  return data;
 }
-function Environment(props) {
-  if (props.color && !props.files && !props.preset && !props.map) {
-    return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
+function dispose(obj) {
+  if (obj.type !== "Scene") obj.dispose?.();
+  for (const p in obj) {
+    const prop = obj[p];
+    if (prop?.type !== "Scene") prop?.dispose?.();
   }
-  if (props.backgroundFiles && props.backgroundFiles !== props.files) {
-    return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
+}
+function getInstanceProps(pendingProps) {
+  const props = {};
+  for (const key in pendingProps) {
+    if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
   }
-  return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
+  return props;
 }
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-const act = React["act"];
-const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React.useLayoutEffect : React.useEffect;
-function useMutableCallback(fn) {
-  const ref = React.useRef(fn);
-  useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
-  return ref;
+function prepare(target, root, type, props) {
+  const object = target;
+  let instance = object?.__r3f;
+  if (!instance) {
+    instance = {
+      root,
+      type,
+      parent: null,
+      children: [],
+      props: getInstanceProps(props),
+      object,
+      eventCount: 0,
+      handlers: {},
+      isHidden: false
+    };
+    if (object) object.__r3f = instance;
+  }
+  return instance;
 }
-function useBridge() {
-  const fiber = useFiber();
-  const ContextBridge = useContextBridge();
-  return React.useMemo(
-    () => ({ children }) => {
-      const strict = !!traverseFiber(fiber, true, (node) => node.type === React.StrictMode);
-      const Root = strict ? React.StrictMode : React.Fragment;
-      return /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(ContextBridge, { children }) });
-    },
-    [fiber, ContextBridge]
-  );
+function invalidateInstance(instance) {
+  if (!instance.parent) return;
+  instance.props.onUpdate?.(instance.object);
+  const state = instance.root?.getState?.();
+  if (state && state.internal.frames === 0) state.invalidate();
 }
-function Block({ set }) {
-  useIsomorphicLayoutEffect(() => {
-    set(new Promise(() => null));
-    return () => set(false);
-  }, [set]);
-  return null;
+
+const tempFrustum = new Frustum();
+let hasWarnedWebGL = false;
+let tslModule = null;
+async function loadTSL() {
+  if (tslModule) return tslModule;
+  try {
+    const tsl = await import('three/tsl');
+    tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
+    return tslModule;
+  } catch {
+    return null;
+  }
 }
-const ErrorBoundary = /* @__PURE__ */ (() => {
-  var _a;
-  return _a = class extends React.Component {
-    constructor() {
-      super(...arguments);
-      __publicField(this, "state", { error: false });
-    }
-    componentDidCatch(err) {
-      this.props.set(err);
-    }
-    render() {
-      return this.state.error ? null : this.props.children;
-    }
-  }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
-})();
-
-const is = {
-  obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function",
-  fun: (a) => typeof a === "function",
-  str: (a) => typeof a === "string",
-  num: (a) => typeof a === "number",
-  boo: (a) => typeof a === "boolean",
-  und: (a) => a === void 0,
-  nul: (a) => a === null,
-  arr: (a) => Array.isArray(a),
-  equ(a, b, { arrays = "shallow", objects = "reference", strict = true } = {}) {
-    if (typeof a !== typeof b || !!a !== !!b) return false;
-    if (is.str(a) || is.num(a) || is.boo(a)) return a === b;
-    const isObj = is.obj(a);
-    if (isObj && objects === "reference") return a === b;
-    const isArr = is.arr(a);
-    if (isArr && arrays === "reference") return a === b;
-    if ((isArr || isObj) && a === b) return true;
-    let i;
-    for (i in a) if (!(i in b)) return false;
-    if (isObj && arrays === "shallow" && objects === "shallow") {
-      for (i in strict ? b : a) if (!is.equ(a[i], b[i], { strict, objects: "reference" })) return false;
-    } else {
-      for (i in strict ? b : a) if (a[i] !== b[i]) return false;
-    }
-    if (is.und(i)) {
-      if (isArr && a.length === 0 && b.length === 0) return true;
-      if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true;
-      if (a !== b) return false;
-    }
-    return true;
-  }
-};
-const isOrthographicCamera = (def) => def && def.isOrthographicCamera;
-const isRef = (obj) => obj !== null && typeof obj === "object" && obj.hasOwnProperty("current");
-const isColorRepresentation = (value) => value != null && (typeof value === "string" || typeof value === "number" || value.isColor);
-const isObject3D = (object) => object?.isObject3D;
-const isTexture = (value) => !!value?.isTexture;
-const isVectorLike = (object) => object !== null && typeof object === "object" && "set" in object && typeof object.set === "function";
-const isCopyable = (object) => isVectorLike(object) && "copy" in object && typeof object.copy === "function";
-const hasConstructor = (object) => !!object?.constructor;
-
-function calculateDpr(dpr) {
-  const target = typeof window !== "undefined" ? window.devicePixelRatio ?? 2 : 1;
-  return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
-}
-function getUuidPrefix(uuid) {
-  return uuid.split("-")[0];
-}
-function updateCamera(camera, size) {
-  if (camera.manual) return;
-  if (isOrthographicCamera(camera)) {
-    camera.left = size.width / -2;
-    camera.right = size.width / 2;
-    camera.top = size.height / 2;
-    camera.bottom = size.height / -2;
-  } else {
-    camera.aspect = size.width / size.height;
-  }
-  camera.updateProjectionMatrix();
-}
-const frustumMatrix = new Matrix4();
-function updateFrustum(camera, frustum) {
-  const target = frustum ?? new Frustum();
-  frustumMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-  target.setFromProjectionMatrix(frustumMatrix);
-  return target;
-}
-
-const REACT_INTERNAL_PROPS = ["children", "key", "ref"];
-function findInitialRoot(instance) {
-  let root = instance.root;
-  while (root.getState().previousRoot) root = root.getState().previousRoot;
-  return root;
-}
-function getRootState(obj) {
-  let state = obj.__r3f?.root.getState();
-  if (!state) {
-    obj.traverseAncestors((ancestor) => {
-      const parentState = ancestor.__r3f?.root.getState();
-      if (parentState) {
-        state = parentState;
-        return false;
-      }
-    });
-  }
-  return state;
-}
-function buildGraph(object) {
-  const data = { nodes: {}, materials: {}, meshes: {} };
-  if (object) {
-    object.traverse((obj) => {
-      if (obj.name) data.nodes[obj.name] = obj;
-      if (obj.material) {
-        const material = Array.isArray(obj.material) ? obj.material[0] : obj.material;
-        const nameAlreadyUsed = data.materials[material.name];
-        let materialName = material.name;
-        if (nameAlreadyUsed) {
-          materialName = materialName + `-${getUuidPrefix(material.uuid)}`;
-          material.userData.materialCacheName = materialName;
-        }
-        data.materials[materialName] = material;
-      }
-      if (obj.isMesh && !data.meshes[obj.name]) data.meshes[obj.name] = obj;
-    });
-  }
-  return data;
-}
-function dispose(obj) {
-  if (obj.type !== "Scene") obj.dispose?.();
-  for (const p in obj) {
-    const prop = obj[p];
-    if (prop?.type !== "Scene") prop?.dispose?.();
-  }
-}
-function getInstanceProps(pendingProps) {
-  const props = {};
-  for (const key in pendingProps) {
-    if (!REACT_INTERNAL_PROPS.includes(key)) props[key] = pendingProps[key];
-  }
-  return props;
-}
-function prepare(target, root, type, props) {
-  const object = target;
-  let instance = object?.__r3f;
-  if (!instance) {
-    instance = {
-      root,
-      type,
-      parent: null,
-      children: [],
-      props: getInstanceProps(props),
-      object,
-      eventCount: 0,
-      handlers: {},
-      isHidden: false,
-      deferredRefs: []
-    };
-    if (object) object.__r3f = instance;
-  }
-  return instance;
-}
-function invalidateInstance(instance) {
-  if (!instance.parent) return;
-  instance.props.onUpdate?.(instance.object);
-  const state = instance.root?.getState?.();
-  if (state && state.internal.frames === 0) state.invalidate();
-}
-
-const tempFrustum = new Frustum();
-let hasWarnedWebGL = false;
-let tslModule = null;
-async function loadTSL() {
-  if (tslModule) return tslModule;
-  try {
-    const tsl = await import('three/tsl');
-    tslModule = { uniform: tsl.uniform, nodeObject: tsl.nodeObject };
-    return tslModule;
-  } catch {
-    return null;
-  }
-}
-function createOcclusionObserverNode(store, uniform) {
-  const node = new Node("float");
-  node.updateType = NodeUpdateType.OBJECT;
-  node.update = function(frame) {
-    const { internal } = store.getState();
-    const registry = internal.visibilityRegistry;
-    const cache = internal.occlusionCache;
-    for (const entry of registry.values()) {
-      const { object, handlers } = entry;
-      if (handlers.onOccluded || handlers.onVisible) {
-        const isOccluded = frame.renderer.isOccluded(object);
-        cache.set(object, isOccluded);
-      }
+function createOcclusionObserverNode(store, uniform) {
+  const node = new Node("float");
+  node.updateType = NodeUpdateType.OBJECT;
+  node.update = function(frame) {
+    const { internal } = store.getState();
+    const registry = internal.visibilityRegistry;
+    const cache = internal.occlusionCache;
+    for (const entry of registry.values()) {
+      const { object, handlers } = entry;
+      if (handlers.onOccluded || handlers.onVisible) {
+        const isOccluded = frame.renderer.isOccluded(object);
+        cache.set(object, isOccluded);
+      }
     }
   };
   node.setup = function() {
@@ -764,6 +439,17 @@ function unregisterVisibility(store, object) {
   internal.visibilityRegistry.delete(object.uuid);
   internal.occlusionCache.delete(object);
 }
+function updateVisibilityHandlers(store, object, handlers) {
+  const { internal } = store.getState();
+  const entry = internal.visibilityRegistry.get(object.uuid);
+  if (!entry) return false;
+  entry.handlers = handlers;
+  if ((handlers.onOccluded || handlers.onVisible) && !internal.occlusionEnabled) {
+    object.occlusionTest = true;
+    enableOcclusion(store);
+  }
+  return true;
+}
 function checkVisibility(state) {
   const { internal, camera } = state;
   const registry = internal.visibilityRegistry;
@@ -924,9 +610,9 @@ function diffProps(instance, newProps) {
     const { root, key } = resolve(instance.object, prop);
     if (root.constructor && root.constructor.length === 0) {
       const ctor = getMemoizedPrototype(root);
-      if (!is.und(ctor)) changedProps[key] = ctor[key];
+      if (!is.und(ctor)) changedProps[prop] = ctor[key];
     } else {
-      changedProps[key] = 0;
+      changedProps[prop] = 0;
     }
   }
   return changedProps;
@@ -951,10 +637,7 @@ function applyProps(object, props) {
       continue;
     }
     if (value === void 0) continue;
-    if (isFromRef(value)) {
-      instance?.deferredRefs?.push({ prop, ref: value[FROM_REF] });
-      continue;
-    }
+    if (isFromRef(value)) continue;
     if (isOnce(value)) {
       if (instance?.appliedOnce?.has(prop)) continue;
       if (instance) {
@@ -990,6 +673,19 @@ function applyProps(object, props) {
     } else if (isVectorLike(target) && is.num(value)) {
       if ("setScalar" in target && typeof target.setScalar === "function") target.setScalar(value);
       else target.set(value);
+    } else if (root instanceof ShaderMaterial && key === "uniforms" && is.obj(value)) {
+      if (!is.obj(root.uniforms)) root.uniforms = {};
+      const uniforms = root.uniforms;
+      const nextUniforms = value;
+      for (const name in nextUniforms) {
+        const uniform = nextUniforms[name];
+        const targetUniform = uniforms[name];
+        if (targetUniform) Object.assign(targetUniform, uniform);
+        else {
+          const nextUniform = uniform instanceof Uniform ? uniform.clone() : new Uniform(uniform.value);
+          uniforms[name] = nextUniform;
+        }
+      }
     } else {
       root[key] = value;
       if (key.endsWith("Node") && root.isMaterial) {
@@ -1008,6 +704,9 @@ function applyProps(object, props) {
     if (instance.eventCount && object2.raycast !== null) {
       rootState.internal.interaction.push(object2);
     }
+  }
+  if (instance?.parent && rootState?.internal && instance.object?.isObject3D) {
+    const object2 = instance.object;
     const root = findInitialRoot(instance);
     const visibilityHandlers = {
       onFramed: instance.handlers.onFramed,
@@ -1015,7 +714,9 @@ function applyProps(object, props) {
       onVisible: instance.handlers.onVisible
     };
     if (hasVisibilityHandlers(visibilityHandlers)) {
-      registerVisibility(root, object2, visibilityHandlers);
+      if (!updateVisibilityHandlers(root, object2, visibilityHandlers)) {
+        registerVisibility(root, object2, visibilityHandlers);
+      }
     } else {
       unregisterVisibility(root, object2);
     }
@@ -1028,1320 +729,911 @@ function applyProps(object, props) {
   return object;
 }
 
-const DEFAULT_POINTER_ID = 0;
-const XR_POINTER_ID_START = 1e3;
-function getPointerState(internal, pointerId) {
-  let state = internal.pointerMap.get(pointerId);
-  if (!state) {
-    state = {
-      hovered: /* @__PURE__ */ new Map(),
-      captured: /* @__PURE__ */ new Map(),
-      initialClick: [0, 0],
-      initialHits: []
-    };
-    internal.pointerMap.set(pointerId, state);
+const shownNotices = /* @__PURE__ */ new Set();
+function notifyDepreciated({ heading, body, link }) {
+  if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
+    return;
+  }
+  if (shownNotices.has(heading)) return;
+  shownNotices.add(heading);
+  const caller = getCallerFrame();
+  if (caller) {
+    console.log();
+  }
+  const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
+  if (caller) {
+    console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
+  }
+  if (body || link) {
+    let message = "";
+    if (body) message += body;
+    if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
+    console.warn(`%c${message}`, "font-weight: bold;");
   }
-  return state;
 }
-function getPointerId(event) {
-  return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
+function getCallerFrame(depth = 3) {
+  const stack = new Error().stack;
+  if (!stack) return null;
+  const lines = stack.split("\n");
+  const frame = lines[depth];
+  if (!frame) return null;
+  let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
+  if (!match) {
+    match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
+  }
+  if (!match) return null;
+  const [, fn, url, line] = match;
+  return {
+    functionName: fn ?? "<anonymous>",
+    location: formatLocation(url, Number(line))
+  };
 }
-function makeId(event) {
-  return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
+function formatLocation(url, line) {
+  const clean = url.split("?")[0];
+  const file = clean.split("/").pop() ?? clean;
+  return `${file}:${line}`;
 }
-function releaseInternalPointerCapture(internal, obj, pointerId) {
-  const pointerState = internal.pointerMap.get(pointerId);
-  if (!pointerState) return;
-  const captureData = pointerState.captured.get(obj);
-  if (captureData) {
-    pointerState.captured.delete(obj);
-    captureData.target.releasePointerCapture(pointerId);
+function notifyAlpha({ message, link }) {
+  if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
+    return;
   }
-}
-function removeInteractivity(store, object) {
-  const { internal } = store.getState();
-  internal.interaction = internal.interaction.filter((o) => o !== object);
-  for (const [pointerId, pointerState] of internal.pointerMap) {
-    pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
-    pointerState.hovered.forEach((value, key) => {
-      if (value.eventObject === object || value.object === object) {
-        pointerState.hovered.delete(key);
-      }
-    });
-    if (pointerState.captured.has(object)) {
-      releaseInternalPointerCapture(internal, object, pointerId);
-    }
+  if (shownNotices.has(message)) return;
+  shownNotices.add(message);
+  const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
+  console.log(`%c\u{1F52C} ${message}`, boxStyle);
+  {
+    console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
   }
-  unregisterVisibility(store, object);
 }
-function createEvents(store) {
-  function calculateDistance(event, pointerId) {
-    const { internal } = store.getState();
-    const pointerState = internal.pointerMap.get(pointerId);
-    if (!pointerState) return 0;
-    const [initialX, initialY] = pointerState.initialClick;
-    const dx = event.offsetX - initialX;
-    const dy = event.offsetY - initialY;
-    return Math.round(Math.sqrt(dx * dx + dy * dy));
-  }
-  function filterPointerEvents(objects) {
-    return objects.filter(
-      (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
-        (name) => obj.__r3f?.handlers["onPointer" + name]
-      ) || ["OverEnter", "OverLeave", "Over"].some(
-        (name) => obj.__r3f?.handlers["onDrag" + name]
-      ) || obj.__r3f?.handlers.onDrop
-    );
-  }
-  function intersect(event, filter) {
-    const state = store.getState();
-    const duplicates = /* @__PURE__ */ new Set();
-    const intersections = [];
-    const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
-    for (let i = 0; i < eventsObjects.length; i++) {
-      const state2 = getRootState(eventsObjects[i]);
-      if (state2) {
-        state2.raycaster.camera = void 0;
-      }
-    }
-    if (!state.previousRoot) {
-      state.events.compute?.(event, state);
-    }
-    function handleRaycast(obj) {
-      const state2 = getRootState(obj);
-      if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
-      if (state2.raycaster.camera === void 0) {
-        state2.events.compute?.(event, state2, state2.previousRoot?.getState());
-        if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
-      }
-      return state2.raycaster.camera ? state2.raycaster.intersectObject(obj, true) : [];
-    }
-    let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
-      const aInteractivePriority = a.object.userData?.interactivePriority;
-      const bInteractivePriority = b.object.userData?.interactivePriority;
-      if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
-        if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
-        if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
-        if (aInteractivePriority !== bInteractivePriority) {
-          return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
-        }
-      }
-      const aState = getRootState(a.object);
-      const bState = getRootState(b.object);
-      const aPriority = aState?.events?.priority ?? 1;
-      const bPriority = bState?.events?.priority ?? 1;
-      return bPriority - aPriority || a.distance - b.distance;
-    }).filter((item) => {
-      const id = makeId(item);
-      if (duplicates.has(id)) return false;
-      duplicates.add(id);
-      return true;
-    });
-    if (state.events.filter) hits = state.events.filter(hits, state);
-    for (const hit of hits) {
-      let eventObject = hit.object;
-      while (eventObject) {
-        if (eventObject.__r3f?.eventCount) {
-          intersections.push({ ...hit, eventObject });
-        }
-        eventObject = eventObject.parent;
+
+const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
+function isInternalRendererAccess(stack, callerDepth = 2) {
+  if (!stack) return false;
+  const caller = stack.split("\n")[callerDepth] ?? "";
+  return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
+}
+
+const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
+const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React.createContext(null));
+const createStore = (invalidate, advance) => {
+  const rootStore = createWithEqualityFn((set, get) => {
+    const position = new Vector3();
+    const defaultTarget = new Vector3();
+    const tempTarget = new Vector3();
+    function getCurrentViewport(camera = get().camera, target = defaultTarget, size = get().size) {
+      const { width, height, top, left } = size;
+      const aspect = width / height;
+      if (target.isVector3) tempTarget.copy(target);
+      else tempTarget.set(...target);
+      const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
+      if (isOrthographicCamera(camera)) {
+        return { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };
+      } else {
+        const fov = camera.fov * Math.PI / 180;
+        const h = 2 * Math.tan(fov / 2) * distance;
+        const w = h * (width / height);
+        return { width: w, height: h, top, left, factor: width / w, distance, aspect };
       }
     }
-    if ("pointerId" in event) {
-      const pointerId = event.pointerId;
-      const pointerState = state.internal.pointerMap.get(pointerId);
-      if (pointerState?.captured.size) {
-        for (const captureData of pointerState.captured.values()) {
-          if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
+    let performanceTimeout = void 0;
+    const setPerformanceCurrent = (current) => set((state2) => ({ performance: { ...state2.performance, current } }));
+    const pointer = new Vector2();
+    const rootState = {
+      set,
+      get,
+      // Mock objects that have to be configured
+      // primaryStore is set after store creation (self-reference for primary, primary's store for secondary)
+      primaryStore: null,
+      gl: null,
+      renderer: null,
+      camera: null,
+      frustum: new Frustum(),
+      autoUpdateFrustum: true,
+      raycaster: null,
+      events: {
+        priority: 1,
+        enabled: true,
+        connected: false,
+        frameTimedRaycasts: true,
+        alwaysFireOnScroll: true,
+        updateOnFrame: false
+      },
+      scene: null,
+      rootScene: null,
+      xr: null,
+      inspector: null,
+      invalidate: (frames = 1, stackFrames = false) => invalidate(get(), frames, stackFrames),
+      advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, get()),
+      textureColorSpace: SRGBColorSpace,
+      isLegacy: false,
+      webGPUSupported: false,
+      isNative: false,
+      controls: null,
+      pointer,
+      mouse: pointer,
+      frameloop: "always",
+      onPointerMissed: void 0,
+      onDragOverMissed: void 0,
+      onDropMissed: void 0,
+      performance: {
+        current: 1,
+        min: 0.5,
+        max: 1,
+        debounce: 200,
+        regress: () => {
+          const state2 = get();
+          if (performanceTimeout) clearTimeout(performanceTimeout);
+          if (state2.performance.current !== state2.performance.min) setPerformanceCurrent(state2.performance.min);
+          performanceTimeout = setTimeout(
+            () => setPerformanceCurrent(get().performance.max),
+            state2.performance.debounce
+          );
         }
-      }
-    }
-    return intersections;
-  }
-  function handleIntersects(intersections, event, delta, callback) {
-    if (intersections.length) {
-      const localState = { stopped: false };
-      for (const hit of intersections) {
-        const state = getRootState(hit.object);
-        if (state) {
-          const { raycaster, pointer, camera, internal } = state;
-          const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
-          const hasPointerCapture = (id) => {
-            const pointerState = internal.pointerMap.get(id);
-            return pointerState?.captured.has(hit.eventObject) ?? false;
-          };
-          const setPointerCapture = (id) => {
-            const captureData = { intersection: hit, target: event.target };
-            const pointerState = getPointerState(internal, id);
-            pointerState.captured.set(hit.eventObject, captureData);
-            event.target.setPointerCapture(id);
-          };
-          const releasePointerCapture = (id) => {
-            releaseInternalPointerCapture(internal, hit.eventObject, id);
-          };
-          const extractEventProps = {};
-          for (const prop in event) {
-            const property = event[prop];
-            if (typeof property !== "function") extractEventProps[prop] = property;
+      },
+      size: { width: 0, height: 0, top: 0, left: 0 },
+      viewport: {
+        initialDpr: 0,
+        dpr: 0,
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        aspect: 0,
+        distance: 0,
+        factor: 0,
+        getCurrentViewport
+      },
+      setEvents: (events) => set((state2) => ({ ...state2, events: { ...state2.events, ...events } })),
+      setSize: (width, height, top, left) => {
+        const state2 = get();
+        if (width === void 0) {
+          set({ _sizeImperative: false });
+          if (state2._sizeProps) {
+            const { width: propW, height: propH } = state2._sizeProps;
+            if (propW !== void 0 || propH !== void 0) {
+              const currentSize = state2.size;
+              const newSize = {
+                width: propW ?? currentSize.width,
+                height: propH ?? currentSize.height,
+                top: currentSize.top,
+                left: currentSize.left
+              };
+              set((s) => ({
+                size: newSize,
+                viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, newSize) }
+              }));
+              getScheduler().invalidate();
+            }
           }
-          const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
-          const raycastEvent = {
-            ...hit,
-            ...extractEventProps,
-            pointer,
-            intersections,
-            stopped: localState.stopped,
-            delta,
-            unprojectedPoint,
-            ray: raycaster.ray,
-            camera,
-            pointerId: eventPointerId,
-            // Hijack stopPropagation, which just sets a flag
-            stopPropagation() {
-              const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
-              if (
-                // ...if this pointer hasn't been captured
-                !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
-                pointerState.captured.has(hit.eventObject)
-              ) {
-                raycastEvent.stopped = localState.stopped = true;
-                if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
-                  const higher = intersections.slice(0, intersections.indexOf(hit));
-                  cancelPointer([...higher, hit], eventPointerId);
-                }
-              }
-            },
-            // there should be a distinction between target and currentTarget
-            target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
-            currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
-            nativeEvent: event
-          };
-          callback(raycastEvent);
-          if (localState.stopped === true) break;
+          return;
         }
+        const w = width;
+        const h = height ?? width;
+        const t = top ?? state2.size.top;
+        const l = left ?? state2.size.left;
+        const size = { width: w, height: h, top: t, left: l };
+        set((s) => ({
+          size,
+          viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, size) },
+          _sizeImperative: true
+        }));
+        getScheduler().invalidate();
+      },
+      setDpr: (dpr) => set((state2) => {
+        const resolved = calculateDpr(dpr);
+        return { viewport: { ...state2.viewport, dpr: resolved, initialDpr: state2.viewport.initialDpr || resolved } };
+      }),
+      setFrameloop: (frameloop = "always") => {
+        set(() => ({ frameloop }));
+        getScheduler().frameloop = frameloop;
+      },
+      setError: (error) => set(() => ({ error })),
+      error: null,
+      //* TSL State (managed via hooks: useUniforms, useNodes, useBuffers, useGPUStorage, useTextures, useRenderPipeline) ==============================
+      uniforms: {},
+      nodes: {},
+      buffers: {},
+      gpuStorage: {},
+      textures: /* @__PURE__ */ new Map(),
+      _textureRefs: /* @__PURE__ */ new Map(),
+      renderPipeline: null,
+      passes: {},
+      _hmrVersion: 0,
+      _sizeImperative: false,
+      _sizeProps: null,
+      previousRoot: void 0,
+      internal: {
+        // Events
+        interaction: [],
+        subscribers: [],
+        // Per-pointer state (new unified structure)
+        pointerMap: /* @__PURE__ */ new Map(),
+        pointerDirty: /* @__PURE__ */ new Map(),
+        lastEvent: React.createRef(),
+        // Deprecated but kept for backwards compatibility
+        hovered: /* @__PURE__ */ new Map(),
+        initialClick: [0, 0],
+        initialHits: [],
+        capturedMap: /* @__PURE__ */ new Map(),
+        // Visibility tracking (onFramed, onOccluded, onVisible)
+        visibilityRegistry: /* @__PURE__ */ new Map(),
+        // Occlusion system (WebGPU only)
+        occlusionEnabled: false,
+        occlusionObserver: null,
+        occlusionCache: /* @__PURE__ */ new Map(),
+        helperGroup: null,
+        // Updates
+        active: false,
+        frames: 0,
+        priority: 0,
+        subscribe: (ref, priority, store) => {
+          const internal = get().internal;
+          internal.priority = internal.priority + (priority > 0 ? 1 : 0);
+          internal.subscribers.push({ ref, priority, store });
+          internal.subscribers = internal.subscribers.sort((a, b) => a.priority - b.priority);
+          return () => {
+            const internal2 = get().internal;
+            if (internal2?.subscribers) {
+              internal2.priority = internal2.priority - (priority > 0 ? 1 : 0);
+              internal2.subscribers = internal2.subscribers.filter((s) => s.ref !== ref);
+            }
+          };
+        },
+        // Renderer Storage (single source of truth)
+        actualRenderer: null,
+        // Scheduler for useFrameNext (initialized in renderer.tsx)
+        scheduler: null
       }
-    }
-    return intersections;
-  }
-  function cancelPointer(intersections, pointerId) {
-    const { internal } = store.getState();
-    const pid = pointerId ?? DEFAULT_POINTER_ID;
-    const pointerState = internal.pointerMap.get(pid);
-    if (!pointerState) return;
-    for (const [hoveredId, hoveredObj] of pointerState.hovered) {
-      if (!intersections.length || !intersections.find(
-        (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
-      )) {
-        const eventObject = hoveredObj.eventObject;
-        const instance = eventObject.__r3f;
-        pointerState.hovered.delete(hoveredId);
-        if (instance?.eventCount) {
-          const handlers = instance.handlers;
-          const data = { ...hoveredObj, intersections };
-          handlers.onPointerOut?.(data);
-          handlers.onPointerLeave?.(data);
-          handlers.onDragOverLeave?.(data);
+    };
+    return rootState;
+  });
+  const state = rootStore.getState();
+  Object.defineProperty(state, "gl", {
+    get() {
+      const currentState = rootStore.getState();
+      if (!currentState.isLegacy && currentState.internal.actualRenderer) {
+        const stack = new Error().stack || "";
+        if (!isInternalRendererAccess(stack)) {
+          const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
+          notifyDepreciated({
+            heading: "Accessing state.gl in WebGPU mode",
+            body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
+          });
         }
       }
+      return currentState.internal.actualRenderer;
+    },
+    set(value) {
+      rootStore.getState().internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(state, "renderer", {
+    get() {
+      return rootStore.getState().internal.actualRenderer;
+    },
+    set(value) {
+      rootStore.getState().internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  let oldScene = state.scene;
+  rootStore.subscribe(() => {
+    const currentState = rootStore.getState();
+    const { scene, rootScene, set } = currentState;
+    if (scene !== oldScene) {
+      oldScene = scene;
+      if (scene?.isScene && scene !== rootScene) {
+        set({ rootScene: scene });
+      }
     }
-  }
-  function pointerMissed(event, objects) {
-    for (let i = 0; i < objects.length; i++) {
-      const instance = objects[i].__r3f;
-      instance?.handlers.onPointerMissed?.(event);
-    }
-  }
-  function dragOverMissed(event, objects) {
-    for (let i = 0; i < objects.length; i++) {
-      const instance = objects[i].__r3f;
-      instance?.handlers.onDragOverMissed?.(event);
-    }
-  }
-  function dropMissed(event, objects) {
-    for (let i = 0; i < objects.length; i++) {
-      const instance = objects[i].__r3f;
-      instance?.handlers.onDropMissed?.(event);
-    }
-  }
-  function cleanupPointer(pointerId) {
-    const { internal } = store.getState();
-    const pointerState = internal.pointerMap.get(pointerId);
-    if (pointerState) {
-      for (const [, hoveredObj] of pointerState.hovered) {
-        const eventObject = hoveredObj.eventObject;
-        const instance = eventObject.__r3f;
-        if (instance?.eventCount) {
-          const handlers = instance.handlers;
-          const data = { ...hoveredObj, intersections: [] };
-          handlers.onPointerOut?.(data);
-          handlers.onPointerLeave?.(data);
+  });
+  let oldSize = state.size;
+  let oldDpr = state.viewport.dpr;
+  let oldCamera = state.camera;
+  rootStore.subscribe(() => {
+    const { camera, size, viewport, set, internal } = rootStore.getState();
+    const actualRenderer = internal.actualRenderer;
+    const canvasTarget = internal.canvasTarget;
+    if (size.width !== oldSize.width || size.height !== oldSize.height || viewport.dpr !== oldDpr) {
+      oldSize = size;
+      oldDpr = viewport.dpr;
+      updateCamera(camera, size);
+      if (internal.isSecondary && canvasTarget) {
+        if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
+        canvasTarget.setSize(size.width, size.height, false);
+      } else {
+        if (viewport.dpr > 0) actualRenderer.setPixelRatio(viewport.dpr);
+        actualRenderer.setSize(size.width, size.height, false);
+        if (canvasTarget) {
+          if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
+          canvasTarget.setSize(size.width, size.height, false);
         }
       }
-      internal.pointerMap.delete(pointerId);
     }
-    internal.pointerDirty.delete(pointerId);
-  }
-  function processDeferredPointer(event, pointerId) {
-    const state = store.getState();
-    const { internal } = state;
-    if (!state.events.enabled) return;
-    const filter = filterPointerEvents;
-    const hits = intersect(event, filter);
-    cancelPointer(hits, pointerId);
-    function onIntersect(data) {
-      const eventObject = data.eventObject;
-      const instance = eventObject.__r3f;
-      if (!instance?.eventCount) return;
-      const handlers = instance.handlers;
-      if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
-        const id = makeId(data);
-        const pointerState = getPointerState(internal, pointerId);
-        const hoveredItem = pointerState.hovered.get(id);
-        if (!hoveredItem) {
-          pointerState.hovered.set(id, data);
-          handlers.onPointerOver?.(data);
-          handlers.onPointerEnter?.(data);
-        } else if (hoveredItem.stopped) {
-          data.stopPropagation();
-        }
+    if (camera !== oldCamera) {
+      oldCamera = camera;
+      const { rootScene } = rootStore.getState();
+      if (camera && rootScene && !camera.parent) {
+        rootScene.add(camera);
+      }
+      set((state2) => ({ viewport: { ...state2.viewport, ...state2.viewport.getCurrentViewport(camera) } }));
+      const currentState = rootStore.getState();
+      if (currentState.autoUpdateFrustum && camera) {
+        updateFrustum(camera, currentState.frustum);
       }
-      handlers.onPointerMove?.(data);
     }
-    handleIntersects(hits, event, 0, onIntersect);
+  });
+  rootStore.subscribe((state2) => invalidate(state2));
+  return rootStore;
+};
+
+const memoizedLoaders = /* @__PURE__ */ new WeakMap();
+const isConstructor$1 = (value) => typeof value === "function" && value?.prototype?.constructor === value;
+function getLoader$1(Proto) {
+  if (isConstructor$1(Proto)) {
+    let loader = memoizedLoaders.get(Proto);
+    if (!loader) {
+      loader = new Proto();
+      memoizedLoaders.set(Proto, loader);
+    }
+    return loader;
   }
-  function handlePointer(name) {
-    switch (name) {
-      case "onPointerLeave":
-      case "onDragLeave":
-        return () => cancelPointer([]);
-      // Global cancel of these events
-      case "onPointerCancel":
-        return (event) => {
-          const pointerId = getPointerId(event);
-          cleanupPointer(pointerId);
-        };
-      case "onLostPointerCapture":
-        return (event) => {
-          const { internal } = store.getState();
-          const pointerId = getPointerId(event);
-          const pointerState = internal.pointerMap.get(pointerId);
-          if (pointerState?.captured.size) {
-            requestAnimationFrame(() => {
-              const pointerState2 = internal.pointerMap.get(pointerId);
-              if (pointerState2?.captured.size) {
-                pointerState2.captured.clear();
-              }
-              cancelPointer([], pointerId);
-            });
-          }
-        };
+  return Proto;
+}
+function loadingFn(extensions, onProgress) {
+  return function(Proto, input) {
+    const loader = getLoader$1(Proto);
+    if (extensions) extensions(loader);
+    if ("loadAsync" in loader && typeof loader.loadAsync === "function") {
+      return loader.loadAsync(input, onProgress).then((data) => {
+        if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
+        return data;
+      });
     }
-    return function handleEvent(event) {
+    return new Promise(
+      (res, reject) => loader.load(
+        input,
+        (data) => {
+          if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
+          res(data);
+        },
+        onProgress,
+        (error) => reject(new Error(`Could not load ${input}: ${error?.message}`))
+      )
+    );
+  };
+}
+function useLoader(loader, input, extensions, onProgress, cacheKey) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
+  const fn = loadingFn(extensions, onProgress);
+  const results = cacheKeys.map(
+    (key, index) => suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
+  );
+  return Array.isArray(input) ? results : results[0];
+}
+useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
+  cacheKeys.forEach(
+    (key, index) => preload(() => loadingFn(extensions, onProgress)(loader, inputs[index]), [loader, key])
+  );
+};
+useLoader.clear = function(loader, input, cacheKey) {
+  const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
+  cacheKeys.forEach((key) => clear([loader, key]));
+};
+useLoader.loader = getLoader$1;
+
+function useFrame(callback, priorityOrOptions) {
+  const store = React.useContext(context);
+  const isInsideCanvas = store !== null;
+  const scheduler = getScheduler();
+  const optionsKey = typeof priorityOrOptions === "number" ? `p:${priorityOrOptions}` : priorityOrOptions ? JSON.stringify({
+    id: priorityOrOptions.id,
+    phase: priorityOrOptions.phase,
+    priority: priorityOrOptions.priority,
+    fps: priorityOrOptions.fps,
+    drop: priorityOrOptions.drop,
+    enabled: priorityOrOptions.enabled,
+    before: priorityOrOptions.before,
+    after: priorityOrOptions.after
+  }) : "";
+  const options = React.useMemo(() => {
+    return typeof priorityOrOptions === "number" ? { priority: priorityOrOptions } : priorityOrOptions ?? {};
+  }, [optionsKey]);
+  const reactId = React.useId();
+  const id = options.id ?? reactId;
+  const callbackRef = useMutableCallback(callback);
+  const isLegacyPriority = typeof priorityOrOptions === "number" && priorityOrOptions > 0;
+  useIsomorphicLayoutEffect(() => {
+    if (!callback) return;
+    if (isInsideCanvas) {
       const state = store.getState();
-      const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
-      const pointerId = getPointerId(event);
-      internal.lastEvent.current = event;
-      if (!events.enabled) return;
-      const isPointerMove = name === "onPointerMove";
-      const isDragOver = name === "onDragOver";
-      const isDrop = name === "onDrop";
-      const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
-      const isPointerDown = name === "onPointerDown";
-      const isPointerUp = name === "onPointerUp";
-      const isWheel = name === "onWheel";
-      const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
-      if (isPointerMove && canDeferRaycasts) {
-        events.compute?.(event, state);
-        internal.pointerDirty.set(pointerId, event);
-        return;
-      }
-      if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
-        events.compute?.(event, state);
-        internal.pointerDirty.set(pointerId, event);
-        return;
-      }
-      if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
-        const deferredEvent = internal.pointerDirty.get(pointerId);
-        internal.pointerDirty.delete(pointerId);
-        processDeferredPointer(deferredEvent, pointerId);
-      }
-      const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
-      const hits = intersect(event, filter);
-      const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
-      if (isPointerDown) {
-        const pointerState2 = getPointerState(internal, pointerId);
-        pointerState2.initialClick = [event.offsetX, event.offsetY];
-        pointerState2.initialHits = hits.map((hit) => hit.eventObject);
-      }
-      const pointerState = internal.pointerMap.get(pointerId);
-      const initialHits = pointerState?.initialHits ?? [];
-      if (isClickEvent && !hits.length) {
-        if (delta <= 2) {
-          pointerMissed(event, internal.interaction);
-          if (onPointerMissed) onPointerMissed(event);
+      const rootId = state.internal.rootId;
+      if (isLegacyPriority) {
+        state.internal.priority++;
+        let parentRoot = state.previousRoot;
+        while (parentRoot) {
+          const parentState = parentRoot.getState();
+          if (parentState?.internal) parentState.internal.priority++;
+          parentRoot = parentState?.previousRoot;
         }
+        notifyDepreciated({
+          heading: "useFrame with numeric priority is deprecated",
+          body: 'Using useFrame(callback, number) to control render order is deprecated.\n\nFor custom rendering, use: useFrame(callback, { phase: "render" })\nFor execution order within update phase, use: useFrame(callback, { priority: number })',
+          link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
+        });
       }
-      if (isDragOver && !hits.length) {
-        dragOverMissed(event, internal.interaction);
-        if (onDragOverMissed) onDragOverMissed(event);
-      }
-      if (isDrop && !hits.length) {
-        dropMissed(event, internal.interaction);
-        if (onDropMissed) onDropMissed(event);
-      }
-      if (isPointerMove || isDragOver) {
-        cancelPointer(hits, pointerId);
-      }
-      function onIntersect(data) {
-        const eventObject = data.eventObject;
-        const instance = eventObject.__r3f;
-        if (!instance?.eventCount) return;
-        const handlers = instance.handlers;
-        if (isPointerMove) {
-          if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
-            const id = makeId(data);
-            const pointerState2 = getPointerState(internal, pointerId);
-            const hoveredItem = pointerState2.hovered.get(id);
-            if (!hoveredItem) {
-              pointerState2.hovered.set(id, data);
-              handlers.onPointerOver?.(data);
-              handlers.onPointerEnter?.(data);
-            } else if (hoveredItem.stopped) {
-              data.stopPropagation();
-            }
-          }
-          handlers.onPointerMove?.(data);
-        } else if (isDragOver) {
-          const id = makeId(data);
-          const pointerState2 = getPointerState(internal, pointerId);
-          const hoveredItem = pointerState2.hovered.get(id);
-          if (!hoveredItem) {
-            pointerState2.hovered.set(id, data);
-            handlers.onDragOverEnter?.(data);
-          } else if (hoveredItem.stopped) {
-            data.stopPropagation();
-          }
-          handlers.onDragOver?.(data);
-        } else if (isDrop) {
-          handlers.onDrop?.(data);
-        } else {
-          const handler = handlers[name];
-          if (handler) {
-            if (!isClickEvent || initialHits.includes(eventObject)) {
-              pointerMissed(
-                event,
-                internal.interaction.filter((object) => !initialHits.includes(object))
-              );
-              handler(data);
-            }
-          } else {
-            if (isClickEvent && initialHits.includes(eventObject)) {
-              pointerMissed(
-                event,
-                internal.interaction.filter((object) => !initialHits.includes(object))
-              );
+      const wrappedCallback = (frameState, delta) => {
+        const localState = store.getState();
+        const mergedState = {
+          ...localState,
+          time: frameState.time,
+          delta: frameState.delta,
+          elapsed: frameState.elapsed,
+          frame: frameState.frame
+        };
+        callbackRef.current?.(mergedState, delta);
+      };
+      const unregister = scheduler.register(wrappedCallback, {
+        id,
+        rootId,
+        ...options
+      });
+      return () => {
+        unregister();
+        if (isLegacyPriority) {
+          const currentState = store.getState();
+          if (currentState.internal) {
+            currentState.internal.priority--;
+            let parentRoot = currentState.previousRoot;
+            while (parentRoot) {
+              const parentState = parentRoot.getState();
+              if (parentState?.internal) parentState.internal.priority--;
+              parentRoot = parentState?.previousRoot;
             }
           }
         }
-      }
-      handleIntersects(hits, event, delta, onIntersect);
-    };
-  }
-  function flushDeferredPointers() {
-    const { internal, events } = store.getState();
-    if (!events.frameTimedRaycasts) return;
-    for (const [pointerId, event] of internal.pointerDirty) {
-      processDeferredPointer(event, pointerId);
+      };
+    } else {
+      return scheduler.register(
+        (state, delta) => {
+          const frameState = state;
+          if (!frameState.renderer) return;
+          callbackRef.current?.(frameState, delta);
+        },
+        { id, ...options }
+      );
     }
-    internal.pointerDirty.clear();
-  }
-  return { handlePointer, flushDeferredPointers, processDeferredPointer };
-}
-const DOM_EVENTS = {
-  onClick: ["click", false],
-  onContextMenu: ["contextmenu", false],
-  onDoubleClick: ["dblclick", false],
-  onDragEnter: ["dragenter", false],
-  onDragLeave: ["dragleave", false],
-  onDragOver: ["dragover", false],
-  onDrop: ["drop", false],
-  onWheel: ["wheel", true],
-  onPointerDown: ["pointerdown", true],
-  onPointerUp: ["pointerup", true],
-  onPointerLeave: ["pointerleave", true],
-  onPointerMove: ["pointermove", true],
-  onPointerCancel: ["pointercancel", true],
-  onLostPointerCapture: ["lostpointercapture", true]
-};
-function createPointerEvents(store) {
-  const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
-  let nextXRPointerId = XR_POINTER_ID_START;
-  const xrPointers = /* @__PURE__ */ new Map();
-  return {
-    priority: 1,
-    enabled: true,
-    frameTimedRaycasts: true,
-    alwaysFireOnScroll: true,
-    updateOnFrame: false,
-    compute(event, state) {
-      state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
-      state.raycaster.setFromCamera(state.pointer, state.camera);
-    },
-    connected: void 0,
-    handlers: Object.keys(DOM_EVENTS).reduce(
-      (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
-      {}
+  }, [store, scheduler, id, optionsKey, isLegacyPriority, isInsideCanvas]);
+  const isPaused = React.useSyncExternalStore(
+    // Subscribe function
+    React.useCallback(
+      (onStoreChange) => {
+        return getScheduler().subscribeJobState(id, onStoreChange);
+      },
+      [id]
     ),
-    update: (pointerId) => {
-      const { events, internal } = store.getState();
-      if (!events.handlers) return;
-      if (pointerId !== void 0) {
-        const event = internal.pointerDirty.get(pointerId);
-        if (event) {
-          internal.pointerDirty.delete(pointerId);
-          processDeferredPointer(event, pointerId);
-        } else if (internal.lastEvent?.current) {
-          processDeferredPointer(internal.lastEvent.current, pointerId);
-        }
-      } else {
-        flushDeferredPointers();
-        if (internal.lastEvent?.current) {
-          events.handlers.onPointerMove(internal.lastEvent.current);
-        }
-      }
-    },
-    flush: () => {
-      const { events, internal } = store.getState();
-      flushDeferredPointers();
-      if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
-        events.handlers.onPointerMove(internal.lastEvent.current);
-      }
-    },
-    connect: (target) => {
-      if (!target) return;
-      const { set, events } = store.getState();
-      events.disconnect?.();
-      set((state) => ({ events: { ...state.events, connected: target } }));
-      if (events.handlers) {
-        for (const name in events.handlers) {
-          const event = events.handlers[name];
-          const [eventName, passive] = DOM_EVENTS[name];
-          target.addEventListener(eventName, event, { passive });
-        }
-      }
-    },
-    disconnect: () => {
-      const { set, events } = store.getState();
-      if (events.connected) {
-        if (events.handlers) {
-          for (const name in events.handlers) {
-            const event = events.handlers[name];
-            const [eventName] = DOM_EVENTS[name];
-            events.connected.removeEventListener(eventName, event);
-          }
-        }
-        set((state) => ({ events: { ...state.events, connected: void 0 } }));
-      }
-    },
-    registerPointer: (config) => {
-      const pointerId = nextXRPointerId++;
-      xrPointers.set(pointerId, config);
-      const { internal } = store.getState();
-      getPointerState(internal, pointerId);
-      return pointerId;
-    },
-    unregisterPointer: (pointerId) => {
-      xrPointers.delete(pointerId);
-      const { internal } = store.getState();
-      const pointerState = internal.pointerMap.get(pointerId);
-      if (pointerState) {
-        for (const [, hoveredObj] of pointerState.hovered) {
-          const eventObject = hoveredObj.eventObject;
-          const instance = eventObject.__r3f;
-          if (instance?.eventCount) {
-            const handlers = instance.handlers;
-            const data = { ...hoveredObj, intersections: [] };
-            handlers.onPointerOut?.(data);
-            handlers.onPointerLeave?.(data);
-          }
-        }
-        internal.pointerMap.delete(pointerId);
-      }
-      internal.pointerDirty.delete(pointerId);
-    }
-  };
+    // getSnapshot function
+    React.useCallback(() => getScheduler().isJobPaused(id), [id]),
+    // getServerSnapshot function (SSR)
+    React.useCallback(() => false, [])
+  );
+  const controls = React.useMemo(() => {
+    const scheduler2 = getScheduler();
+    return {
+      /** The job's unique ID */
+      id,
+      /**
+       * Access to the global scheduler for frame loop control.
+       * Use for controlling the entire frame loop, adding phases, etc.
+       */
+      scheduler: scheduler2,
+      /**
+       * Manually step this job only.
+       * Bypasses FPS limiting - always runs.
+       * @param timestamp Optional timestamp (defaults to performance.now())
+       */
+      step: (timestamp) => {
+        getScheduler().stepJob(id, timestamp);
+      },
+      /**
+       * Manually step ALL jobs in the scheduler.
+       * Useful for frameloop='never' mode.
+       * @param timestamp Optional timestamp (defaults to performance.now())
+       */
+      stepAll: (timestamp) => {
+        getScheduler().step(timestamp);
+      },
+      /**
+       * Pause this job (set enabled=false).
+       * Job remains registered but won't run.
+       */
+      pause: () => {
+        getScheduler().pauseJob(id);
+      },
+      /**
+       * Resume this job (set enabled=true).
+       */
+      resume: () => {
+        getScheduler().resumeJob(id);
+      },
+      /**
+       * Reactive paused state - automatically updates when pause/resume is called.
+       * No need for forceUpdate() in your components.
+       */
+      isPaused
+    };
+  }, [id, isPaused]);
+  return controls;
 }
 
-const shownNotices = /* @__PURE__ */ new Set();
-function notifyDepreciated({ heading, body, link }) {
-  if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_DEPRECATION_WARNINGS !== "true") {
-    return;
-  }
-  if (shownNotices.has(heading)) return;
-  shownNotices.add(heading);
-  const caller = getCallerFrame();
-  if (caller) {
-    console.log();
-  }
-  const boxStyle = "background: #ff9800; color: #1a1a1a; padding: 8px 12px; border-radius: 4px; font-weight: 500;";
-  if (caller) {
-    console.log(`%c\u26A0\uFE0F ${heading}`, boxStyle);
-  }
-  if (body || link) {
-    let message = "";
-    if (body) message += body;
-    if (link) message += (body ? "\n\n" : "") + `More info: ${link}`;
-    console.warn(`%c${message}`, "font-weight: bold;");
-  }
-}
-function getCallerFrame(depth = 3) {
-  const stack = new Error().stack;
-  if (!stack) return null;
-  const lines = stack.split("\n");
-  const frame = lines[depth];
-  if (!frame) return null;
-  let match = frame.match(/^\s*at (?:(.+?) )?\(?(.+?):(\d+):(\d+)\)?$/);
-  if (!match) {
-    match = frame.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
-  }
-  if (!match) return null;
-  const [, fn, url, line] = match;
-  return {
-    functionName: fn ?? "<anonymous>",
-    location: formatLocation(url, Number(line))
-  };
+const IsObject = (url) => url === Object(url) && !Array.isArray(url) && typeof url !== "function";
+function getUrls(input) {
+  if (typeof input === "string") return [input];
+  if (Array.isArray(input)) return input;
+  return Object.values(input);
 }
-function formatLocation(url, line) {
-  const clean = url.split("?")[0];
-  const file = clean.split("/").pop() ?? clean;
-  return `${file}:${line}`;
+function allUrlsCached(urls, textureCache) {
+  return urls.every((url) => textureCache.has(url));
 }
-function notifyAlpha({ message, link }) {
-  if (typeof process !== "undefined" && (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) && process.env.R3F_SHOW_ALPHA_WARNINGS !== "true") {
-    return;
-  }
-  if (shownNotices.has(message)) return;
-  shownNotices.add(message);
-  const boxStyle = "background: #6366f1; color: #ffffff; padding: 6px 10px; border-radius: 4px; font-weight: 500;";
-  console.log(`%c\u{1F52C} ${message}`, boxStyle);
-  {
-    console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
+function buildFromCache(input, textureCache) {
+  if (typeof input === "string") {
+    return textureCache.get(input);
+  } else if (Array.isArray(input)) {
+    return input.map((url) => textureCache.get(url));
+  } else {
+    const result = {};
+    const objInput = input;
+    for (const key in objInput) {
+      result[key] = textureCache.get(objInput[key]);
+    }
+    return result;
   }
 }
-
-const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
-const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React.createContext(null));
-const createStore = (invalidate, advance) => {
-  const rootStore = createWithEqualityFn((set, get) => {
-    const position = new Vector3();
-    const defaultTarget = new Vector3();
-    const tempTarget = new Vector3();
-    function getCurrentViewport(camera = get().camera, target = defaultTarget, size = get().size) {
-      const { width, height, top, left } = size;
-      const aspect = width / height;
-      if (target.isVector3) tempTarget.copy(target);
-      else tempTarget.set(...target);
-      const distance = camera.getWorldPosition(position).distanceTo(tempTarget);
-      if (isOrthographicCamera(camera)) {
-        return { width: width / camera.zoom, height: height / camera.zoom, top, left, factor: 1, distance, aspect };
-      } else {
-        const fov = camera.fov * Math.PI / 180;
-        const h = 2 * Math.tan(fov / 2) * distance;
-        const w = h * (width / height);
-        return { width: w, height: h, top, left, factor: width / w, distance, aspect };
-      }
-    }
-    let performanceTimeout = void 0;
-    const setPerformanceCurrent = (current) => set((state2) => ({ performance: { ...state2.performance, current } }));
-    const pointer = new Vector2();
-    const rootState = {
-      set,
-      get,
-      // Mock objects that have to be configured
-      // primaryStore is set after store creation (self-reference for primary, primary's store for secondary)
-      primaryStore: null,
-      gl: null,
-      renderer: null,
-      camera: null,
-      frustum: new Frustum(),
-      autoUpdateFrustum: true,
-      raycaster: null,
-      events: {
-        priority: 1,
-        enabled: true,
-        connected: false,
-        frameTimedRaycasts: true,
-        alwaysFireOnScroll: true,
-        updateOnFrame: false
-      },
-      scene: null,
-      rootScene: null,
-      xr: null,
-      inspector: null,
-      invalidate: (frames = 1, stackFrames = false) => invalidate(get(), frames, stackFrames),
-      advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, get()),
-      textureColorSpace: SRGBColorSpace,
-      isLegacy: false,
-      webGPUSupported: false,
-      isNative: false,
-      controls: null,
-      pointer,
-      mouse: pointer,
-      frameloop: "always",
-      onPointerMissed: void 0,
-      onDragOverMissed: void 0,
-      onDropMissed: void 0,
-      performance: {
-        current: 1,
-        min: 0.5,
-        max: 1,
-        debounce: 200,
-        regress: () => {
-          const state2 = get();
-          if (performanceTimeout) clearTimeout(performanceTimeout);
-          if (state2.performance.current !== state2.performance.min) setPerformanceCurrent(state2.performance.min);
-          performanceTimeout = setTimeout(
-            () => setPerformanceCurrent(get().performance.max),
-            state2.performance.debounce
-          );
+function useTexture(input, optionsOrOnLoad) {
+  const renderer = useThree((state) => state.internal.actualRenderer);
+  const store = useStore();
+  const options = typeof optionsOrOnLoad === "function" ? { onLoad: optionsOrOnLoad } : optionsOrOnLoad ?? {};
+  const { onLoad, cache = true } = options;
+  const onLoadRef = useRef(onLoad);
+  onLoadRef.current = onLoad;
+  const onLoadCalledForRef = useRef(null);
+  const urls = useMemo(() => getUrls(input), [input]);
+  const cachedResult = useMemo(() => {
+    if (!cache) return null;
+    const textures = store.getState().textures;
+    if (!allUrlsCached(urls, textures)) return null;
+    return buildFromCache(input, textures);
+  }, [cache, urls, input, store]);
+  const loadedTextures = useLoader(
+    TextureLoader,
+    IsObject(input) ? Object.values(input) : input
+  );
+  const inputKey = urls.join("\0");
+  useLayoutEffect(() => {
+    if (cachedResult) return;
+    if (onLoadCalledForRef.current === inputKey) return;
+    onLoadCalledForRef.current = inputKey;
+    onLoadRef.current?.(loadedTextures);
+  }, [cachedResult, loadedTextures, inputKey]);
+  useEffect(() => {
+    if (cachedResult) return;
+    if ("initTexture" in renderer) {
+      let textureArray = [];
+      if (Array.isArray(loadedTextures)) {
+        textureArray = loadedTextures;
+      } else if (loadedTextures instanceof Texture$1) {
+        textureArray = [loadedTextures];
+      } else if (IsObject(loadedTextures)) {
+        textureArray = Object.values(loadedTextures);
+      }
+      textureArray.forEach((texture) => {
+        if (texture instanceof Texture$1) {
+          renderer.initTexture(texture);
+        }
+      });
+    }
+  }, [renderer, loadedTextures, cachedResult]);
+  const mappedTextures = useMemo(() => {
+    if (cachedResult) return cachedResult;
+    if (IsObject(input)) {
+      const keyed = {};
+      const textureArray = loadedTextures;
+      let i = 0;
+      for (const key in input) keyed[key] = textureArray[i++];
+      return keyed;
+    } else {
+      return loadedTextures;
+    }
+  }, [input, loadedTextures, cachedResult]);
+  useEffect(() => {
+    if (!cache) return;
+    const urlTextureMap = [];
+    if (typeof input === "string") {
+      urlTextureMap.push([input, mappedTextures]);
+    } else if (Array.isArray(input)) {
+      const textureArray = mappedTextures;
+      input.forEach((url, i) => urlTextureMap.push([url, textureArray[i]]));
+    } else if (IsObject(input)) {
+      const textureRecord = mappedTextures;
+      for (const key in input) {
+        const url = input[key];
+        urlTextureMap.push([url, textureRecord[key]]);
+      }
+    }
+    store.setState((state) => {
+      const refs = new Map(state._textureRefs);
+      let textures = state.textures;
+      let added = false;
+      for (const [url, texture] of urlTextureMap) {
+        if (!textures.has(url)) {
+          if (!added) {
+            textures = new Map(textures);
+            added = true;
+          }
+          textures.set(url, texture);
         }
+        refs.set(url, (refs.get(url) ?? 0) + 1);
+      }
+      return added ? { textures, _textureRefs: refs } : { _textureRefs: refs };
+    });
+    return () => store.setState((state) => {
+      const refs = new Map(state._textureRefs);
+      for (const [url] of urlTextureMap) {
+        const next = (refs.get(url) ?? 0) - 1;
+        if (next <= 0) refs.delete(url);
+        else refs.set(url, next);
+      }
+      return { _textureRefs: refs };
+    });
+  }, [cache, input, mappedTextures, store]);
+  return mappedTextures;
+}
+useTexture.preload = (url) => useLoader.preload(TextureLoader, url);
+useTexture.clear = (input) => useLoader.clear(TextureLoader, input);
+const Texture = ({
+  children,
+  input,
+  onLoad,
+  cache
+}) => {
+  const options = typeof onLoad === "function" ? { onLoad, cache } : { ...onLoad, cache };
+  const ret = useTexture(input, options);
+  return /* @__PURE__ */ jsx(Fragment, { children: children?.(ret) });
+};
+
+function useTextures(selector) {
+  const store = useStore();
+  const registry = useMemo(() => {
+    const getState = store.getState;
+    const setState = store.setState;
+    const getOne = (key) => getState().textures.get(key);
+    return {
+      get all() {
+        return getState().textures;
       },
-      size: { width: 0, height: 0, top: 0, left: 0 },
-      viewport: {
-        initialDpr: 0,
-        dpr: 0,
-        width: 0,
-        height: 0,
-        top: 0,
-        left: 0,
-        aspect: 0,
-        distance: 0,
-        factor: 0,
-        getCurrentViewport
+      get(input) {
+        if (typeof input === "string") return getOne(input);
+        if (Array.isArray(input)) return input.map(getOne);
+        const out = {};
+        for (const name in input) out[name] = getOne(input[name]);
+        return out;
       },
-      setEvents: (events) => set((state2) => ({ ...state2, events: { ...state2.events, ...events } })),
-      setSize: (width, height, top, left) => {
-        const state2 = get();
-        if (width === void 0) {
-          set({ _sizeImperative: false });
-          if (state2._sizeProps) {
-            const { width: propW, height: propH } = state2._sizeProps;
-            if (propW !== void 0 || propH !== void 0) {
-              const currentSize = state2.size;
-              const newSize = {
-                width: propW ?? currentSize.width,
-                height: propH ?? currentSize.height,
-                top: currentSize.top,
-                left: currentSize.left
-              };
-              set((s) => ({
-                size: newSize,
-                viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, newSize) }
-              }));
-              getScheduler().invalidate();
-            }
+      has: (key) => getState().textures.has(key),
+      add(keyOrRecord, texture) {
+        setState((state) => {
+          const textures = new Map(state.textures);
+          if (typeof keyOrRecord === "string") {
+            textures.set(keyOrRecord, texture);
+          } else {
+            for (const key in keyOrRecord) textures.set(key, keyOrRecord[key]);
           }
-          return;
+          return { textures };
+        });
+      },
+      dispose(key, options) {
+        const state = getState();
+        const refs = state._textureRefs.get(key) ?? 0;
+        if (refs > 0 && !options?.force) {
+          console.warn(
+            `[useTextures] "${key}" still has ${refs} active reference(s); skipping dispose. Pass { force: true } to override.`
+          );
+          return false;
         }
-        const w = width;
-        const h = height ?? width;
-        const t = top ?? state2.size.top;
-        const l = left ?? state2.size.left;
-        const size = { width: w, height: h, top: t, left: l };
-        set((s) => ({
-          size,
-          viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, size) },
-          _sizeImperative: true
-        }));
-        getScheduler().invalidate();
+        state.textures.get(key)?.dispose();
+        setState((s) => {
+          const textures = new Map(s.textures);
+          textures.delete(key);
+          const nextRefs = new Map(s._textureRefs);
+          nextRefs.delete(key);
+          return { textures, _textureRefs: nextRefs };
+        });
+        return true;
       },
-      setDpr: (dpr) => set((state2) => {
-        const resolved = calculateDpr(dpr);
-        return { viewport: { ...state2.viewport, dpr: resolved, initialDpr: state2.viewport.initialDpr || resolved } };
-      }),
-      setFrameloop: (frameloop = "always") => {
-        set(() => ({ frameloop }));
-      },
-      setError: (error) => set(() => ({ error })),
-      error: null,
-      //* TSL State (managed via hooks: useUniforms, useNodes, useBuffers, useGPUStorage, useTextures, useRenderPipeline) ==============================
-      uniforms: {},
-      nodes: {},
-      buffers: {},
-      gpuStorage: {},
-      textures: /* @__PURE__ */ new Map(),
-      _textureRefs: /* @__PURE__ */ new Map(),
-      renderPipeline: null,
-      passes: {},
-      _hmrVersion: 0,
-      _sizeImperative: false,
-      _sizeProps: null,
-      previousRoot: void 0,
-      internal: {
-        // Events
-        interaction: [],
-        subscribers: [],
-        // Per-pointer state (new unified structure)
-        pointerMap: /* @__PURE__ */ new Map(),
-        pointerDirty: /* @__PURE__ */ new Map(),
-        lastEvent: React.createRef(),
-        // Deprecated but kept for backwards compatibility
-        hovered: /* @__PURE__ */ new Map(),
-        initialClick: [0, 0],
-        initialHits: [],
-        capturedMap: /* @__PURE__ */ new Map(),
-        // Visibility tracking (onFramed, onOccluded, onVisible)
-        visibilityRegistry: /* @__PURE__ */ new Map(),
-        // Occlusion system (WebGPU only)
-        occlusionEnabled: false,
-        occlusionObserver: null,
-        occlusionCache: /* @__PURE__ */ new Map(),
-        helperGroup: null,
-        // Updates
-        active: false,
-        frames: 0,
-        priority: 0,
-        subscribe: (ref, priority, store) => {
-          const internal = get().internal;
-          internal.priority = internal.priority + (priority > 0 ? 1 : 0);
-          internal.subscribers.push({ ref, priority, store });
-          internal.subscribers = internal.subscribers.sort((a, b) => a.priority - b.priority);
-          return () => {
-            const internal2 = get().internal;
-            if (internal2?.subscribers) {
-              internal2.priority = internal2.priority - (priority > 0 ? 1 : 0);
-              internal2.subscribers = internal2.subscribers.filter((s) => s.ref !== ref);
-            }
-          };
-        },
-        // Renderer Storage (single source of truth)
-        actualRenderer: null,
-        // Scheduler for useFrameNext (initialized in renderer.tsx)
-        scheduler: null
+      disposeAll() {
+        for (const texture of getState().textures.values()) texture.dispose();
+        setState({ textures: /* @__PURE__ */ new Map(), _textureRefs: /* @__PURE__ */ new Map() });
       }
     };
-    return rootState;
-  });
-  const state = rootStore.getState();
-  Object.defineProperty(state, "gl", {
-    get() {
-      const currentState = rootStore.getState();
-      if (!currentState.isLegacy && currentState.internal.actualRenderer) {
-        const stack = new Error().stack || "";
-        const isInternalAccess = stack.includes("zustand") || stack.includes("setState") || stack.includes("Object.assign") || stack.includes("react-three-fiber/packages/fiber/src/core");
-        if (!isInternalAccess) {
-          const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
-          notifyDepreciated({
-            heading: "Accessing state.gl in WebGPU mode",
-            body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
-          });
-        }
-      }
-      return currentState.internal.actualRenderer;
-    },
-    set(value) {
-      rootStore.getState().internal.actualRenderer = value;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  Object.defineProperty(state, "renderer", {
-    get() {
-      return rootStore.getState().internal.actualRenderer;
-    },
-    set(value) {
-      rootStore.getState().internal.actualRenderer = value;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  let oldScene = state.scene;
-  rootStore.subscribe(() => {
-    const currentState = rootStore.getState();
-    const { scene, rootScene, set } = currentState;
-    if (scene !== oldScene) {
-      oldScene = scene;
-      if (scene?.isScene && scene !== rootScene) {
-        set({ rootScene: scene });
-      }
-    }
-  });
-  let oldSize = state.size;
-  let oldDpr = state.viewport.dpr;
-  let oldCamera = state.camera;
-  rootStore.subscribe(() => {
-    const { camera, size, viewport, set, internal } = rootStore.getState();
-    const actualRenderer = internal.actualRenderer;
-    const canvasTarget = internal.canvasTarget;
-    if (size.width !== oldSize.width || size.height !== oldSize.height || viewport.dpr !== oldDpr) {
-      oldSize = size;
-      oldDpr = viewport.dpr;
-      updateCamera(camera, size);
-      if (internal.isSecondary && canvasTarget) {
-        if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
-        canvasTarget.setSize(size.width, size.height, false);
-      } else {
-        if (viewport.dpr > 0) actualRenderer.setPixelRatio(viewport.dpr);
-        actualRenderer.setSize(size.width, size.height, false);
-        if (canvasTarget) {
-          if (viewport.dpr > 0) canvasTarget.setPixelRatio(viewport.dpr);
-          canvasTarget.setSize(size.width, size.height, false);
-        }
-      }
-    }
-    if (camera !== oldCamera) {
-      oldCamera = camera;
-      const { rootScene } = rootStore.getState();
-      if (camera && rootScene && !camera.parent) {
-        rootScene.add(camera);
-      }
-      set((state2) => ({ viewport: { ...state2.viewport, ...state2.viewport.getCurrentViewport(camera) } }));
-      const currentState = rootStore.getState();
-      if (currentState.autoUpdateFrustum && camera) {
-        updateFrustum(camera, currentState.frustum);
-      }
-    }
-  });
-  rootStore.subscribe((state2) => invalidate(state2));
-  return rootStore;
-};
+  }, [store]);
+  const subscribe = selector ? () => selector(registry) : (state) => state.textures;
+  const selected = useThree(subscribe);
+  return selector ? selected : registry;
+}
 
-const memoizedLoaders = /* @__PURE__ */ new WeakMap();
-const isConstructor$1 = (value) => typeof value === "function" && value?.prototype?.constructor === value;
-function getLoader(Proto) {
-  if (isConstructor$1(Proto)) {
-    let loader = memoizedLoaders.get(Proto);
-    if (!loader) {
-      loader = new Proto();
-      memoizedLoaders.set(Proto, loader);
+function useRenderTarget(widthOrOptions, heightOrOptions, options) {
+  const isLegacy = useThree((s) => s.isLegacy);
+  const size = useThree((s) => s.size);
+  let width;
+  let height;
+  let opts;
+  if (typeof widthOrOptions === "object") {
+    opts = widthOrOptions;
+  } else if (typeof widthOrOptions === "number") {
+    width = widthOrOptions;
+    if (typeof heightOrOptions === "object") {
+      height = widthOrOptions;
+      opts = heightOrOptions;
+    } else if (typeof heightOrOptions === "number") {
+      height = heightOrOptions;
+      opts = options;
+    } else {
+      height = widthOrOptions;
     }
-    return loader;
   }
-  return Proto;
-}
-function loadingFn(extensions, onProgress) {
-  return function(Proto, input) {
-    const loader = getLoader(Proto);
-    if (extensions) extensions(loader);
-    if ("loadAsync" in loader && typeof loader.loadAsync === "function") {
-      return loader.loadAsync(input, onProgress).then((data) => {
-        if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
-        return data;
-      });
+  return useMemo(() => {
+    const w = width ?? size.width;
+    const h = height ?? size.height;
+    {
+      return isLegacy ? new WebGLRenderTarget(w, h, opts) : new RenderTarget(w, h, opts);
     }
-    return new Promise(
-      (res, reject) => loader.load(
-        input,
-        (data) => {
-          if (isObject3D(data?.scene)) Object.assign(data, buildGraph(data.scene));
-          res(data);
-        },
-        onProgress,
-        (error) => reject(new Error(`Could not load ${input}: ${error?.message}`))
-      )
-    );
-  };
-}
-function useLoader(loader, input, extensions, onProgress) {
-  const keys = Array.isArray(input) ? input : [input];
-  const fn = loadingFn(extensions, onProgress);
-  const results = keys.map((key) => suspend(fn, [loader, key], { equal: is.equ }));
-  return Array.isArray(input) ? results : results[0];
+  }, [width, height, size.width, size.height, opts, isLegacy]);
 }
-useLoader.preload = function(loader, input, extensions, onProgress) {
-  const keys = Array.isArray(input) ? input : [input];
-  keys.forEach((key) => preload(loadingFn(extensions, onProgress), [loader, key]));
-};
-useLoader.clear = function(loader, input) {
-  const keys = Array.isArray(input) ? input : [input];
-  keys.forEach((key) => clear([loader, key]));
+
+const presetsObj = {
+  apartment: "lebombo_1k.hdr",
+  city: "potsdamer_platz_1k.hdr",
+  dawn: "kiara_1_dawn_1k.hdr",
+  forest: "forest_slope_1k.hdr",
+  lobby: "st_fagans_interior_1k.hdr",
+  night: "dikhololo_night_1k.hdr",
+  park: "rooitou_park_1k.hdr",
+  studio: "studio_small_03_1k.hdr",
+  sunset: "venice_sunset_1k.hdr",
+  warehouse: "empty_warehouse_01_1k.hdr"
 };
-useLoader.loader = getLoader;
 
-function useFrame(callback, priorityOrOptions) {
-  const store = React.useContext(context);
-  const isInsideCanvas = store !== null;
-  const scheduler = getScheduler();
-  const optionsKey = typeof priorityOrOptions === "number" ? `p:${priorityOrOptions}` : priorityOrOptions ? JSON.stringify({
-    id: priorityOrOptions.id,
-    phase: priorityOrOptions.phase,
-    priority: priorityOrOptions.priority,
-    fps: priorityOrOptions.fps,
-    drop: priorityOrOptions.drop,
-    enabled: priorityOrOptions.enabled,
-    before: priorityOrOptions.before,
-    after: priorityOrOptions.after
-  }) : "";
-  const options = React.useMemo(() => {
-    return typeof priorityOrOptions === "number" ? { priority: priorityOrOptions } : priorityOrOptions ?? {};
-  }, [optionsKey]);
-  const reactId = React.useId();
-  const id = options.id ?? reactId;
-  const callbackRef = useMutableCallback(callback);
-  const isLegacyPriority = typeof priorityOrOptions === "number" && priorityOrOptions > 0;
-  useIsomorphicLayoutEffect(() => {
-    if (!callback) return;
-    if (isInsideCanvas) {
-      const state = store.getState();
-      const rootId = state.internal.rootId;
-      if (isLegacyPriority) {
-        state.internal.priority++;
-        let parentRoot = state.previousRoot;
-        while (parentRoot) {
-          const parentState = parentRoot.getState();
-          if (parentState?.internal) parentState.internal.priority++;
-          parentRoot = parentState?.previousRoot;
-        }
-        notifyDepreciated({
-          heading: "useFrame with numeric priority is deprecated",
-          body: 'Using useFrame(callback, number) to control render order is deprecated.\n\nFor custom rendering, use: useFrame(callback, { phase: "render" })\nFor execution order within update phase, use: useFrame(callback, { priority: number })',
-          link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
-        });
+const CUBEMAP_ROOT = "https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/";
+const isArray = (arr) => Array.isArray(arr);
+const defaultFiles = ["/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"];
+function useEnvironment({
+  files = defaultFiles,
+  path = "",
+  preset = void 0,
+  colorSpace = void 0,
+  extensions
+} = {}) {
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+    path = CUBEMAP_ROOT;
+  }
+  const multiFile = isArray(files);
+  const { extension, isCubemap } = getExtension(files);
+  const loader = getLoader(extension);
+  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
+  const renderer = useThree((state) => state.renderer);
+  useLayoutEffect(() => {
+    if (extension !== "webp" && extension !== "jpg" && extension !== "jpeg") return;
+    function clearGainmapTexture() {
+      useLoader.clear(loader, multiFile ? [files] : files);
+    }
+    renderer.domElement.addEventListener("webglcontextlost", clearGainmapTexture, { once: true });
+  }, [extension, files, loader, multiFile, renderer.domElement]);
+  const loaderResult = useLoader(
+    loader,
+    multiFile ? [files] : files,
+    (loader2) => {
+      if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
+        loader2.setRenderer?.(renderer);
       }
-      const wrappedCallback = (frameState, delta) => {
-        const localState = store.getState();
-        const mergedState = {
-          ...localState,
-          time: frameState.time,
-          delta: frameState.delta,
-          elapsed: frameState.elapsed,
-          frame: frameState.frame
-        };
-        callbackRef.current?.(mergedState, delta);
-      };
-      const unregister = scheduler.register(wrappedCallback, {
-        id,
-        rootId,
-        ...options
-      });
-      return () => {
-        unregister();
-        if (isLegacyPriority) {
-          const currentState = store.getState();
-          if (currentState.internal) {
-            currentState.internal.priority--;
-            let parentRoot = currentState.previousRoot;
-            while (parentRoot) {
-              const parentState = parentRoot.getState();
-              if (parentState?.internal) parentState.internal.priority--;
-              parentRoot = parentState?.previousRoot;
-            }
-          }
-        }
-      };
-    } else {
-      return scheduler.register(
-        (state, delta) => {
-          const frameState = state;
-          if (!frameState.renderer) return;
-          callbackRef.current?.(frameState, delta);
-        },
-        { id, ...options }
-      );
+      loader2.setPath?.(path);
+      if (extensions) extensions(loader2);
     }
-  }, [store, scheduler, id, optionsKey, isLegacyPriority, isInsideCanvas]);
-  const isPaused = React.useSyncExternalStore(
-    // Subscribe function
-    React.useCallback(
-      (onStoreChange) => {
-        return getScheduler().subscribeJobState(id, onStoreChange);
-      },
-      [id]
-    ),
-    // getSnapshot function
-    React.useCallback(() => getScheduler().isJobPaused(id), [id]),
-    // getServerSnapshot function (SSR)
-    React.useCallback(() => false, [])
   );
-  const controls = React.useMemo(() => {
-    const scheduler2 = getScheduler();
-    return {
-      /** The job's unique ID */
-      id,
-      /**
-       * Access to the global scheduler for frame loop control.
-       * Use for controlling the entire frame loop, adding phases, etc.
-       */
-      scheduler: scheduler2,
-      /**
-       * Manually step this job only.
-       * Bypasses FPS limiting - always runs.
-       * @param timestamp Optional timestamp (defaults to performance.now())
-       */
-      step: (timestamp) => {
-        getScheduler().stepJob(id, timestamp);
-      },
-      /**
-       * Manually step ALL jobs in the scheduler.
-       * Useful for frameloop='never' mode.
-       * @param timestamp Optional timestamp (defaults to performance.now())
-       */
-      stepAll: (timestamp) => {
-        getScheduler().step(timestamp);
-      },
-      /**
-       * Pause this job (set enabled=false).
-       * Job remains registered but won't run.
-       */
-      pause: () => {
-        getScheduler().pauseJob(id);
-      },
-      /**
-       * Resume this job (set enabled=true).
-       */
-      resume: () => {
-        getScheduler().resumeJob(id);
-      },
-      /**
-       * Reactive paused state - automatically updates when pause/resume is called.
-       * No need for forceUpdate() in your components.
-       */
-      isPaused
-    };
-  }, [id, isPaused]);
-  return controls;
+  let texture = multiFile ? (
+    // @ts-ignore
+    loaderResult[0]
+  ) : loaderResult;
+  if (extension === "jpg" || extension === "jpeg" || extension === "webp") {
+    texture = texture.renderTarget?.texture;
+  }
+  texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
+  texture.colorSpace = colorSpace ?? (isCubemap ? "srgb" : "srgb-linear");
+  return texture;
+}
+const preloadDefaultOptions = {
+  files: defaultFiles,
+  path: "",
+  preset: void 0,
+  extensions: void 0
+};
+useEnvironment.preload = (preloadOptions) => {
+  const options = { ...preloadDefaultOptions, ...preloadOptions };
+  let { files, path = "" } = options;
+  const { preset, extensions } = options;
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+    path = CUBEMAP_ROOT;
+  }
+  const { extension } = getExtension(files);
+  if (extension === "webp" || extension === "jpg" || extension === "jpeg") {
+    throw new Error("useEnvironment: Preloading gainmaps is not supported");
+  }
+  const loader = getLoader(extension);
+  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
+  useLoader.preload(loader, isArray(files) ? [files] : files, (loader2) => {
+    loader2.setPath?.(path);
+    if (extensions) extensions(loader2);
+  });
+};
+const clearDefaultOptins = {
+  files: defaultFiles,
+  preset: void 0
+};
+useEnvironment.clear = (clearOptions) => {
+  const options = { ...clearDefaultOptins, ...clearOptions };
+  let { files } = options;
+  const { preset } = options;
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+  }
+  const { extension } = getExtension(files);
+  const loader = getLoader(extension);
+  if (!loader) throw new Error("useEnvironment: Unrecognized file extension: " + files);
+  useLoader.clear(loader, isArray(files) ? [files] : files);
+};
+function validatePreset(preset) {
+  if (!(preset in presetsObj)) throw new Error("Preset must be one of: " + Object.keys(presetsObj).join(", "));
+}
+function getExtension(files) {
+  const isCubemap = isArray(files) && files.length === 6;
+  const isGainmap = isArray(files) && files.length === 3 && files.some((file) => file.endsWith("json"));
+  const firstEntry = isArray(files) ? files[0] : files;
+  const extension = isCubemap ? "cube" : isGainmap ? "webp" : firstEntry.startsWith("data:application/exr") ? "exr" : firstEntry.startsWith("data:application/hdr") ? "hdr" : firstEntry.startsWith("data:image/jpeg") ? "jpg" : firstEntry.split(".").pop()?.split("?")?.shift()?.toLowerCase();
+  return { extension, isCubemap, isGainmap };
+}
+function getLoader(extension) {
+  const loader = extension === "cube" ? CubeTextureLoader : extension === "hdr" ? HDRLoader : extension === "exr" ? EXRLoader : extension === "jpg" || extension === "jpeg" ? UltraHDRLoader : extension === "webp" ? GainMapLoader : null;
+  return loader;
 }
 
-const IsObject = (url) => url === Object(url) && !Array.isArray(url) && typeof url !== "function";
-function getUrls(input) {
-  if (typeof input === "string") return [input];
-  if (Array.isArray(input)) return input;
-  return Object.values(input);
+function useStore() {
+  const store = useContext(context);
+  if (!store) throw new Error("R3F: Hooks can only be used within the Canvas component!");
+  return store;
 }
-function allUrlsCached(urls, textureCache) {
-  return urls.every((url) => textureCache.has(url));
+function useThree(selector = (state) => state, equalityFn) {
+  return useStore()(selector, equalityFn);
 }
-function buildFromCache(input, textureCache) {
-  if (typeof input === "string") {
-    return textureCache.get(input);
-  } else if (Array.isArray(input)) {
-    return input.map((url) => textureCache.get(url));
-  } else {
-    const result = {};
-    const objInput = input;
-    for (const key in objInput) {
-      result[key] = textureCache.get(objInput[key]);
-    }
-    return result;
-  }
-}
-function useTexture(input, optionsOrOnLoad) {
-  const renderer = useThree((state) => state.internal.actualRenderer);
-  const store = useStore();
-  const options = typeof optionsOrOnLoad === "function" ? { onLoad: optionsOrOnLoad } : optionsOrOnLoad ?? {};
-  const { onLoad, cache = true } = options;
-  const onLoadRef = useRef(onLoad);
-  onLoadRef.current = onLoad;
-  const onLoadCalledForRef = useRef(null);
-  const urls = useMemo(() => getUrls(input), [input]);
-  const cachedResult = useMemo(() => {
-    if (!cache) return null;
-    const textures = store.getState().textures;
-    if (!allUrlsCached(urls, textures)) return null;
-    return buildFromCache(input, textures);
-  }, [cache, urls, input, store]);
-  const loadedTextures = useLoader(
-    TextureLoader,
-    IsObject(input) ? Object.values(input) : input
-  );
-  const inputKey = urls.join("\0");
-  useLayoutEffect(() => {
-    if (cachedResult) return;
-    if (onLoadCalledForRef.current === inputKey) return;
-    onLoadCalledForRef.current = inputKey;
-    onLoadRef.current?.(loadedTextures);
-  }, [cachedResult, loadedTextures, inputKey]);
-  useEffect(() => {
-    if (cachedResult) return;
-    if ("initTexture" in renderer) {
-      let textureArray = [];
-      if (Array.isArray(loadedTextures)) {
-        textureArray = loadedTextures;
-      } else if (loadedTextures instanceof Texture$1) {
-        textureArray = [loadedTextures];
-      } else if (IsObject(loadedTextures)) {
-        textureArray = Object.values(loadedTextures);
-      }
-      textureArray.forEach((texture) => {
-        if (texture instanceof Texture$1) {
-          renderer.initTexture(texture);
-        }
-      });
-    }
-  }, [renderer, loadedTextures, cachedResult]);
-  const mappedTextures = useMemo(() => {
-    if (cachedResult) return cachedResult;
-    if (IsObject(input)) {
-      const keyed = {};
-      const textureArray = loadedTextures;
-      let i = 0;
-      for (const key in input) keyed[key] = textureArray[i++];
-      return keyed;
-    } else {
-      return loadedTextures;
-    }
-  }, [input, loadedTextures, cachedResult]);
-  useEffect(() => {
-    if (!cache) return;
-    const urlTextureMap = [];
-    if (typeof input === "string") {
-      urlTextureMap.push([input, mappedTextures]);
-    } else if (Array.isArray(input)) {
-      const textureArray = mappedTextures;
-      input.forEach((url, i) => urlTextureMap.push([url, textureArray[i]]));
-    } else if (IsObject(input)) {
-      const textureRecord = mappedTextures;
-      for (const key in input) {
-        const url = input[key];
-        urlTextureMap.push([url, textureRecord[key]]);
-      }
-    }
-    store.setState((state) => {
-      const refs = new Map(state._textureRefs);
-      let textures = state.textures;
-      let added = false;
-      for (const [url, texture] of urlTextureMap) {
-        if (!textures.has(url)) {
-          if (!added) {
-            textures = new Map(textures);
-            added = true;
-          }
-          textures.set(url, texture);
-        }
-        refs.set(url, (refs.get(url) ?? 0) + 1);
-      }
-      return added ? { textures, _textureRefs: refs } : { _textureRefs: refs };
-    });
-    return () => store.setState((state) => {
-      const refs = new Map(state._textureRefs);
-      for (const [url] of urlTextureMap) {
-        const next = (refs.get(url) ?? 0) - 1;
-        if (next <= 0) refs.delete(url);
-        else refs.set(url, next);
-      }
-      return { _textureRefs: refs };
-    });
-  }, [cache, input, mappedTextures, store]);
-  return mappedTextures;
-}
-useTexture.preload = (url) => useLoader.preload(TextureLoader, url);
-useTexture.clear = (input) => useLoader.clear(TextureLoader, input);
-const Texture = ({
-  children,
-  input,
-  onLoad,
-  cache
-}) => {
-  const options = typeof onLoad === "function" ? { onLoad, cache } : { ...onLoad, cache };
-  const ret = useTexture(input, options);
-  return /* @__PURE__ */ jsx(Fragment, { children: children?.(ret) });
-};
-
-function useTextures(selector) {
-  const store = useStore();
-  const registry = useMemo(() => {
-    const getState = store.getState;
-    const setState = store.setState;
-    const getOne = (key) => getState().textures.get(key);
-    return {
-      get all() {
-        return getState().textures;
-      },
-      get(input) {
-        if (typeof input === "string") return getOne(input);
-        if (Array.isArray(input)) return input.map(getOne);
-        const out = {};
-        for (const name in input) out[name] = getOne(input[name]);
-        return out;
-      },
-      has: (key) => getState().textures.has(key),
-      add(keyOrRecord, texture) {
-        setState((state) => {
-          const textures = new Map(state.textures);
-          if (typeof keyOrRecord === "string") {
-            textures.set(keyOrRecord, texture);
-          } else {
-            for (const key in keyOrRecord) textures.set(key, keyOrRecord[key]);
-          }
-          return { textures };
-        });
-      },
-      dispose(key, options) {
-        const state = getState();
-        const refs = state._textureRefs.get(key) ?? 0;
-        if (refs > 0 && !options?.force) {
-          console.warn(
-            `[useTextures] "${key}" still has ${refs} active reference(s); skipping dispose. Pass { force: true } to override.`
-          );
-          return false;
-        }
-        state.textures.get(key)?.dispose();
-        setState((s) => {
-          const textures = new Map(s.textures);
-          textures.delete(key);
-          const nextRefs = new Map(s._textureRefs);
-          nextRefs.delete(key);
-          return { textures, _textureRefs: nextRefs };
-        });
-        return true;
-      },
-      disposeAll() {
-        for (const texture of getState().textures.values()) texture.dispose();
-        setState({ textures: /* @__PURE__ */ new Map(), _textureRefs: /* @__PURE__ */ new Map() });
-      }
-    };
-  }, [store]);
-  const subscribe = selector ? () => selector(registry) : (state) => state.textures;
-  const selected = useThree(subscribe);
-  return selector ? selected : registry;
-}
-
-function useRenderTarget(widthOrOptions, heightOrOptions, options) {
-  const isLegacy = useThree((s) => s.isLegacy);
-  const size = useThree((s) => s.size);
-  let width;
-  let height;
-  let opts;
-  if (typeof widthOrOptions === "object") {
-    opts = widthOrOptions;
-  } else if (typeof widthOrOptions === "number") {
-    width = widthOrOptions;
-    if (typeof heightOrOptions === "object") {
-      height = widthOrOptions;
-      opts = heightOrOptions;
-    } else if (typeof heightOrOptions === "number") {
-      height = heightOrOptions;
-      opts = options;
-    } else {
-      height = widthOrOptions;
-    }
-  }
-  return useMemo(() => {
-    const w = width ?? size.width;
-    const h = height ?? size.height;
-    {
-      return isLegacy ? new WebGLRenderTarget(w, h, opts) : new RenderTarget(w, h, opts);
-    }
-  }, [width, height, size.width, size.height, opts, isLegacy]);
-}
-
-function useStore() {
-  const store = useContext(context);
-  if (!store) throw new Error("R3F: Hooks can only be used within the Canvas component!");
-  return store;
-}
-function useThree(selector = (state) => state, equalityFn) {
-  return useStore()(selector, equalityFn);
-}
-function useInstanceHandle(ref) {
-  const instance = useRef(null);
-  useImperativeHandle(instance, () => ref.current.__r3f, [ref]);
-  return instance;
+function useInstanceHandle(ref) {
+  const instance = useRef(null);
+  useImperativeHandle(instance, () => ref.current.__r3f, [ref]);
+  return instance;
 }
 function useGraph(object) {
   return useMemo(() => buildGraph(object), [object]);
 }
 
+const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
+
 let effectId = 0;
 function addEffect(callback) {
   notifyDepreciated({
@@ -2376,7 +1668,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.0-alpha.2";
+const version = "10.0.0-alpha.3";
 const packageData = {
 	version: version};
 
@@ -13522,117 +12814,700 @@ Visit https://react.dev/link/error-boundaries to learn more about error boundari
               break;
             }
           }
-        }
-        return e;
-      }, le.findHostInstance = function(e) {
-        var n = e._reactInternals;
-        if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
-        return e = mu(n), e === null ? null : ot(e.stateNode);
-      }, le.findHostInstanceWithNoPortals = function(e) {
-        return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
-      }, le.findHostInstanceWithWarning = function(e, n) {
-        var o = e._reactInternals;
-        if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
-        if (e = mu(o), e === null) return null;
-        if (e.mode & 8) {
-          var i = G(o) || "Component";
-          mb[i] || (mb[i] = true, B(e, function() {
-            o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
-          }));
-        }
-        return ot(e.stateNode);
-      }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
-        var n = ye;
-        ye |= 1;
-        var o = x.T, i = wt();
-        try {
-          if (an(2), x.T = null, e) return e();
-        } finally {
-          an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
-        }
-      }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
-        if (!xr) throw Error("Test selector API is not supported by this renderer.");
-        for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
-          var o = n[e++], i = o.tag;
-          if (!Kr(o)) {
-            if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
-            for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
+        }
+        return e;
+      }, le.findHostInstance = function(e) {
+        var n = e._reactInternals;
+        if (n === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
+        return e = mu(n), e === null ? null : ot(e.stateNode);
+      }, le.findHostInstanceWithNoPortals = function(e) {
+        return e = Ed(e), e = e !== null ? _p(e) : null, e === null ? null : ot(e.stateNode);
+      }, le.findHostInstanceWithWarning = function(e, n) {
+        var o = e._reactInternals;
+        if (o === void 0) throw typeof e.render == "function" ? Error("Unable to find node on an unmounted component.") : (e = Object.keys(e).join(","), Error("Argument appears to not be a ReactComponent. Keys: " + e));
+        if (e = mu(o), e === null) return null;
+        if (e.mode & 8) {
+          var i = G(o) || "Component";
+          mb[i] || (mb[i] = true, B(e, function() {
+            o.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", n, n, i);
+          }));
+        }
+        return ot(e.stateNode);
+      }, le.flushPassiveEffects = el, le.flushSyncFromReconciler = function(e) {
+        var n = ye;
+        ye |= 1;
+        var o = x.T, i = wt();
+        try {
+          if (an(2), x.T = null, e) return e();
+        } finally {
+          an(i), x.T = o, ye = n, (ye & (Zn | uo)) === Jn && Wa(0);
+        }
+      }, le.flushSyncWork = Ls, le.focusWithin = function(e, n) {
+        if (!xr) throw Error("Test selector API is not supported by this renderer.");
+        for (e = Ef(e), n = hh(e, n), n = Array.from(n), e = 0; e < n.length; ) {
+          var o = n[e++], i = o.tag;
+          if (!Kr(o)) {
+            if ((i === 5 || i === 26 || i === 27) && Ft(o.stateNode)) return true;
+            for (o = o.child; o !== null; ) n.push(o), o = o.sibling;
+          }
+        }
+        return false;
+      }, le.getFindAllNodesFailureDescription = function(e, n) {
+        if (!xr) throw Error("Test selector API is not supported by this renderer.");
+        var o = 0, i = [];
+        e = [Ef(e), 0];
+        for (var s = 0; s < e.length; ) {
+          var u = e[s++], f = u.tag, p = e[s++], g = n[p];
+          if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
+        }
+        if (o < n.length) {
+          for (e = []; o < n.length; o++) e.push(Sc(n[o]));
+          return `findAllNodes was able to match part of the selector:
+  ` + (i.join(" > ") + `
+
+No matching component was found for:
+  `) + e.join(" > ");
+        }
+        return null;
+      }, le.getPublicRootInstance = function(e) {
+        if (e = e.current, !e.child) return null;
+        switch (e.child.tag) {
+          case 27:
+          case 5:
+            return ot(e.child.stateNode);
+          default:
+            return e.child.stateNode;
+        }
+      }, le.injectIntoDevTools = function() {
+        var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
+        return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
+      }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
+        function s() {
+          var S = kc(e, n);
+          u.forEach(function(T) {
+            0 > S.indexOf(T) && g(T);
+          }), S.forEach(function(T) {
+            0 > u.indexOf(T) && p(T);
+          });
+        }
+        if (!xr) throw Error("Test selector API is not supported by this renderer.");
+        var u = kc(e, n);
+        o = zr(u, o, i);
+        var f = o.disconnect, p = o.observe, g = o.unobserve;
+        return bm.push(s), { disconnect: function() {
+          var S = bm.indexOf(s);
+          0 <= S && bm.splice(S, 1), f();
+        } };
+      }, le.shouldError = function(e) {
+        return pu(e);
+      }, le.shouldSuspend = function(e) {
+        return fu(e);
+      }, le.startHostTransition = function(e, n, o, i) {
+        if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
+        var s = uf(e).queue;
+        Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
+          x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
+          var u = uf(e);
+          return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
+        });
+      }, le.updateContainer = function(e, n, o, i) {
+        var s = n.current, u = Nt(s);
+        return As(s, u, e, n, o, i), u;
+      }, le.updateContainerSync = Wh, le;
+    }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
+  })(Mg)), Mg.exports;
+}
+var Eb;
+function n0() {
+  return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
+}
+var t0 = n0();
+const r0 = Xb(t0);
+
+const DEFAULT_POINTER_ID = 0;
+const XR_POINTER_ID_START = 1e3;
+function getPointerState(internal, pointerId) {
+  let state = internal.pointerMap.get(pointerId);
+  if (!state) {
+    state = {
+      hovered: /* @__PURE__ */ new Map(),
+      captured: /* @__PURE__ */ new Map(),
+      initialClick: [0, 0],
+      initialHits: []
+    };
+    internal.pointerMap.set(pointerId, state);
+  }
+  return state;
+}
+function getPointerId(event) {
+  return "pointerId" in event ? event.pointerId : DEFAULT_POINTER_ID;
+}
+function makeId(event) {
+  return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId;
+}
+function releaseInternalPointerCapture(internal, obj, pointerId) {
+  const pointerState = internal.pointerMap.get(pointerId);
+  if (!pointerState) return;
+  const captureData = pointerState.captured.get(obj);
+  if (captureData) {
+    pointerState.captured.delete(obj);
+    try {
+      captureData.target.releasePointerCapture?.(pointerId);
+    } catch {
+    }
+  }
+}
+function swapInteractivity(store, object, newObject) {
+  const { internal } = store.getState();
+  for (let i = 0; i < internal.interaction.length; i++) {
+    if (internal.interaction[i] === object) internal.interaction[i] = newObject;
+  }
+  for (const pointerState of internal.pointerMap.values()) {
+    for (let i = 0; i < pointerState.initialHits.length; i++) {
+      if (pointerState.initialHits[i] === object) pointerState.initialHits[i] = newObject;
+    }
+    pointerState.hovered.forEach((value, key) => {
+      if (value.eventObject === object || value.object === object) {
+        pointerState.hovered.delete(key);
+        const next = {
+          ...value,
+          eventObject: value.eventObject === object ? newObject : value.eventObject,
+          object: value.object === object ? newObject : value.object
+        };
+        pointerState.hovered.set(makeId(next), next);
+      }
+    });
+    const captureData = pointerState.captured.get(object);
+    if (captureData) {
+      pointerState.captured.delete(object);
+      pointerState.captured.set(newObject, {
+        ...captureData,
+        intersection: {
+          ...captureData.intersection,
+          object: captureData.intersection.object === object ? newObject : captureData.intersection.object,
+          eventObject: captureData.intersection.eventObject === object ? newObject : captureData.intersection.eventObject
+        }
+      });
+    }
+  }
+  unregisterVisibility(store, object);
+}
+function removeInteractivity(store, object) {
+  const { internal } = store.getState();
+  internal.interaction = internal.interaction.filter((o) => o !== object);
+  for (const [pointerId, pointerState] of internal.pointerMap) {
+    pointerState.initialHits = pointerState.initialHits.filter((o) => o !== object);
+    pointerState.hovered.forEach((value, key) => {
+      if (value.eventObject === object || value.object === object) {
+        pointerState.hovered.delete(key);
+      }
+    });
+    if (pointerState.captured.has(object)) {
+      releaseInternalPointerCapture(internal, object, pointerId);
+    }
+  }
+  unregisterVisibility(store, object);
+}
+function createEvents(store) {
+  function calculateDistance(event, pointerId) {
+    const { internal } = store.getState();
+    const pointerState = internal.pointerMap.get(pointerId);
+    if (!pointerState) return 0;
+    const [initialX, initialY] = pointerState.initialClick;
+    const dx = event.offsetX - initialX;
+    const dy = event.offsetY - initialY;
+    return Math.round(Math.sqrt(dx * dx + dy * dy));
+  }
+  function filterPointerEvents(objects) {
+    return objects.filter(
+      (obj) => ["Move", "Over", "Enter", "Out", "Leave"].some(
+        (name) => obj.__r3f?.handlers["onPointer" + name]
+      ) || ["OverEnter", "OverLeave", "Over"].some(
+        (name) => obj.__r3f?.handlers["onDrag" + name]
+      ) || obj.__r3f?.handlers.onDrop
+    );
+  }
+  function intersect(event, filter) {
+    const state = store.getState();
+    const duplicates = /* @__PURE__ */ new Set();
+    const intersections = [];
+    const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
+    for (let i = 0; i < eventsObjects.length; i++) {
+      const state2 = getRootState(eventsObjects[i]);
+      if (state2) {
+        state2.raycaster.camera = void 0;
+      }
+    }
+    if (!state.previousRoot) {
+      state.events.compute?.(event, state);
+    }
+    function handleRaycast(obj) {
+      const state2 = getRootState(obj);
+      if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return [];
+      if (state2.raycaster.camera === void 0) {
+        state2.events.compute?.(event, state2, state2.previousRoot?.getState());
+        if (state2.raycaster.camera === void 0) state2.raycaster.camera = null;
+      }
+      if (!state2.raycaster.camera) return [];
+      obj.updateWorldMatrix(true, true);
+      return state2.raycaster.intersectObject(obj, true);
+    }
+    let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => {
+      const aInteractivePriority = a.object.userData?.interactivePriority;
+      const bInteractivePriority = b.object.userData?.interactivePriority;
+      if (aInteractivePriority !== void 0 || bInteractivePriority !== void 0) {
+        if (aInteractivePriority !== void 0 && bInteractivePriority === void 0) return -1;
+        if (bInteractivePriority !== void 0 && aInteractivePriority === void 0) return 1;
+        if (aInteractivePriority !== bInteractivePriority) {
+          return (bInteractivePriority ?? 0) - (aInteractivePriority ?? 0);
+        }
+      }
+      const aState = getRootState(a.object);
+      const bState = getRootState(b.object);
+      const aPriority = aState?.events?.priority ?? 1;
+      const bPriority = bState?.events?.priority ?? 1;
+      return bPriority - aPriority || a.distance - b.distance;
+    }).filter((item) => {
+      const id = makeId(item);
+      if (duplicates.has(id)) return false;
+      duplicates.add(id);
+      return true;
+    });
+    if (state.events.filter) hits = state.events.filter(hits, state);
+    for (const hit of hits) {
+      let eventObject = hit.object;
+      while (eventObject) {
+        if (eventObject.__r3f?.eventCount) {
+          intersections.push({ ...hit, eventObject });
+        }
+        eventObject = eventObject.parent;
+      }
+    }
+    if ("pointerId" in event) {
+      const pointerId = event.pointerId;
+      const pointerState = state.internal.pointerMap.get(pointerId);
+      if (pointerState?.captured.size) {
+        for (const captureData of pointerState.captured.values()) {
+          if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection);
+        }
+      }
+    }
+    return intersections;
+  }
+  function handleIntersects(intersections, event, delta, callback) {
+    if (intersections.length) {
+      const localState = { stopped: false };
+      for (const hit of intersections) {
+        const state = getRootState(hit.object);
+        if (state) {
+          const { raycaster, pointer, camera, internal } = state;
+          const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera);
+          const hasPointerCapture = (id) => {
+            const pointerState = internal.pointerMap.get(id);
+            return pointerState?.captured.has(hit.eventObject) ?? false;
+          };
+          const setPointerCapture = (id) => {
+            const captureData = { intersection: hit, target: event.target };
+            const pointerState = getPointerState(internal, id);
+            pointerState.captured.set(hit.eventObject, captureData);
+            event.target.setPointerCapture(id);
+          };
+          const releasePointerCapture = (id) => {
+            releaseInternalPointerCapture(internal, hit.eventObject, id);
+          };
+          const extractEventProps = {};
+          for (const prop in event) {
+            const property = event[prop];
+            if (typeof property !== "function") extractEventProps[prop] = property;
+          }
+          const eventPointerId = "pointerId" in event ? event.pointerId : void 0;
+          const raycastEvent = {
+            ...hit,
+            ...extractEventProps,
+            pointer,
+            intersections,
+            stopped: localState.stopped,
+            delta,
+            unprojectedPoint,
+            ray: raycaster.ray,
+            camera,
+            pointerId: eventPointerId,
+            // Hijack stopPropagation, which just sets a flag
+            stopPropagation() {
+              const pointerState = eventPointerId !== void 0 ? internal.pointerMap.get(eventPointerId) : void 0;
+              if (
+                // ...if this pointer hasn't been captured
+                !pointerState?.captured.size || // ... or if the hit object is capturing the pointer
+                pointerState.captured.has(hit.eventObject)
+              ) {
+                raycastEvent.stopped = localState.stopped = true;
+                if (pointerState?.hovered.size && Array.from(pointerState.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
+                  const higher = intersections.slice(0, intersections.indexOf(hit));
+                  cancelPointer([...higher, hit], eventPointerId);
+                }
+              }
+            },
+            // there should be a distinction between target and currentTarget
+            target: { hasPointerCapture, setPointerCapture, releasePointerCapture },
+            currentTarget: { hasPointerCapture, setPointerCapture, releasePointerCapture },
+            nativeEvent: event
+          };
+          callback(raycastEvent);
+          if (localState.stopped === true) break;
+        }
+      }
+    }
+    return intersections;
+  }
+  function cancelPointer(intersections, pointerId) {
+    const { internal } = store.getState();
+    const pid = pointerId ?? DEFAULT_POINTER_ID;
+    const pointerState = internal.pointerMap.get(pid);
+    if (!pointerState) return;
+    for (const [hoveredId, hoveredObj] of pointerState.hovered) {
+      if (!intersections.length || !intersections.find(
+        (hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId
+      )) {
+        const eventObject = hoveredObj.eventObject;
+        const instance = eventObject.__r3f;
+        pointerState.hovered.delete(hoveredId);
+        if (instance?.eventCount) {
+          const handlers = instance.handlers;
+          const data = { ...hoveredObj, intersections };
+          handlers.onPointerOut?.(data);
+          handlers.onPointerLeave?.(data);
+          handlers.onDragOverLeave?.(data);
+        }
+      }
+    }
+  }
+  function pointerMissed(event, objects) {
+    for (let i = 0; i < objects.length; i++) {
+      const instance = objects[i].__r3f;
+      instance?.handlers.onPointerMissed?.(event);
+    }
+  }
+  function dragOverMissed(event, objects) {
+    for (let i = 0; i < objects.length; i++) {
+      const instance = objects[i].__r3f;
+      instance?.handlers.onDragOverMissed?.(event);
+    }
+  }
+  function dropMissed(event, objects) {
+    for (let i = 0; i < objects.length; i++) {
+      const instance = objects[i].__r3f;
+      instance?.handlers.onDropMissed?.(event);
+    }
+  }
+  function cleanupPointer(pointerId) {
+    const { internal } = store.getState();
+    const pointerState = internal.pointerMap.get(pointerId);
+    if (pointerState) {
+      for (const [, hoveredObj] of pointerState.hovered) {
+        const eventObject = hoveredObj.eventObject;
+        const instance = eventObject.__r3f;
+        if (instance?.eventCount) {
+          const handlers = instance.handlers;
+          const data = { ...hoveredObj, intersections: [] };
+          handlers.onPointerOut?.(data);
+          handlers.onPointerLeave?.(data);
+        }
+      }
+      internal.pointerMap.delete(pointerId);
+    }
+    internal.pointerDirty.delete(pointerId);
+  }
+  function processDeferredPointer(event, pointerId) {
+    const state = store.getState();
+    const { internal } = state;
+    if (!state.events.enabled) return;
+    const filter = filterPointerEvents;
+    const hits = intersect(event, filter);
+    cancelPointer(hits, pointerId);
+    function onIntersect(data) {
+      const eventObject = data.eventObject;
+      const instance = eventObject.__r3f;
+      if (!instance?.eventCount) return;
+      const handlers = instance.handlers;
+      if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
+        const id = makeId(data);
+        const pointerState = getPointerState(internal, pointerId);
+        const hoveredItem = pointerState.hovered.get(id);
+        if (!hoveredItem) {
+          pointerState.hovered.set(id, data);
+          handlers.onPointerOver?.(data);
+          handlers.onPointerEnter?.(data);
+        } else if (hoveredItem.stopped) {
+          data.stopPropagation();
+        }
+      }
+      handlers.onPointerMove?.(data);
+    }
+    handleIntersects(hits, event, 0, onIntersect);
+  }
+  function handlePointer(name) {
+    switch (name) {
+      case "onPointerLeave":
+      case "onDragLeave":
+        return () => cancelPointer([]);
+      // Global cancel of these events
+      case "onPointerCancel":
+        return (event) => {
+          const pointerId = getPointerId(event);
+          cleanupPointer(pointerId);
+        };
+      case "onLostPointerCapture":
+        return (event) => {
+          const { internal } = store.getState();
+          const pointerId = getPointerId(event);
+          const pointerState = internal.pointerMap.get(pointerId);
+          if (pointerState?.captured.size) {
+            requestAnimationFrame(() => {
+              const pointerState2 = internal.pointerMap.get(pointerId);
+              if (pointerState2?.captured.size) {
+                pointerState2.captured.clear();
+              }
+              cancelPointer([], pointerId);
+            });
+          }
+        };
+    }
+    return function handleEvent(event) {
+      const state = store.getState();
+      const { onPointerMissed, onDragOverMissed, onDropMissed, internal, events } = state;
+      const pointerId = getPointerId(event);
+      internal.lastEvent.current = event;
+      if (!events.enabled) return;
+      const isPointerMove = name === "onPointerMove";
+      const isDragOver = name === "onDragOver";
+      const isDrop = name === "onDrop";
+      const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick";
+      const isPointerDown = name === "onPointerDown";
+      const isPointerUp = name === "onPointerUp";
+      const isWheel = name === "onWheel";
+      const canDeferRaycasts = events.frameTimedRaycasts && state.frameloop === "always";
+      if (isPointerMove && canDeferRaycasts) {
+        events.compute?.(event, state);
+        internal.pointerDirty.set(pointerId, event);
+        return;
+      }
+      if (isWheel && canDeferRaycasts && !events.alwaysFireOnScroll) {
+        events.compute?.(event, state);
+        internal.pointerDirty.set(pointerId, event);
+        return;
+      }
+      if ((isClickEvent || isPointerDown || isPointerUp) && internal.pointerDirty.has(pointerId)) {
+        const deferredEvent = internal.pointerDirty.get(pointerId);
+        internal.pointerDirty.delete(pointerId);
+        processDeferredPointer(deferredEvent, pointerId);
+      }
+      const filter = isPointerMove || isDragOver || isDrop ? filterPointerEvents : void 0;
+      const hits = intersect(event, filter);
+      const delta = isClickEvent ? calculateDistance(event, pointerId) : 0;
+      if (isPointerDown) {
+        const pointerState2 = getPointerState(internal, pointerId);
+        pointerState2.initialClick = [event.offsetX, event.offsetY];
+        pointerState2.initialHits = hits.map((hit) => hit.eventObject);
+      }
+      const pointerState = internal.pointerMap.get(pointerId);
+      const initialHits = pointerState?.initialHits ?? [];
+      if (isClickEvent && !hits.length) {
+        if (delta <= 2) {
+          pointerMissed(event, internal.interaction);
+          if (onPointerMissed) onPointerMissed(event);
+        }
+      }
+      if (isDragOver && !hits.length) {
+        dragOverMissed(event, internal.interaction);
+        if (onDragOverMissed) onDragOverMissed(event);
+      }
+      if (isDrop && !hits.length) {
+        dropMissed(event, internal.interaction);
+        if (onDropMissed) onDropMissed(event);
+      }
+      if (isPointerMove || isDragOver) {
+        cancelPointer(hits, pointerId);
+      }
+      function onIntersect(data) {
+        const eventObject = data.eventObject;
+        const instance = eventObject.__r3f;
+        if (!instance?.eventCount) return;
+        const handlers = instance.handlers;
+        if (isPointerMove) {
+          if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) {
+            const id = makeId(data);
+            const pointerState2 = getPointerState(internal, pointerId);
+            const hoveredItem = pointerState2.hovered.get(id);
+            if (!hoveredItem) {
+              pointerState2.hovered.set(id, data);
+              handlers.onPointerOver?.(data);
+              handlers.onPointerEnter?.(data);
+            } else if (hoveredItem.stopped) {
+              data.stopPropagation();
+            }
+          }
+          handlers.onPointerMove?.(data);
+        } else if (isDragOver) {
+          const id = makeId(data);
+          const pointerState2 = getPointerState(internal, pointerId);
+          const hoveredItem = pointerState2.hovered.get(id);
+          if (!hoveredItem) {
+            pointerState2.hovered.set(id, data);
+            handlers.onDragOverEnter?.(data);
+          } else if (hoveredItem.stopped) {
+            data.stopPropagation();
+          }
+          handlers.onDragOver?.(data);
+        } else if (isDrop) {
+          handlers.onDrop?.(data);
+        } else {
+          const handler = handlers[name];
+          if (handler) {
+            if (!isClickEvent || initialHits.includes(eventObject)) {
+              pointerMissed(
+                event,
+                internal.interaction.filter((object) => !initialHits.includes(object))
+              );
+              handler(data);
+            }
+          } else {
+            if (isClickEvent && initialHits.includes(eventObject)) {
+              pointerMissed(
+                event,
+                internal.interaction.filter((object) => !initialHits.includes(object))
+              );
+            }
           }
         }
-        return false;
-      }, le.getFindAllNodesFailureDescription = function(e, n) {
-        if (!xr) throw Error("Test selector API is not supported by this renderer.");
-        var o = 0, i = [];
-        e = [Ef(e), 0];
-        for (var s = 0; s < e.length; ) {
-          var u = e[s++], f = u.tag, p = e[s++], g = n[p];
-          if ((f !== 5 && f !== 26 && f !== 27 || !Kr(u)) && (If(u, g) && (i.push(Sc(g)), p++, p > o && (o = p)), p < n.length)) for (u = u.child; u !== null; ) e.push(u, p), u = u.sibling;
+      }
+      handleIntersects(hits, event, delta, onIntersect);
+    };
+  }
+  function flushDeferredPointers() {
+    const { internal, events } = store.getState();
+    if (!events.frameTimedRaycasts) return;
+    for (const [pointerId, event] of internal.pointerDirty) {
+      processDeferredPointer(event, pointerId);
+    }
+    internal.pointerDirty.clear();
+  }
+  return { handlePointer, flushDeferredPointers, processDeferredPointer };
+}
+const DOM_EVENTS = {
+  onClick: ["click", false],
+  onContextMenu: ["contextmenu", false],
+  onDoubleClick: ["dblclick", false],
+  onDragEnter: ["dragenter", false],
+  onDragLeave: ["dragleave", false],
+  onDragOver: ["dragover", false],
+  onDrop: ["drop", false],
+  onWheel: ["wheel", true],
+  onPointerDown: ["pointerdown", true],
+  onPointerUp: ["pointerup", true],
+  onPointerLeave: ["pointerleave", true],
+  onPointerMove: ["pointermove", true],
+  onPointerCancel: ["pointercancel", true],
+  onLostPointerCapture: ["lostpointercapture", true]
+};
+function createPointerEvents(store) {
+  const { handlePointer, flushDeferredPointers, processDeferredPointer } = createEvents(store);
+  let nextXRPointerId = XR_POINTER_ID_START;
+  const xrPointers = /* @__PURE__ */ new Map();
+  return {
+    priority: 1,
+    enabled: true,
+    frameTimedRaycasts: true,
+    alwaysFireOnScroll: true,
+    updateOnFrame: false,
+    compute(event, state) {
+      state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+      state.raycaster.setFromCamera(state.pointer, state.camera);
+    },
+    connected: void 0,
+    handlers: Object.keys(DOM_EVENTS).reduce(
+      (acc, key) => ({ ...acc, [key]: handlePointer(key) }),
+      {}
+    ),
+    update: (pointerId) => {
+      const { events, internal } = store.getState();
+      if (!events.handlers) return;
+      if (pointerId !== void 0) {
+        const event = internal.pointerDirty.get(pointerId);
+        if (event) {
+          internal.pointerDirty.delete(pointerId);
+          processDeferredPointer(event, pointerId);
+        } else if (internal.lastEvent?.current) {
+          processDeferredPointer(internal.lastEvent.current, pointerId);
         }
-        if (o < n.length) {
-          for (e = []; o < n.length; o++) e.push(Sc(n[o]));
-          return `findAllNodes was able to match part of the selector:
-  ` + (i.join(" > ") + `
-
-No matching component was found for:
-  `) + e.join(" > ");
+      } else {
+        flushDeferredPointers();
+        if (internal.lastEvent?.current) {
+          events.handlers.onPointerMove(internal.lastEvent.current);
         }
-        return null;
-      }, le.getPublicRootInstance = function(e) {
-        if (e = e.current, !e.child) return null;
-        switch (e.child.tag) {
-          case 27:
-          case 5:
-            return ot(e.child.stateNode);
-          default:
-            return e.child.stateNode;
+      }
+    },
+    flush: () => {
+      const { events, internal } = store.getState();
+      flushDeferredPointers();
+      if (events.updateOnFrame && internal.lastEvent?.current && events.handlers) {
+        events.handlers.onPointerMove(internal.lastEvent.current);
+      }
+    },
+    connect: (target) => {
+      if (!target) return;
+      const { set, events } = store.getState();
+      events.disconnect?.();
+      set((state) => ({ events: { ...state.events, connected: target } }));
+      if (events.handlers) {
+        for (const name in events.handlers) {
+          const event = events.handlers[name];
+          const [eventName, passive] = DOM_EVENTS[name];
+          target.addEventListener(eventName, event, { passive });
         }
-      }, le.injectIntoDevTools = function() {
-        var e = { bundleType: 1, version: Jt, rendererPackageName: Zt, currentDispatcherRef: x, reconcilerVersion: "19.2.0" };
-        return jo !== null && (e.rendererConfig = jo), e.overrideHookState = gb, e.overrideHookStateDeletePath = yb, e.overrideHookStateRenamePath = bb, e.overrideProps = vb, e.overridePropsDeletePath = Sb, e.overridePropsRenamePath = kb, e.scheduleUpdate = wb, e.scheduleRetry = Pb, e.setErrorHandler = xb, e.setSuspenseHandler = zb, e.scheduleRefresh = hu, e.scheduleRoot = Fl, e.setRefreshHandler = Ir, e.getCurrentFiber = Ic, Ep(e);
-      }, le.isAlreadyRendering = Ns, le.observeVisibleRects = function(e, n, o, i) {
-        function s() {
-          var S = kc(e, n);
-          u.forEach(function(T) {
-            0 > S.indexOf(T) && g(T);
-          }), S.forEach(function(T) {
-            0 > u.indexOf(T) && p(T);
-          });
+      }
+    },
+    disconnect: () => {
+      const { set, events } = store.getState();
+      if (events.connected) {
+        if (events.handlers) {
+          for (const name in events.handlers) {
+            const event = events.handlers[name];
+            const [eventName] = DOM_EVENTS[name];
+            events.connected.removeEventListener(eventName, event);
+          }
         }
-        if (!xr) throw Error("Test selector API is not supported by this renderer.");
-        var u = kc(e, n);
-        o = zr(u, o, i);
-        var f = o.disconnect, p = o.observe, g = o.unobserve;
-        return bm.push(s), { disconnect: function() {
-          var S = bm.indexOf(s);
-          0 <= S && bm.splice(S, 1), f();
-        } };
-      }, le.shouldError = function(e) {
-        return pu(e);
-      }, le.shouldSuspend = function(e) {
-        return fu(e);
-      }, le.startHostTransition = function(e, n, o, i) {
-        if (e.tag !== 5) throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
-        var s = uf(e).queue;
-        Hp(e), nt(e, s, n, Xt, o === null ? Em : function() {
-          x.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
-          var u = uf(e);
-          return u.next === null && (u = e.alternate.memoizedState), qi(e, u.next.queue, {}, Nt(e)), o(i);
-        });
-      }, le.updateContainer = function(e, n, o, i) {
-        var s = n.current, u = Nt(s);
-        return As(s, u, e, n, o, i), u;
-      }, le.updateContainerSync = Wh, le;
-    }, Tt.exports.default = Tt.exports, Object.defineProperty(Tt.exports, "__esModule", { value: true }));
-  })(Mg)), Mg.exports;
-}
-var Eb;
-function n0() {
-  return Eb || (Eb = 1, process.env.NODE_ENV === "production" ? Rm.exports = Kb() : Rm.exports = e0()), Rm.exports;
+        set((state) => ({ events: { ...state.events, connected: void 0 } }));
+      }
+    },
+    // PREVIEW (A8): the XR pointer registration API may change before stable.
+    registerPointer: (config) => {
+      const pointerId = nextXRPointerId++;
+      xrPointers.set(pointerId, config);
+      const { internal } = store.getState();
+      getPointerState(internal, pointerId);
+      return pointerId;
+    },
+    unregisterPointer: (pointerId) => {
+      xrPointers.delete(pointerId);
+      const { internal } = store.getState();
+      const pointerState = internal.pointerMap.get(pointerId);
+      if (pointerState) {
+        for (const [, hoveredObj] of pointerState.hovered) {
+          const eventObject = hoveredObj.eventObject;
+          const instance = eventObject.__r3f;
+          if (instance?.eventCount) {
+            const handlers = instance.handlers;
+            const data = { ...hoveredObj, intersections: [] };
+            handlers.onPointerOut?.(data);
+            handlers.onPointerLeave?.(data);
+          }
+        }
+        internal.pointerMap.delete(pointerId);
+      }
+      internal.pointerDirty.delete(pointerId);
+    }
+  };
 }
-var t0 = n0();
-const r0 = Xb(t0);
-
-const t = 1, o = 8, r = 32, e = 2;
 
 function createReconciler(config) {
   const reconciler2 = r0(config);
@@ -13797,7 +13672,15 @@ function setFiberRef(fiber, publicInstance) {
   }
 }
 const reconstructed = [];
-function swapInstances() {
+function flushReconstructedInstances() {
+  if (reconstructed.length === 0) return;
+  try {
+    swapReconstructedInstances();
+  } finally {
+    reconstructed.length = 0;
+  }
+}
+function swapReconstructedInstances() {
   for (const [instance] of reconstructed) {
     const parent = instance.parent;
     if (parent) {
@@ -13815,6 +13698,9 @@ function swapInstances() {
       }
     }
     if (instance.isHidden) unhideInstance(instance);
+    if (isObject3D(instance.object) && !instance.parent) {
+      removeInteractivity(findInitialRoot(instance), instance.object);
+    }
     if (instance.object.__r3f) delete instance.object.__r3f;
     if (instance.type !== "primitive") disposeOnIdle(instance.object);
   }
@@ -13823,10 +13709,16 @@ function swapInstances() {
     const parent = instance.parent;
     if (parent) {
       const target = catalogue[toPascalCase(instance.type)];
+      const prevObject = instance.object;
       instance.object = instance.props.object ?? new target(...instance.props.args ?? []);
       instance.object.__r3f = instance;
       setFiberRef(fiber, instance.object);
+      if (isObject3D(prevObject) && isObject3D(instance.object)) {
+        swapInteractivity(findInitialRoot(instance), prevObject, instance.object);
+      }
       delete instance.appliedOnce;
+      instance.eventCount = 0;
+      instance.handlers = {};
       applyProps(instance.object, instance.props);
       if (instance.props.attach) {
         attach(parent, instance);
@@ -13843,14 +13735,114 @@ function swapInstances() {
       invalidateInstance(instance);
     }
   }
-  reconstructed.length = 0;
 }
 const handleTextInstance = () => {
 };
 const NO_CONTEXT = {};
 let currentUpdatePriority = NoEventPriority;
-const NoFlags = 0;
-const Update = 4;
+function getEventPriority(type) {
+  switch (type) {
+    case "beforetoggle":
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return e;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return o;
+    case "message": {
+      switch (unstable_getCurrentPriorityLevel()) {
+        case unstable_ImmediatePriority:
+          return e;
+        case unstable_UserBlockingPriority:
+          return o;
+        case unstable_NormalPriority:
+        case unstable_LowPriority:
+          return r;
+        case unstable_IdlePriority:
+          return i$1;
+        default:
+          return r;
+      }
+    }
+    default:
+      return r;
+  }
+}
+function scheduleMicrotask(callback) {
+  if (typeof queueMicrotask === "function") {
+    queueMicrotask(callback);
+  } else if (typeof Promise !== "undefined") {
+    Promise.resolve().then(callback).catch((error) => {
+      setTimeout(() => {
+        throw error;
+      });
+    });
+  } else {
+    setTimeout(callback);
+  }
+}
 const reconciler = /* @__PURE__ */ createReconciler({
   isPrimaryRenderer: false,
   warnsIfNotActing: false,
@@ -13889,16 +13881,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
     else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
     else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
     if (reconstruct) {
-      reconstructed.push([instance, { ...newProps }, fiber]);
+      reconstructed.push([instance, getInstanceProps(newProps), fiber]);
     } else {
       const changedProps = diffProps(instance, newProps);
-      if (Object.keys(changedProps).length) {
-        Object.assign(instance.props, changedProps);
-        applyProps(instance.object, changedProps);
-      }
+      const attach2 = instance.props.attach;
+      instance.props = getInstanceProps(newProps);
+      if (attach2 !== void 0) instance.props.attach = attach2;
+      else delete instance.props.attach;
+      if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
     }
-    const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
-    if (isTailSibling) swapInstances();
   },
   finalizeInitialChildren: (instance) => {
     for (const prop in instance.props) {
@@ -13923,8 +13914,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
     const target = container.getState().internal.container ?? container.getState().scene;
     return prepare(target, container, "", {});
   },
-  resetAfterCommit: () => {
-  },
+  // Reconstructed instances are swapped once all mutations are committed,
+  // before layout effects run so refs point to the new objects
+  resetAfterCommit: flushReconstructedInstances,
   shouldSetTextContent: () => false,
   clearContainer: () => false,
   hideInstance,
@@ -13932,6 +13924,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
   createTextInstance: handleTextInstance,
   hideTextInstance: handleTextInstance,
   unhideTextInstance: handleTextInstance,
+  // Mirrors react-dom, which flushes discrete work in microtasks
+  supportsMicrotasks: true,
+  scheduleMicrotask,
   scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
   cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
   noTimeout: -1,
@@ -13972,28 +13967,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
   },
   resolveUpdatePriority() {
     if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
-    switch (typeof window !== "undefined" && window.event?.type) {
-      case "click":
-      case "contextmenu":
-      case "dblclick":
-      case "dragenter":
-      case "dragleave":
-      case "drop":
-      case "pointercancel":
-      case "pointerdown":
-      case "pointerup":
-        return e;
-      case "dragover":
-      case "pointermove":
-      case "pointerout":
-      case "pointerover":
-      case "pointerenter":
-      case "pointerleave":
-      case "wheel":
-        return o;
-      default:
-        return r;
-    }
+    const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
+    if (eventType === void 0) return r;
+    return getEventPriority(eventType);
   },
   resetFormInstance() {
   },
@@ -14042,11 +14018,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
   cloneMutableTextInstance(textInstance) {
     return textInstance;
   },
+  // React 19.2 added these for root-level view transitions. They only run for hosts that opt into
+  // view transitions by returning a container from cloneRootViewTransitionContainer; R3F renders
+  // into a WebGL/WebGPU canvas, where cloning the root has no meaning, so we never opt in and
+  // React never calls them. They stay as no-ops rather than throws: the host config is shared by
+  // every root, and a throw here would turn a React-internal probe into a hard crash for users.
+  // Guarded by a test asserting a full render + unmount never reaches them.
   cloneRootViewTransitionContainer(_rootContainer) {
-    throw new Error("Not implemented.");
   },
   removeRootViewTransitionClone(_rootContainer, _clone) {
-    throw new Error("Not implemented.");
   },
   // https://github.com/facebook/react/pull/32465
   createFragmentInstance: (_fiber) => null,
@@ -14131,6 +14111,7 @@ function createRoot(canvas) {
   const lastConfiguredProps = {};
   let configured = false;
   let pending = null;
+  let rendererSetup = null;
   return {
     async configure(props = {}) {
       let resolve;
@@ -14161,7 +14142,7 @@ function createRoot(canvas) {
         forceEven
       } = props;
       const textureColorSpace = is.obj(glConfig) && !is.fun(glConfig) && !isRenderer(glConfig) && glConfig.textureColorSpace || is.obj(rendererConfig) && !is.fun(rendererConfig) && !isRenderer(rendererConfig) && rendererConfig.textureColorSpace || SRGBColorSpace;
-      const state = store.getState();
+      let state = store.getState();
       const defaultGLProps = {
         canvas,
         powerPreference: "high-performance",
@@ -14189,56 +14170,68 @@ function createRoot(canvas) {
           "The `primaryCanvas` prop for multi-canvas rendering cannot be used with WebGL. Remove the `gl` prop or use WebGPU."
         );
       }
-      if (wantsGL && !state.internal.actualRenderer) {
-        renderer = await resolveRenderer(glConfig, defaultGLProps, WebGLRenderer);
-        state.internal.actualRenderer = renderer;
-        state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
-      } else if (!wantsGL && primaryCanvas && !state.internal.actualRenderer) {
-        const primary = await waitForPrimary(primaryCanvas);
-        renderer = primary.renderer;
-        state.internal.actualRenderer = renderer;
-        const canvasTarget = new CanvasTarget(canvas);
-        primary.store.setState((prev) => ({
-          internal: { ...prev.internal, isMultiCanvas: true }
-        }));
-        state.set((prev) => ({
-          webGPUSupported: primary.store.getState().webGPUSupported,
-          renderer,
-          primaryStore: primary.store,
-          internal: {
-            ...prev.internal,
-            canvasTarget,
-            isMultiCanvas: true,
-            isSecondary: true,
-            targetId: primaryCanvas
-          }
-        }));
-      } else if (!wantsGL && !state.internal.actualRenderer) {
-        renderer = await resolveRenderer(rendererConfig, defaultGPUProps, WebGPURenderer);
-        if (!renderer.hasInitialized?.()) {
-          const size2 = computeInitialSize(canvas, propsSize);
-          if (size2.width > 0 && size2.height > 0) {
-            const pixelRatio = calculateDpr(dpr);
-            canvas.width = size2.width * pixelRatio;
-            canvas.height = size2.height * pixelRatio;
-          }
-          await renderer.init();
-        }
-        const backend = renderer.backend;
-        const isWebGPUBackend = backend && "isWebGPUBackend" in backend;
-        state.internal.actualRenderer = renderer;
-        state.set({ webGPUSupported: isWebGPUBackend, renderer, primaryStore: store });
-        if (canvasId && !state.internal.isSecondary) {
-          const canvasTarget = new CanvasTarget(canvas);
-          const unregisterPrimary = registerPrimary(canvasId, renderer, store);
-          state.set((prev) => ({
-            internal: {
-              ...prev.internal,
-              canvasTarget,
-              unregisterPrimary
+      if (!state.internal.actualRenderer) {
+        if (!rendererSetup) {
+          rendererSetup = (async () => {
+            if (wantsGL) {
+              renderer = await resolveRenderer(glConfig, defaultGLProps, WebGLRenderer);
+              state.internal.actualRenderer = renderer;
+              state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
+            } else if (!wantsGL && primaryCanvas) {
+              const primary = await waitForPrimary(primaryCanvas);
+              renderer = primary.renderer;
+              state.internal.actualRenderer = renderer;
+              const canvasTarget = new CanvasTarget(canvas);
+              primary.store.setState((prev) => ({
+                internal: { ...prev.internal, isMultiCanvas: true }
+              }));
+              state.set((prev) => ({
+                webGPUSupported: primary.store.getState().webGPUSupported,
+                renderer,
+                primaryStore: primary.store,
+                internal: {
+                  ...prev.internal,
+                  canvasTarget,
+                  isMultiCanvas: true,
+                  isSecondary: true,
+                  targetId: primaryCanvas
+                }
+              }));
+            } else if (!wantsGL) {
+              renderer = await resolveRenderer(rendererConfig, defaultGPUProps, WebGPURenderer);
+              if (!renderer.hasInitialized?.()) {
+                const size2 = computeInitialSize(canvas, propsSize);
+                if (size2.width > 0 && size2.height > 0) {
+                  const pixelRatio = calculateDpr(dpr);
+                  canvas.width = size2.width * pixelRatio;
+                  canvas.height = size2.height * pixelRatio;
+                }
+                await renderer.init();
+              }
+              const backend = renderer.backend;
+              const isWebGPUBackend = backend && "isWebGPUBackend" in backend;
+              state.internal.actualRenderer = renderer;
+              state.set({ webGPUSupported: isWebGPUBackend, renderer, primaryStore: store });
+              if (canvasId && !state.internal.isSecondary) {
+                const canvasTarget = new CanvasTarget(canvas);
+                const unregisterPrimary = registerPrimary(canvasId, renderer, store);
+                state.set((prev) => ({
+                  internal: {
+                    ...prev.internal,
+                    canvasTarget,
+                    unregisterPrimary
+                  }
+                }));
+              }
             }
-          }));
+          })().catch((err) => {
+            rendererSetup = null;
+            throw err;
+          });
         }
+        await rendererSetup;
+        state = store.getState();
+        renderer = state.internal.actualRenderer;
       }
       let raycaster = state.raycaster;
       if (!raycaster) state.set({ raycaster: raycaster = new Raycaster() });
@@ -14588,7 +14581,8 @@ function unmountComponentAtNode(canvas, callback) {
             dispose(state.scene);
             _roots.delete(canvas);
             if (callback) callback(canvas);
-          } catch {
+          } catch (error) {
+            console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
           }
         }, 500);
       }
@@ -14651,6 +14645,7 @@ function PortalInner({ state = {}, children, container }) {
       viewport = rootState.viewport.getCurrentViewport(camera, new Vector3(), resolvedSize);
       if (camera !== rootState.camera) updateCamera(camera, resolvedSize);
     }
+    const set = injectState.set;
     return {
       // The intersect consists of the previous root state
       ...rootState,
@@ -14669,7 +14664,7 @@ function PortalInner({ state = {}, children, container }) {
       size: resolvedSize,
       viewport: { ...rootState.viewport, ...viewport },
       // Layers are allowed to override events
-      setEvents: (events2) => injectState.set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
+      setEvents: (events2) => set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
       // Container for child attachment - the portalScene (injected or container itself)
       internal: { ...rootState.internal, ...injectState.internal, container: portalScene }
     };
@@ -14698,6 +14693,212 @@ function flushSync(fn) {
   return reconciler.flushSyncFromReconciler(fn);
 }
 
+const isRef = (obj) => obj.current && obj.current.isScene;
+const resolveScene = (scene) => isRef(scene) ? scene.current : scene;
+function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
+  sceneProps = {
+    backgroundBlurriness: 0,
+    backgroundIntensity: 1,
+    backgroundRotation: [0, 0, 0],
+    environmentIntensity: 1,
+    environmentRotation: [0, 0, 0],
+    ...sceneProps
+  };
+  const target = resolveScene(scene || defaultScene);
+  const oldbg = target.background;
+  const oldenv = target.environment;
+  const oldSceneProps = {
+    // @ts-ignore
+    backgroundBlurriness: target.backgroundBlurriness,
+    // @ts-ignore
+    backgroundIntensity: target.backgroundIntensity,
+    // @ts-ignore
+    backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
+    // @ts-ignore
+    environmentIntensity: target.environmentIntensity,
+    // @ts-ignore
+    environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0]
+  };
+  if (background !== "only") target.environment = texture;
+  if (background) target.background = texture;
+  applyProps(target, sceneProps);
+  return () => {
+    if (background !== "only") target.environment = oldenv;
+    if (background) target.background = oldbg;
+    applyProps(target, oldSceneProps);
+  };
+}
+function EnvironmentMap({ scene, background = false, map, ...config }) {
+  const defaultScene = useThree((state) => state.scene);
+  React.useLayoutEffect(() => {
+    if (map) return setEnvProps(background, scene, defaultScene, map, config);
+  });
+  return null;
+}
+function EnvironmentCube({
+  background = false,
+  scene,
+  blur,
+  backgroundBlurriness,
+  backgroundIntensity,
+  backgroundRotation,
+  environmentIntensity,
+  environmentRotation,
+  ...rest
+}) {
+  const texture = useEnvironment(rest);
+  const defaultScene = useThree((state) => state.scene);
+  React.useLayoutEffect(() => {
+    return setEnvProps(background, scene, defaultScene, texture, {
+      backgroundBlurriness: blur ?? backgroundBlurriness,
+      backgroundIntensity,
+      backgroundRotation,
+      environmentIntensity,
+      environmentRotation
+    });
+  });
+  React.useEffect(() => {
+    return () => {
+      texture.dispose();
+    };
+  }, [texture]);
+  return null;
+}
+function EnvironmentPortal({
+  children,
+  near = 0.1,
+  far = 1e3,
+  resolution = 256,
+  frames = 1,
+  map,
+  background = false,
+  blur,
+  backgroundBlurriness,
+  backgroundIntensity,
+  backgroundRotation,
+  environmentIntensity,
+  environmentRotation,
+  scene,
+  files,
+  path,
+  preset = void 0,
+  extensions
+}) {
+  const renderer = useThree((state) => state.renderer);
+  const isLegacy = useThree((state) => state.isLegacy);
+  const defaultScene = useThree((state) => state.scene);
+  const camera = React.useRef(null);
+  const [virtualScene] = React.useState(() => new Scene());
+  const fbo = React.useMemo(() => {
+    const fbo2 = isLegacy ? new WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
+    fbo2.texture.type = HalfFloatType;
+    return fbo2;
+  }, [resolution, isLegacy]);
+  React.useEffect(() => {
+    return () => {
+      fbo.dispose();
+    };
+  }, [fbo]);
+  React.useLayoutEffect(() => {
+    if (frames === 1) {
+      const autoClear = renderer.autoClear;
+      renderer.autoClear = true;
+      camera.current.update(renderer, virtualScene);
+      renderer.autoClear = autoClear;
+    }
+    return setEnvProps(background, scene, defaultScene, fbo.texture, {
+      backgroundBlurriness: blur ?? backgroundBlurriness,
+      backgroundIntensity,
+      backgroundRotation,
+      environmentIntensity,
+      environmentRotation
+    });
+  }, [
+    children,
+    virtualScene,
+    fbo.texture,
+    scene,
+    defaultScene,
+    background,
+    frames,
+    renderer,
+    blur,
+    backgroundBlurriness,
+    backgroundIntensity,
+    backgroundRotation,
+    environmentIntensity,
+    environmentRotation
+  ]);
+  let count = 1;
+  useFrame(() => {
+    if (frames === Infinity || count < frames) {
+      const autoClear = renderer.autoClear;
+      renderer.autoClear = true;
+      camera.current.update(renderer, virtualScene);
+      renderer.autoClear = autoClear;
+      count++;
+    }
+  });
+  return /* @__PURE__ */ jsx(Fragment, { children: createPortal(
+    /* @__PURE__ */ jsxs(Fragment, { children: [
+      children,
+      /* @__PURE__ */ jsx("cubeCamera", { ref: camera, args: [near, far, fbo] }),
+      files || preset ? /* @__PURE__ */ jsx(EnvironmentCube, { background: true, files, preset, path, extensions }) : map ? /* @__PURE__ */ jsx(EnvironmentMap, { background: true, map, extensions }) : null
+    ] }),
+    virtualScene
+  ) });
+}
+function EnvironmentGround(props) {
+  const textureDefault = useEnvironment(props);
+  const texture = props.map || textureDefault;
+  React.useMemo(() => extend({ GroundProjectedEnvImpl: GroundedSkybox }), []);
+  React.useEffect(() => {
+    return () => {
+      textureDefault.dispose();
+    };
+  }, [textureDefault]);
+  const height = props.ground?.height ?? 15;
+  const radius = props.ground?.radius ?? 60;
+  const scale = props.ground?.scale ?? 1e3;
+  const args = React.useMemo(
+    () => [texture, height, radius],
+    [texture, height, radius]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(EnvironmentMap, { ...props, map: texture }),
+    /* @__PURE__ */ jsx("groundProjectedEnvImpl", { args, scale })
+  ] });
+}
+function EnvironmentColor({ color, scene }) {
+  const defaultScene = useThree((state) => state.scene);
+  React.useLayoutEffect(() => {
+    if (color === void 0) return;
+    const target = resolveScene(scene || defaultScene);
+    const oldBg = target.background;
+    target.background = new Color(color);
+    return () => {
+      target.background = oldBg;
+    };
+  });
+  return null;
+}
+function EnvironmentDualSource(props) {
+  const { backgroundFiles, ...envProps } = props;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(EnvironmentCube, { ...envProps, background: false }),
+    /* @__PURE__ */ jsx(EnvironmentCube, { ...props, files: backgroundFiles, background: "only" })
+  ] });
+}
+function Environment(props) {
+  if (props.color && !props.files && !props.preset && !props.map) {
+    return /* @__PURE__ */ jsx(EnvironmentColor, { ...props });
+  }
+  if (props.backgroundFiles && props.backgroundFiles !== props.files) {
+    return /* @__PURE__ */ jsx(EnvironmentDualSource, { ...props });
+  }
+  return props.ground ? /* @__PURE__ */ jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsx(EnvironmentCube, { ...props });
+}
+
 function parseBackground(background) {
   if (!background) return null;
   if (typeof background === "object" && !background.isColor) {
@@ -14728,14 +14929,49 @@ function parseBackground(background) {
   return null;
 }
 
+function parseRendererConfig(rendererProp) {
+  const isRendererConfig = typeof rendererProp === "object" && rendererProp !== null && !("render" in rendererProp) && ("primaryCanvas" in rendererProp || "scheduler" in rendererProp);
+  if (isRendererConfig) {
+    const { primaryCanvas: pc, scheduler: sc, ...rest } = rendererProp;
+    return {
+      primaryCanvas: pc,
+      scheduler: sc,
+      renderer: Object.keys(rest).length > 0 ? rest : rendererProp
+    };
+  }
+  return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
+}
+
+const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
+const registries = /* @__PURE__ */ new WeakMap();
+function getKindRegistry(store, kind) {
+  let registry = registries.get(store);
+  if (!registry) {
+    registry = {
+      nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
+      uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
+      buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
+      gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
+    };
+    registries.set(store, registry);
+  }
+  return registry[kind];
+}
+function invalidateResource(store, kind, scopeKey) {
+  const registry = getKindRegistry(store, kind);
+  {
+    registry.valid.clear();
+    registry.staged.clear();
+  }
+}
+function invalidateAllResources(store) {
+  for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
+}
+
 function clearHmrCaches(store) {
-  store.setState((state) => ({
-    nodes: {},
-    uniforms: {},
-    buffers: {},
-    gpuStorage: {},
-    _hmrVersion: state._hmrVersion + 1
-  }));
+  const primary = store.getState().primaryStore ?? store;
+  invalidateAllResources(primary);
+  primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
 }
 
 function CanvasImpl({
@@ -14771,18 +15007,7 @@ function CanvasImpl({
   forceEven,
   ...props
 }) {
-  const isRendererConfig = typeof rendererProp === "object" && rendererProp !== null && !("render" in rendererProp) && ("primaryCanvas" in rendererProp || "scheduler" in rendererProp);
-  let primaryCanvas;
-  let scheduler;
-  let renderer;
-  if (isRendererConfig) {
-    const { primaryCanvas: pc, scheduler: sc, ...rest } = rendererProp;
-    primaryCanvas = pc;
-    scheduler = sc;
-    renderer = Object.keys(rest).length > 0 ? rest : rendererProp;
-  } else {
-    renderer = rendererProp;
-  }
+  const { primaryCanvas, scheduler, renderer } = parseRendererConfig(rendererProp);
   React.useMemo(() => extend(THREE), []);
   const Bridge = useBridge();
   const backgroundProps = React.useMemo(() => parseBackground(background), [background]);
@@ -14827,6 +15052,7 @@ function CanvasImpl({
   const handleDropMissed = useMutableCallback(onDropMissed);
   const [block, setBlock] = React.useState(false);
   const [error, setError] = React.useState(false);
+  const [fallbackVisible, setFallbackVisible] = React.useState(false);
   if (block) throw block;
   if (error) throw error;
   const root = React.useRef(null);
@@ -14834,6 +15060,7 @@ function CanvasImpl({
   const unsubscribeErrorRef = React.useRef(null);
   useIsomorphicLayoutEffect(() => {
     effectActiveRef.current = true;
+    if (fallbackVisible) return;
     const canvas = canvasRef.current;
     if (effectiveSize.width > 0 && effectiveSize.height > 0 && canvas) {
       if (!root.current) {
@@ -14854,7 +15081,7 @@ function CanvasImpl({
       }
       async function run() {
         if (!effectActiveRef.current || !root.current) return;
-        await root.current.configure({
+        const configured = await root.current.configure({
           id,
           primaryCanvas,
           scheduler,
@@ -14881,7 +15108,7 @@ function CanvasImpl({
           onDropMissed: (...args) => handleDropMissed.current?.(...args),
           onCreated: (state) => {
             state.events.connect?.(
-              eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current
+              eventSource ? isRef$1(eventSource) ? eventSource.current : eventSource : divRef.current
             );
             if (eventPrefix) {
               state.setEvents({
@@ -14895,8 +15122,20 @@ function CanvasImpl({
             }
             onCreated?.(state);
           }
-        });
-        if (!effectActiveRef.current || !root.current) return;
+        }).then(
+          () => true,
+          // Renderer setup failed (e.g. no WebGL/WebGPU support). The `fallback` prop lives
+          // inside <canvas>, which browsers don't display, so surface it as visible DOM
+          // instead; with no fallback, rethrow to an external error boundary. (#3757)
+          (setupError) => {
+            if (effectActiveRef.current) {
+              if (fallback != null) setFallbackVisible(true);
+              else setError(setupError);
+            }
+            return false;
+          }
+        );
+        if (!configured || !effectActiveRef.current || !root.current) return;
         root.current.render(
           /* @__PURE__ */ jsx(Bridge, { children: /* @__PURE__ */ jsx(ErrorBoundary, { set: setError, children: /* @__PURE__ */ jsxs(React.Suspense, { fallback: /* @__PURE__ */ jsx(Block, { set: setBlock }), children: [
             backgroundProps && /* @__PURE__ */ jsx(Environment, { ...backgroundProps }),
@@ -14959,7 +15198,11 @@ function CanvasImpl({
         ...style
       },
       ...props,
-      children: /* @__PURE__ */ jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx(
+      children: fallbackVisible ? (
+        // Renderer setup failed: render the fallback as visible DOM. Inside <canvas> (below)
+        // it exists in the tree but browsers never paint it, which is the whole bug (#3757).
+        fallback
+      ) : /* @__PURE__ */ jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx(
         "canvas",
         {
           ref: canvasRef,
@@ -14978,4 +15221,4 @@ function Canvas(props) {
 
 extend(THREE);
 
-export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
+export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef$1 as isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };