@react-three/fiber 10.0.0-canary.5c62eb9 → 10.0.0-canary.6d6e5ab

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/legacy.cjs CHANGED
@@ -62,9 +62,12 @@ const WebGPURenderer = class WebGPURenderer2 {
62
62
  }
63
63
  };
64
64
  const RenderTarget = null;
65
+ const CubeRenderTarget = null;
65
66
 
66
67
  const THREE = /*#__PURE__*/_mergeNamespaces({
67
68
  __proto__: null,
69
+ CubeRenderTarget: CubeRenderTarget,
70
+ CubeRenderTargetCompat: three.WebGLCubeRenderTarget,
68
71
  Inspector: Inspector,
69
72
  R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
70
73
  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
@@ -342,15 +345,16 @@ function EnvironmentPortal({
342
345
  preset = void 0,
343
346
  extensions
344
347
  }) {
345
- const gl = fiber.useThree((state) => state.gl);
348
+ const renderer = fiber.useThree((state) => state.renderer);
349
+ const isLegacy = fiber.useThree((state) => state.isLegacy);
346
350
  const defaultScene = fiber.useThree((state) => state.scene);
347
351
  const camera = React__namespace.useRef(null);
348
352
  const [virtualScene] = React__namespace.useState(() => new three.Scene());
349
353
  const fbo = React__namespace.useMemo(() => {
350
- const fbo2 = new three.WebGLCubeRenderTarget(resolution);
354
+ const fbo2 = isLegacy ? new three.WebGLCubeRenderTarget(resolution) : new CubeRenderTarget(resolution);
351
355
  fbo2.texture.type = three.HalfFloatType;
352
356
  return fbo2;
353
- }, [resolution]);
357
+ }, [resolution, isLegacy]);
354
358
  React__namespace.useEffect(() => {
355
359
  return () => {
356
360
  fbo.dispose();
@@ -358,10 +362,10 @@ function EnvironmentPortal({
358
362
  }, [fbo]);
359
363
  React__namespace.useLayoutEffect(() => {
360
364
  if (frames === 1) {
361
- const autoClear = gl.autoClear;
362
- gl.autoClear = true;
363
- camera.current.update(gl, virtualScene);
364
- gl.autoClear = autoClear;
365
+ const autoClear = renderer.autoClear;
366
+ renderer.autoClear = true;
367
+ camera.current.update(renderer, virtualScene);
368
+ renderer.autoClear = autoClear;
365
369
  }
366
370
  return setEnvProps(background, scene, defaultScene, fbo.texture, {
367
371
  backgroundBlurriness: blur ?? backgroundBlurriness,
@@ -378,7 +382,7 @@ function EnvironmentPortal({
378
382
  defaultScene,
379
383
  background,
380
384
  frames,
381
- gl,
385
+ renderer,
382
386
  blur,
383
387
  backgroundBlurriness,
384
388
  backgroundIntensity,
@@ -389,10 +393,10 @@ function EnvironmentPortal({
389
393
  let count = 1;
390
394
  fiber.useFrame(() => {
391
395
  if (frames === Infinity || count < frames) {
392
- const autoClear = gl.autoClear;
393
- gl.autoClear = true;
394
- camera.current.update(gl, virtualScene);
395
- gl.autoClear = autoClear;
396
+ const autoClear = renderer.autoClear;
397
+ renderer.autoClear = true;
398
+ camera.current.update(renderer, virtualScene);
399
+ renderer.autoClear = autoClear;
396
400
  count++;
397
401
  }
398
402
  });
@@ -459,7 +463,6 @@ function Environment(props) {
459
463
  var __defProp = Object.defineProperty;
460
464
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
461
465
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
462
- const act = React__namespace["act"];
463
466
  const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React__namespace.useLayoutEffect : React__namespace.useEffect;
464
467
  function useMutableCallback(fn) {
465
468
  const ref = React__namespace.useRef(fn);
@@ -635,8 +638,7 @@ function prepare(target, root, type, props) {
635
638
  object,
636
639
  eventCount: 0,
637
640
  handlers: {},
638
- isHidden: false,
639
- deferredRefs: []
641
+ isHidden: false
640
642
  };
641
643
  if (object) object.__r3f = instance;
642
644
  }
@@ -793,6 +795,17 @@ function unregisterVisibility(store, object) {
793
795
  internal.visibilityRegistry.delete(object.uuid);
794
796
  internal.occlusionCache.delete(object);
795
797
  }
798
+ function updateVisibilityHandlers(store, object, handlers) {
799
+ const { internal } = store.getState();
800
+ const entry = internal.visibilityRegistry.get(object.uuid);
801
+ if (!entry) return false;
802
+ entry.handlers = handlers;
803
+ if ((handlers.onOccluded || handlers.onVisible) && !internal.occlusionEnabled) {
804
+ object.occlusionTest = true;
805
+ enableOcclusion(store);
806
+ }
807
+ return true;
808
+ }
796
809
  function checkVisibility(state) {
797
810
  const { internal, camera } = state;
798
811
  const registry = internal.visibilityRegistry;
@@ -953,9 +966,9 @@ function diffProps(instance, newProps) {
953
966
  const { root, key } = resolve(instance.object, prop);
954
967
  if (root.constructor && root.constructor.length === 0) {
955
968
  const ctor = getMemoizedPrototype(root);
956
- if (!is.und(ctor)) changedProps[key] = ctor[key];
969
+ if (!is.und(ctor)) changedProps[prop] = ctor[key];
957
970
  } else {
958
- changedProps[key] = 0;
971
+ changedProps[prop] = 0;
959
972
  }
960
973
  }
961
974
  return changedProps;
@@ -980,10 +993,7 @@ function applyProps(object, props) {
980
993
  continue;
981
994
  }
982
995
  if (value === void 0) continue;
983
- if (isFromRef(value)) {
984
- instance?.deferredRefs?.push({ prop, ref: value[FROM_REF] });
985
- continue;
986
- }
996
+ if (isFromRef(value)) continue;
987
997
  if (isOnce(value)) {
988
998
  if (instance?.appliedOnce?.has(prop)) continue;
989
999
  if (instance) {
@@ -1019,6 +1029,19 @@ function applyProps(object, props) {
1019
1029
  } else if (isVectorLike(target) && is.num(value)) {
1020
1030
  if ("setScalar" in target && typeof target.setScalar === "function") target.setScalar(value);
1021
1031
  else target.set(value);
1032
+ } else if (root instanceof three.ShaderMaterial && key === "uniforms" && is.obj(value)) {
1033
+ if (!is.obj(root.uniforms)) root.uniforms = {};
1034
+ const uniforms = root.uniforms;
1035
+ const nextUniforms = value;
1036
+ for (const name in nextUniforms) {
1037
+ const uniform = nextUniforms[name];
1038
+ const targetUniform = uniforms[name];
1039
+ if (targetUniform) Object.assign(targetUniform, uniform);
1040
+ else {
1041
+ const nextUniform = uniform instanceof three.Uniform ? uniform.clone() : new three.Uniform(uniform.value);
1042
+ uniforms[name] = nextUniform;
1043
+ }
1044
+ }
1022
1045
  } else {
1023
1046
  root[key] = value;
1024
1047
  if (key.endsWith("Node") && root.isMaterial) {
@@ -1037,6 +1060,9 @@ function applyProps(object, props) {
1037
1060
  if (instance.eventCount && object2.raycast !== null) {
1038
1061
  rootState.internal.interaction.push(object2);
1039
1062
  }
1063
+ }
1064
+ if (instance?.parent && rootState?.internal && instance.object?.isObject3D) {
1065
+ const object2 = instance.object;
1040
1066
  const root = findInitialRoot(instance);
1041
1067
  const visibilityHandlers = {
1042
1068
  onFramed: instance.handlers.onFramed,
@@ -1044,7 +1070,9 @@ function applyProps(object, props) {
1044
1070
  onVisible: instance.handlers.onVisible
1045
1071
  };
1046
1072
  if (hasVisibilityHandlers(visibilityHandlers)) {
1047
- registerVisibility(root, object2, visibilityHandlers);
1073
+ if (!updateVisibilityHandlers(root, object2, visibilityHandlers)) {
1074
+ registerVisibility(root, object2, visibilityHandlers);
1075
+ }
1048
1076
  } else {
1049
1077
  unregisterVisibility(root, object2);
1050
1078
  }
@@ -1572,6 +1600,7 @@ function createPointerEvents(store) {
1572
1600
  set((state) => ({ events: { ...state.events, connected: void 0 } }));
1573
1601
  }
1574
1602
  },
1603
+ // PREVIEW (A8): the XR pointer registration API may change before stable.
1575
1604
  registerPointer: (config) => {
1576
1605
  const pointerId = nextXRPointerId++;
1577
1606
  xrPointers.set(pointerId, config);
@@ -1659,11 +1688,10 @@ function notifyAlpha({ message, link }) {
1659
1688
  }
1660
1689
 
1661
1690
  const INTERNAL_LIB_MARKERS = ["zustand", "setState", "Object.assign"];
1662
- const INTERNAL_FIBER_MARKERS = ["packages/fiber/src", "packages/fiber/dist", "@react-three/fiber", "@react-three_fiber"];
1663
1691
  function isInternalRendererAccess(stack, callerDepth = 2) {
1664
1692
  if (!stack) return false;
1665
1693
  const caller = stack.split("\n")[callerDepth] ?? "";
1666
- return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m)) || INTERNAL_FIBER_MARKERS.some((m) => caller.includes(m));
1694
+ return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
1667
1695
  }
1668
1696
 
1669
1697
  const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
@@ -1798,6 +1826,7 @@ const createStore = (invalidate, advance) => {
1798
1826
  }),
1799
1827
  setFrameloop: (frameloop = "always") => {
1800
1828
  set(() => ({ frameloop }));
1829
+ scheduler.getScheduler().frameloop = frameloop;
1801
1830
  },
1802
1831
  setError: (error) => set(() => ({ error })),
1803
1832
  error: null,
@@ -1978,19 +2007,25 @@ function loadingFn(extensions, onProgress) {
1978
2007
  );
1979
2008
  };
1980
2009
  }
1981
- function useLoader(loader, input, extensions, onProgress) {
1982
- const keys = Array.isArray(input) ? input : [input];
2010
+ function useLoader(loader, input, extensions, onProgress, cacheKey) {
2011
+ const inputs = Array.isArray(input) ? input : [input];
2012
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
1983
2013
  const fn = loadingFn(extensions, onProgress);
1984
- const results = keys.map((key) => suspendReact.suspend(fn, [loader, key], { equal: is.equ }));
2014
+ const results = cacheKeys.map(
2015
+ (key, index) => suspendReact.suspend(() => fn(loader, inputs[index]), [loader, key], { equal: is.equ })
2016
+ );
1985
2017
  return Array.isArray(input) ? results : results[0];
1986
2018
  }
1987
- useLoader.preload = function(loader, input, extensions, onProgress) {
1988
- const keys = Array.isArray(input) ? input : [input];
1989
- keys.forEach((key) => suspendReact.preload(loadingFn(extensions, onProgress), [loader, key]));
2019
+ useLoader.preload = function(loader, input, extensions, onProgress, cacheKey) {
2020
+ const inputs = Array.isArray(input) ? input : [input];
2021
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
2022
+ cacheKeys.forEach(
2023
+ (key, index) => suspendReact.preload(() => loadingFn(extensions, onProgress)(loader, inputs[index]), [loader, key])
2024
+ );
1990
2025
  };
1991
- useLoader.clear = function(loader, input) {
1992
- const keys = Array.isArray(input) ? input : [input];
1993
- keys.forEach((key) => suspendReact.clear([loader, key]));
2026
+ useLoader.clear = function(loader, input, cacheKey) {
2027
+ const cacheKeys = Array.isArray(cacheKey ?? input) ? cacheKey ?? input : [cacheKey ?? input];
2028
+ cacheKeys.forEach((key) => suspendReact.clear([loader, key]));
1994
2029
  };
1995
2030
  useLoader.loader = getLoader;
1996
2031
 
@@ -2410,7 +2445,7 @@ function advance(timestamp) {
2410
2445
  scheduler.getScheduler().step(timestamp);
2411
2446
  }
2412
2447
 
2413
- const version = "10.0.0-alpha.2";
2448
+ const version = "10.0.0-alpha.3";
2414
2449
  const packageData = {
2415
2450
  version: version};
2416
2451
 
@@ -13666,7 +13701,7 @@ function n0() {
13666
13701
  var t0 = n0();
13667
13702
  const r0 = Xb(t0);
13668
13703
 
13669
- const t = 1, o = 8, r = 32, e = 2;
13704
+ const t = 1, o = 8, r = 32, e = 2, i$1 = 268435456;
13670
13705
 
13671
13706
  function createReconciler(config) {
13672
13707
  const reconciler2 = r0(config);
@@ -13831,7 +13866,15 @@ function setFiberRef(fiber, publicInstance) {
13831
13866
  }
13832
13867
  }
13833
13868
  const reconstructed = [];
13834
- function swapInstances() {
13869
+ function flushReconstructedInstances() {
13870
+ if (reconstructed.length === 0) return;
13871
+ try {
13872
+ swapReconstructedInstances();
13873
+ } finally {
13874
+ reconstructed.length = 0;
13875
+ }
13876
+ }
13877
+ function swapReconstructedInstances() {
13835
13878
  for (const [instance] of reconstructed) {
13836
13879
  const parent = instance.parent;
13837
13880
  if (parent) {
@@ -13849,6 +13892,7 @@ function swapInstances() {
13849
13892
  }
13850
13893
  }
13851
13894
  if (instance.isHidden) unhideInstance(instance);
13895
+ if (isObject3D(instance.object)) removeInteractivity(findInitialRoot(instance), instance.object);
13852
13896
  if (instance.object.__r3f) delete instance.object.__r3f;
13853
13897
  if (instance.type !== "primitive") disposeOnIdle(instance.object);
13854
13898
  }
@@ -13861,6 +13905,8 @@ function swapInstances() {
13861
13905
  instance.object.__r3f = instance;
13862
13906
  setFiberRef(fiber, instance.object);
13863
13907
  delete instance.appliedOnce;
13908
+ instance.eventCount = 0;
13909
+ instance.handlers = {};
13864
13910
  applyProps(instance.object, instance.props);
13865
13911
  if (instance.props.attach) {
13866
13912
  attach(parent, instance);
@@ -13877,14 +13923,114 @@ function swapInstances() {
13877
13923
  invalidateInstance(instance);
13878
13924
  }
13879
13925
  }
13880
- reconstructed.length = 0;
13881
13926
  }
13882
13927
  const handleTextInstance = () => {
13883
13928
  };
13884
13929
  const NO_CONTEXT = {};
13885
13930
  let currentUpdatePriority = NoEventPriority;
13886
- const NoFlags = 0;
13887
- const Update = 4;
13931
+ function getEventPriority(type) {
13932
+ switch (type) {
13933
+ case "beforetoggle":
13934
+ case "cancel":
13935
+ case "click":
13936
+ case "close":
13937
+ case "contextmenu":
13938
+ case "copy":
13939
+ case "cut":
13940
+ case "auxclick":
13941
+ case "dblclick":
13942
+ case "dragend":
13943
+ case "dragstart":
13944
+ case "drop":
13945
+ case "focusin":
13946
+ case "focusout":
13947
+ case "input":
13948
+ case "invalid":
13949
+ case "keydown":
13950
+ case "keypress":
13951
+ case "keyup":
13952
+ case "mousedown":
13953
+ case "mouseup":
13954
+ case "paste":
13955
+ case "pause":
13956
+ case "play":
13957
+ case "pointercancel":
13958
+ case "pointerdown":
13959
+ case "pointerup":
13960
+ case "ratechange":
13961
+ case "reset":
13962
+ case "resize":
13963
+ case "seeked":
13964
+ case "submit":
13965
+ case "touchcancel":
13966
+ case "touchend":
13967
+ case "touchstart":
13968
+ case "volumechange":
13969
+ case "change":
13970
+ case "selectionchange":
13971
+ case "compositionstart":
13972
+ case "compositionend":
13973
+ case "compositionupdate":
13974
+ case "beforeinput":
13975
+ case "blur":
13976
+ case "fullscreenchange":
13977
+ case "focus":
13978
+ case "hashchange":
13979
+ case "popstate":
13980
+ case "select":
13981
+ case "selectstart":
13982
+ return e;
13983
+ case "drag":
13984
+ case "dragenter":
13985
+ case "dragexit":
13986
+ case "dragleave":
13987
+ case "dragover":
13988
+ case "mousemove":
13989
+ case "mouseout":
13990
+ case "mouseover":
13991
+ case "pointermove":
13992
+ case "pointerout":
13993
+ case "pointerover":
13994
+ case "scroll":
13995
+ case "touchmove":
13996
+ case "wheel":
13997
+ case "mouseenter":
13998
+ case "mouseleave":
13999
+ case "pointerenter":
14000
+ case "pointerleave":
14001
+ return o;
14002
+ case "message": {
14003
+ switch (Tb.unstable_getCurrentPriorityLevel()) {
14004
+ case Tb.unstable_ImmediatePriority:
14005
+ return e;
14006
+ case Tb.unstable_UserBlockingPriority:
14007
+ return o;
14008
+ case Tb.unstable_NormalPriority:
14009
+ case Tb.unstable_LowPriority:
14010
+ return r;
14011
+ case Tb.unstable_IdlePriority:
14012
+ return i$1;
14013
+ default:
14014
+ return r;
14015
+ }
14016
+ }
14017
+ default:
14018
+ return r;
14019
+ }
14020
+ }
14021
+ function scheduleMicrotask(callback) {
14022
+ if (typeof queueMicrotask === "function") {
14023
+ queueMicrotask(callback);
14024
+ } else if (typeof Promise !== "undefined") {
14025
+ Promise.resolve().then(callback).catch((error) => {
14026
+ setTimeout(() => {
14027
+ throw error;
14028
+ });
14029
+ });
14030
+ } else {
14031
+ setTimeout(callback);
14032
+ }
14033
+ }
13888
14034
  const reconciler = /* @__PURE__ */ createReconciler({
13889
14035
  isPrimaryRenderer: false,
13890
14036
  warnsIfNotActing: false,
@@ -13923,16 +14069,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
13923
14069
  else if (newProps.args?.length !== oldProps.args?.length) reconstruct = true;
13924
14070
  else if (newProps.args?.some((value, index) => value !== oldProps.args?.[index])) reconstruct = true;
13925
14071
  if (reconstruct) {
13926
- reconstructed.push([instance, { ...newProps }, fiber]);
14072
+ reconstructed.push([instance, getInstanceProps(newProps), fiber]);
13927
14073
  } else {
13928
14074
  const changedProps = diffProps(instance, newProps);
13929
- if (Object.keys(changedProps).length) {
13930
- Object.assign(instance.props, changedProps);
13931
- applyProps(instance.object, changedProps);
13932
- }
14075
+ const attach2 = instance.props.attach;
14076
+ instance.props = getInstanceProps(newProps);
14077
+ if (attach2 !== void 0) instance.props.attach = attach2;
14078
+ else delete instance.props.attach;
14079
+ if (Object.keys(changedProps).length) applyProps(instance.object, changedProps);
13933
14080
  }
13934
- const isTailSibling = fiber.sibling === null || (fiber.flags & Update) === NoFlags;
13935
- if (isTailSibling) swapInstances();
13936
14081
  },
13937
14082
  finalizeInitialChildren: (instance) => {
13938
14083
  for (const prop in instance.props) {
@@ -13957,8 +14102,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13957
14102
  const target = container.getState().internal.container ?? container.getState().scene;
13958
14103
  return prepare(target, container, "", {});
13959
14104
  },
13960
- resetAfterCommit: () => {
13961
- },
14105
+ // Reconstructed instances are swapped once all mutations are committed,
14106
+ // before layout effects run so refs point to the new objects
14107
+ resetAfterCommit: flushReconstructedInstances,
13962
14108
  shouldSetTextContent: () => false,
13963
14109
  clearContainer: () => false,
13964
14110
  hideInstance,
@@ -13966,6 +14112,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
13966
14112
  createTextInstance: handleTextInstance,
13967
14113
  hideTextInstance: handleTextInstance,
13968
14114
  unhideTextInstance: handleTextInstance,
14115
+ // Mirrors react-dom, which flushes discrete work in microtasks
14116
+ supportsMicrotasks: true,
14117
+ scheduleMicrotask,
13969
14118
  scheduleTimeout: typeof setTimeout === "function" ? setTimeout : void 0,
13970
14119
  cancelTimeout: typeof clearTimeout === "function" ? clearTimeout : void 0,
13971
14120
  noTimeout: -1,
@@ -14006,28 +14155,9 @@ const reconciler = /* @__PURE__ */ createReconciler({
14006
14155
  },
14007
14156
  resolveUpdatePriority() {
14008
14157
  if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
14009
- switch (typeof window !== "undefined" && window.event?.type) {
14010
- case "click":
14011
- case "contextmenu":
14012
- case "dblclick":
14013
- case "dragenter":
14014
- case "dragleave":
14015
- case "drop":
14016
- case "pointercancel":
14017
- case "pointerdown":
14018
- case "pointerup":
14019
- return e;
14020
- case "dragover":
14021
- case "pointermove":
14022
- case "pointerout":
14023
- case "pointerover":
14024
- case "pointerenter":
14025
- case "pointerleave":
14026
- case "wheel":
14027
- return o;
14028
- default:
14029
- return r;
14030
- }
14158
+ const eventType = typeof window !== "undefined" ? window.event?.type : void 0;
14159
+ if (eventType === void 0) return r;
14160
+ return getEventPriority(eventType);
14031
14161
  },
14032
14162
  resetFormInstance() {
14033
14163
  },
@@ -14076,11 +14206,15 @@ const reconciler = /* @__PURE__ */ createReconciler({
14076
14206
  cloneMutableTextInstance(textInstance) {
14077
14207
  return textInstance;
14078
14208
  },
14209
+ // React 19.2 added these for root-level view transitions. They only run for hosts that opt into
14210
+ // view transitions by returning a container from cloneRootViewTransitionContainer; R3F renders
14211
+ // into a WebGL/WebGPU canvas, where cloning the root has no meaning, so we never opt in and
14212
+ // React never calls them. They stay as no-ops rather than throws: the host config is shared by
14213
+ // every root, and a throw here would turn a React-internal probe into a hard crash for users.
14214
+ // Guarded by a test asserting a full render + unmount never reaches them.
14079
14215
  cloneRootViewTransitionContainer(_rootContainer) {
14080
- throw new Error("Not implemented.");
14081
14216
  },
14082
14217
  removeRootViewTransitionClone(_rootContainer, _clone) {
14083
- throw new Error("Not implemented.");
14084
14218
  },
14085
14219
  // https://github.com/facebook/react/pull/32465
14086
14220
  createFragmentInstance: (_fiber) => null,
@@ -14165,6 +14299,7 @@ function createRoot(canvas) {
14165
14299
  const lastConfiguredProps = {};
14166
14300
  let configured = false;
14167
14301
  let pending = null;
14302
+ let rendererSetup = null;
14168
14303
  return {
14169
14304
  async configure(props = {}) {
14170
14305
  let resolve;
@@ -14195,7 +14330,7 @@ function createRoot(canvas) {
14195
14330
  forceEven
14196
14331
  } = props;
14197
14332
  const textureColorSpace = is.obj(glConfig) && !is.fun(glConfig) && !isRenderer(glConfig) && glConfig.textureColorSpace || is.obj(rendererConfig) && !is.fun(rendererConfig) && !isRenderer(rendererConfig) && rendererConfig.textureColorSpace || three.SRGBColorSpace;
14198
- const state = store.getState();
14333
+ let state = store.getState();
14199
14334
  const defaultGLProps = {
14200
14335
  canvas,
14201
14336
  powerPreference: "high-performance",
@@ -14223,9 +14358,21 @@ function createRoot(canvas) {
14223
14358
  );
14224
14359
  }
14225
14360
  if (!state.internal.actualRenderer) {
14226
- renderer = await resolveRenderer(glConfig, defaultGLProps, three.WebGLRenderer);
14227
- state.internal.actualRenderer = renderer;
14228
- state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
14361
+ if (!rendererSetup) {
14362
+ rendererSetup = (async () => {
14363
+ {
14364
+ renderer = await resolveRenderer(glConfig, defaultGLProps, three.WebGLRenderer);
14365
+ state.internal.actualRenderer = renderer;
14366
+ state.set({ isLegacy: true, gl: renderer, renderer, primaryStore: store });
14367
+ }
14368
+ })().catch((err) => {
14369
+ rendererSetup = null;
14370
+ throw err;
14371
+ });
14372
+ }
14373
+ await rendererSetup;
14374
+ state = store.getState();
14375
+ renderer = state.internal.actualRenderer;
14229
14376
  }
14230
14377
  let raycaster = state.raycaster;
14231
14378
  if (!raycaster) state.set({ raycaster: raycaster = new three.Raycaster() });
@@ -14575,7 +14722,8 @@ function unmountComponentAtNode(canvas, callback) {
14575
14722
  dispose(state.scene);
14576
14723
  _roots.delete(canvas);
14577
14724
  if (callback) callback(canvas);
14578
- } catch {
14725
+ } catch (error) {
14726
+ console.warn("[R3F] Error while unmounting root; teardown may be incomplete:", error);
14579
14727
  }
14580
14728
  }, 500);
14581
14729
  }
@@ -14638,6 +14786,7 @@ function PortalInner({ state = {}, children, container }) {
14638
14786
  viewport = rootState.viewport.getCurrentViewport(camera, new three.Vector3(), resolvedSize);
14639
14787
  if (camera !== rootState.camera) updateCamera(camera, resolvedSize);
14640
14788
  }
14789
+ const set = injectState.set;
14641
14790
  return {
14642
14791
  // The intersect consists of the previous root state
14643
14792
  ...rootState,
@@ -14656,7 +14805,7 @@ function PortalInner({ state = {}, children, container }) {
14656
14805
  size: resolvedSize,
14657
14806
  viewport: { ...rootState.viewport, ...viewport },
14658
14807
  // Layers are allowed to override events
14659
- setEvents: (events2) => injectState.set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
14808
+ setEvents: (events2) => set((state2) => ({ ...state2, events: { ...state2.events, ...events2 } })),
14660
14809
  // Container for child attachment - the portalScene (injected or container itself)
14661
14810
  internal: { ...rootState.internal, ...injectState.internal, container: portalScene }
14662
14811
  };
@@ -14728,14 +14877,36 @@ function parseRendererConfig(rendererProp) {
14728
14877
  return { primaryCanvas: void 0, scheduler: void 0, renderer: rendererProp };
14729
14878
  }
14730
14879
 
14880
+ const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
14881
+ const registries = /* @__PURE__ */ new WeakMap();
14882
+ function getKindRegistry(store, kind) {
14883
+ let registry = registries.get(store);
14884
+ if (!registry) {
14885
+ registry = {
14886
+ nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14887
+ uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14888
+ buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
14889
+ gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
14890
+ };
14891
+ registries.set(store, registry);
14892
+ }
14893
+ return registry[kind];
14894
+ }
14895
+ function invalidateResource(store, kind, scopeKey) {
14896
+ const registry = getKindRegistry(store, kind);
14897
+ {
14898
+ registry.valid.clear();
14899
+ registry.staged.clear();
14900
+ }
14901
+ }
14902
+ function invalidateAllResources(store) {
14903
+ for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
14904
+ }
14905
+
14731
14906
  function clearHmrCaches(store) {
14732
- store.setState((state) => ({
14733
- nodes: {},
14734
- uniforms: {},
14735
- buffers: {},
14736
- gpuStorage: {},
14737
- _hmrVersion: state._hmrVersion + 1
14738
- }));
14907
+ const primary = store.getState().primaryStore ?? store;
14908
+ invalidateAllResources(primary);
14909
+ primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
14739
14910
  }
14740
14911
 
14741
14912
  function CanvasImpl({
@@ -14816,6 +14987,7 @@ function CanvasImpl({
14816
14987
  const handleDropMissed = useMutableCallback(onDropMissed);
14817
14988
  const [block, setBlock] = React__namespace.useState(false);
14818
14989
  const [error, setError] = React__namespace.useState(false);
14990
+ const [fallbackVisible, setFallbackVisible] = React__namespace.useState(false);
14819
14991
  if (block) throw block;
14820
14992
  if (error) throw error;
14821
14993
  const root = React__namespace.useRef(null);
@@ -14823,6 +14995,7 @@ function CanvasImpl({
14823
14995
  const unsubscribeErrorRef = React__namespace.useRef(null);
14824
14996
  useIsomorphicLayoutEffect(() => {
14825
14997
  effectActiveRef.current = true;
14998
+ if (fallbackVisible) return;
14826
14999
  const canvas = canvasRef.current;
14827
15000
  if (effectiveSize.width > 0 && effectiveSize.height > 0 && canvas) {
14828
15001
  if (!root.current) {
@@ -14843,7 +15016,7 @@ function CanvasImpl({
14843
15016
  }
14844
15017
  async function run() {
14845
15018
  if (!effectActiveRef.current || !root.current) return;
14846
- await root.current.configure({
15019
+ const configured = await root.current.configure({
14847
15020
  id,
14848
15021
  primaryCanvas,
14849
15022
  scheduler,
@@ -14884,8 +15057,20 @@ function CanvasImpl({
14884
15057
  }
14885
15058
  onCreated?.(state);
14886
15059
  }
14887
- });
14888
- if (!effectActiveRef.current || !root.current) return;
15060
+ }).then(
15061
+ () => true,
15062
+ // Renderer setup failed (e.g. no WebGL/WebGPU support). The `fallback` prop lives
15063
+ // inside <canvas>, which browsers don't display, so surface it as visible DOM
15064
+ // instead; with no fallback, rethrow to an external error boundary. (#3757)
15065
+ (setupError) => {
15066
+ if (effectActiveRef.current) {
15067
+ if (fallback != null) setFallbackVisible(true);
15068
+ else setError(setupError);
15069
+ }
15070
+ return false;
15071
+ }
15072
+ );
15073
+ if (!configured || !effectActiveRef.current || !root.current) return;
14889
15074
  root.current.render(
14890
15075
  /* @__PURE__ */ jsxRuntime.jsx(Bridge, { children: /* @__PURE__ */ jsxRuntime.jsx(ErrorBoundary, { set: setError, children: /* @__PURE__ */ jsxRuntime.jsxs(React__namespace.Suspense, { fallback: /* @__PURE__ */ jsxRuntime.jsx(Block, { set: setBlock }), children: [
14891
15076
  backgroundProps && /* @__PURE__ */ jsxRuntime.jsx(Environment, { ...backgroundProps }),
@@ -14948,7 +15133,11 @@ function CanvasImpl({
14948
15133
  ...style
14949
15134
  },
14950
15135
  ...props,
14951
- children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsx(
15136
+ children: fallbackVisible ? (
15137
+ // Renderer setup failed: render the fallback as visible DOM. Inside <canvas> (below)
15138
+ // it exists in the tree but browsers never paint it, which is the whole bug (#3757).
15139
+ fallback
15140
+ ) : /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className: "r3f-canvas-container", style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsxRuntime.jsx(
14952
15141
  "canvas",
14953
15142
  {
14954
15143
  ref: canvasRef,
@@ -14986,7 +15175,6 @@ exports.REACT_INTERNAL_PROPS = REACT_INTERNAL_PROPS;
14986
15175
  exports.RESERVED_PROPS = RESERVED_PROPS;
14987
15176
  exports.Texture = Texture;
14988
15177
  exports._roots = _roots;
14989
- exports.act = act;
14990
15178
  exports.addAfterEffect = addAfterEffect;
14991
15179
  exports.addEffect = addEffect;
14992
15180
  exports.addTail = addTail;