@gnsx/react-three-fiber 10.0.3 → 10.0.4

package/dist/index.cjs

@@ -3453,7 +3453,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15210,6 +15210,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15506,8 +15507,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15560,7 +15563,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15635,23 +15640,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15662,7 +15706,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/dist/index.mjs

@@ -3432,7 +3432,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15189,6 +15189,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15485,8 +15486,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15539,7 +15542,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15614,23 +15619,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15641,7 +15685,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/dist/legacy.cjs

@@ -3460,7 +3460,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15217,6 +15217,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15466,8 +15467,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15520,7 +15523,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15595,23 +15600,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15622,7 +15666,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/dist/legacy.mjs

@@ -3439,7 +3439,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15196,6 +15196,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15445,8 +15446,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15499,7 +15502,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15574,23 +15579,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15601,7 +15645,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/dist/webgpu/index.cjs

@@ -3461,7 +3461,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15218,6 +15218,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15496,8 +15497,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15550,7 +15553,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15625,23 +15630,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15652,7 +15696,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/dist/webgpu/index.mjs

@@ -3440,7 +3440,7 @@ function advance(timestamp) {
   getScheduler().step(timestamp);
 }
 
-const version = "10.0.3";
+const version = "10.0.4";
 const packageData = {
 	version: version};
 
@@ -15197,6 +15197,7 @@ function createRoot(canvas) {
   let pending = null;
   return {
     async configure(props = {}) {
+      if (pending) await pending;
       let resolve;
       pending = new Promise((_resolve) => resolve = _resolve);
       const {
@@ -15475,8 +15476,10 @@ function createRoot(canvas) {
         const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
               const renderer2 = state2.internal.actualRenderer;
+              if (!renderer2) return;
               renderer2.setCanvasTarget(state2.internal.canvasTarget);
             }
           },
@@ -15529,7 +15532,9 @@ function createRoot(canvas) {
         const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
+            if (!state2.internal.active) return;
             const renderer2 = state2.internal.actualRenderer;
+            if (!renderer2) return;
             const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
@@ -15604,23 +15609,62 @@ function Provider({
   }, []);
   return /* @__PURE__ */ jsx(context.Provider, { value: store, children });
 }
+function releaseSceneR3fLinks(scene, options) {
+  if (!scene) return null;
+  scene.traverse((obj) => {
+    delete obj.__r3f;
+  });
+  delete scene.__r3f;
+  {
+    scene.clear();
+  }
+  return scene;
+}
+function releaseRendererRefsFromRootState(state) {
+  const { internal } = state;
+  const renderer = internal.actualRenderer ?? null;
+  internal.actualRenderer = null;
+  internal.canvasTarget = null;
+  internal.pointerMap?.clear();
+  internal.pointerDirty?.clear();
+  return renderer;
+}
+function detachRootSceneFromRootState(state) {
+  const scene = releaseSceneR3fLinks(state.scene);
+  state.set((prev) => ({
+    scene: null,
+    rootScene: null,
+    internal: { ...prev.internal, container: null }
+  }));
+  return scene;
+}
 function unmountComponentAtNode(canvas, callback) {
   const root = _roots.get(canvas);
   const fiber = root?.fiber;
   if (fiber) {
     const state = root?.store.getState();
-    if (state) state.internal.active = false;
+    let rendererForCleanup = null;
+    let canvasTargetForCleanup;
+    let sceneForCleanup = null;
+    if (state) {
+      state.internal.active = false;
+      canvasTargetForCleanup = state.internal.canvasTarget;
+      rendererForCleanup = releaseRendererRefsFromRootState(state);
+      const unregisterRoot = state.internal.unregisterRoot;
+      if (unregisterRoot) {
+        unregisterRoot();
+        state.internal.unregisterRoot = void 0;
+      }
+    }
     reconciler.updateContainer(null, fiber, null, () => {
       if (state) {
+        sceneForCleanup = detachRootSceneFromRootState(state);
         setTimeout(() => {
           try {
-            const renderer = state.internal.actualRenderer;
-            const unregisterRoot = state.internal.unregisterRoot;
-            if (unregisterRoot) unregisterRoot();
+            const renderer = rendererForCleanup;
             const unregisterPrimary = state.internal.unregisterPrimary;
             if (unregisterPrimary) unregisterPrimary();
-            const canvasTarget = state.internal.canvasTarget;
-            if (canvasTarget?.dispose) canvasTarget.dispose();
+            if (canvasTargetForCleanup?.dispose) canvasTargetForCleanup.dispose();
             state.events.disconnect?.();
             cleanupHelperGroup(root.store);
             if (state.isLegacy && renderer) {
@@ -15631,7 +15675,7 @@ function unmountComponentAtNode(canvas, callback) {
             if (!state.internal.isSecondary) {
               if (renderer?.xr) state.xr.disconnect();
             }
-            dispose(state.scene);
+            if (sceneForCleanup) dispose(sceneForCleanup);
             _roots.delete(canvas);
             if (callback) callback(canvas);
           } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gnsx/react-three-fiber",
-  "version": "10.0.3",
+  "version": "10.0.4",
   "description": "A React renderer for Threejs",
   "keywords": [
     "react",