@needle-tools/engine 4.16.10 → 4.16.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/engine",
-  "version": "4.16.10",
+  "version": "4.16.12",
   "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in.",
   "main": "dist/needle-engine.min.js",
   "exports": {
@@ -114,7 +114,7 @@
   ],
   "dependencies": {
     "@dimforge/rapier3d-compat": "0.19.x",
-    "@needle-tools/gltf-progressive": "3.4.0-beta.2",
+    "@needle-tools/gltf-progressive": "3.4.0-beta.4",
     "@needle-tools/materialx": "1.4.6",
     "@needle-tools/three-animation-pointer": "1.0.7",
     "@webxr-input-profiles/motion-controllers": "^1.0.0",

package/src/engine/api.ts

@@ -109,7 +109,9 @@ export * from "./debug/index.js";
 // ============================================================================
 
 /** Addressable asset system for loading assets by address/label */
-export * from "./engine_addressables.js";
+// Keep cache disposal internal: closing shared bitmaps can invalidate active consumers.
+export type { ProgressCallback } from "./engine_addressables.js";
+export { Addressables, AssetReference, FileReference, FileReferenceSerializer, ImageReference, ImageReferenceSerializer } from "./engine_addressables.js";
 
 /** Animation playback and control utilities */
 export { AnimationUtils } from "./engine_animation.js";

package/src/engine/debug/debug_spector.ts

@@ -18,7 +18,7 @@ declare global {
 
 
 export function initSpectorIfAvailable(_context: Context, canvas: HTMLCanvasElement): void {
-    if (typeof window !== undefined && window.SPECTOR) {
+    if (typeof window !== "undefined" && window.SPECTOR) {
         console.log(window.SPECTOR);
         const params = new URLSearchParams(window.location.search);
         if (params.has("spector")) {

package/src/engine/engine_addressables.ts

@@ -619,14 +619,36 @@ export class ImageReference {
 
     private _bitmap?: Promise<ImageBitmap | null>;
     private _bitmapObject?: ImageBitmap;
+    private _bitmapGeneration = 0;
 
     dispose() {
+        // Invalidate image loads and decodes that may complete after teardown.
+        this._bitmapGeneration++;
         if (this._bitmapObject) {
             this._bitmapObject.close();
+            // drop the reference too: close() frees the underlying image data, but keeping the
+            // object alive keeps the wrapper (and anything reachable from it) in the heap.
+            this._bitmapObject = undefined;
         }
         this._bitmap = undefined;
     }
 
+    /**
+     * @internal Only used during final context teardown; see {@link clearAssetCaches}.
+     * Dispose every cached {@link ImageReference} and empty the cache.
+     *
+     * The cache is static, so it outlives any {@link Context}: without this, images loaded by a
+     * page that is later torn down (e.g. navigating between routes in a SPA) stay in memory for
+     * the lifetime of the document, and the heap grows with every navigation.
+     * Called automatically once the last context is disposed — see {@link clearAssetCaches}.
+     */
+    static clearCache() {
+        for (const ref of ImageReference.imageReferences.values()) {
+            ref.dispose();
+        }
+        ImageReference.imageReferences.clear();
+    }
+
     createHTMLImage(): HTMLImageElement {
         const img = new Image();
         img.src = this.url;
@@ -659,22 +681,33 @@ export class ImageReference {
         // });
     }
 
-    /** Loads the bitmap data of the image */
+    /** Loads the bitmap data of the image. Returns null if disposed before loading completes. */
     getBitmap(): Promise<ImageBitmap | null> {
         if (this._bitmap) return this._bitmap;
-        this._bitmap = new Promise((res, _) => {
+        const generation = this._bitmapGeneration;
+        this._bitmap = new Promise((resolve, reject) => {
             const imageElement = document.createElement("img") as HTMLImageElement;
             imageElement.addEventListener("load", () => {
-                this._bitmap = createImageBitmap(imageElement).then((bitmap) => {
+                if (generation !== this._bitmapGeneration) {
+                    resolve(null);
+                    return;
+                }
+                createImageBitmap(imageElement).then(bitmap => {
+                    if (generation !== this._bitmapGeneration) {
+                        // The cache no longer owns this request. Do not revive disposed state
+                        // or overwrite a newer load on a reference that has been reused.
+                        bitmap.close();
+                        resolve(null);
+                        return;
+                    }
                     this._bitmapObject = bitmap;
-                    res(bitmap);
-                    return bitmap;
-                })
-            });
+                    resolve(bitmap);
+                }, reject);
+            }, { once: true });
             imageElement.addEventListener("error", err => {
                 console.error("Failed to load image:" + this.url, err);
-                res(null);
-            });
+                resolve(null);
+            }, { once: true });
             imageElement.src = this.url;
         });
         return this._bitmap;
@@ -748,6 +781,39 @@ export class FileReference {
     constructor(url: string) {
         this.url = url;
     }
+
+    /** Drop the cached response so its body can be garbage collected. A subsequent load re-fetches. */
+    dispose() {
+        this.res = undefined;
+    }
+
+    /**
+     * @internal Only used during final context teardown; see {@link clearAssetCaches}.
+     * Dispose every cached {@link FileReference} and empty the cache.
+     *
+     * The cache is static, so it outlives any {@link Context}: each entry holds the fetch response
+     * for its url, which keeps the file's binary data alive for the lifetime of the document.
+     * Called automatically once the last context is disposed — see {@link clearAssetCaches}.
+     */
+    static clearCache() {
+        for (const ref of FileReference.cache.values()) {
+            ref.dispose();
+        }
+        FileReference.cache.clear();
+    }
+}
+
+/**
+ * @internal Clear the shared file and image caches after the last context is disposed.
+ *
+ * Intentionally not exposed through the public engine API: clearing these caches closes
+ * ImageBitmaps already returned to callers. It does not destroy scenes or remove consumers,
+ * so calling it while a context is alive can invalidate assets that are still in use.
+ * A public API needs resource ownership tracking and defined handling of pending loads first.
+ */
+export function clearAssetCaches() {
+    FileReference.clearCache();
+    ImageReference.clearCache();
 }
 
 

package/src/engine/engine_application.ts

@@ -102,10 +102,15 @@ export class Application extends EventTarget {
     constructor(context: Context) {
         super();
         this.context = context;
-        window.addEventListener("visibilitychange", this.onVisiblityChanged.bind(this), false);
+        window.addEventListener("visibilitychange", this.onVisiblityChanged, false);
     }
 
-    private onVisiblityChanged(evt) {
+    /** @internal Remove the global listener when the owning context is disposed. */
+    dispose() {
+        window.removeEventListener("visibilitychange", this.onVisiblityChanged, false);
+    }
+
+    private onVisiblityChanged = (evt) => {
         // console.log(evt.target.visibilityState)
         switch (evt.target.visibilityState) {
             case "hidden":

package/src/engine/engine_audio.ts

@@ -1,25 +1,78 @@
 import { AudioContext } from "three";
 
 import { Application } from "./engine_application.js";
+import { getParam } from "./engine_utils.js";
 
-/** 
- * @internal 
- * Ensure the audio context is resumed if it gets suspended or interrupted */
+/** Verbose audio logging, opt-in via `?debugaudio` (same flag AudioSource uses). */
+const debug = getParam("debugaudio");
+
+/**
+ * iOS Safari exposes a non-standard `"interrupted"` state in addition to the
+ * spec'd `AudioContextState`s when the audio session is taken away (e.g. the
+ * device is locked or another app starts playing audio).
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/state#resuming_interrupted_play_states_in_ios_safari
+ */
+export type InterruptibleAudioContextState = AudioContextState | "interrupted";
+
+/**
+ * @internal
+ * Pure policy deciding whether `AudioContext.resume()` should be attempted right now.
+ *
+ * The context needs resuming when it is `"suspended"` or (on iOS) `"interrupted"`.
+ * But resuming is only allowed while the document is **visible**: on iOS Safari,
+ * calling `resume()` while the page is backgrounded or the device is locked fails
+ * with `InvalidStateError: Failed to start the audio device`, because the audio
+ * hardware cannot be started in the background. In that case the resume must be
+ * deferred until the page becomes visible again.
+ *
+ * @param state The current (possibly iOS-interrupted) audio context state.
+ * @param visibility The current `document.visibilityState`.
+ * @returns `true` if `resume()` should be called now, `false` if it should be deferred.
+ */
+export function shouldResumeAudioContext(
+    state: InterruptibleAudioContextState,
+    visibility: DocumentVisibilityState,
+): boolean {
+    // Resuming while hidden throws InvalidStateError on iOS — defer until visible.
+    if (visibility !== "visible") return false;
+    return state === "suspended" || state === "interrupted";
+}
+
+/** Resume the shared AudioContext if it is suspended/interrupted and the page is visible. */
+function recoverAudioContext() {
+    const ctx = AudioContext.getContext();
+    const state = ctx.state as InterruptibleAudioContextState;
+    const visibility = typeof document !== "undefined" ? document.visibilityState : "visible";
+    if (!shouldResumeAudioContext(state, visibility)) return;
+    ctx.resume()
+        .then(() => { if (debug) console.log("AudioContext resumed successfully"); })
+        .catch(e => { if (debug) console.warn("Failed to resume AudioContext: " + e); });
+}
+
+/**
+ * @internal
+ * Keep the shared AudioContext alive across suspends/interruptions (tab switch, device lock, audio
+ * session interruption). On returning to the foreground we simply resume() the EXISTING context —
+ * the same approach three.js uses, which recovers cleanly because AudioSource plays clips through a
+ * MediaElementAudioSourceNode (an <audio> element), whose media session iOS keeps alive across a
+ * lock. We deliberately do NOT close/recreate the context: on-device testing showed that makes iOS
+ * worse (a recreated context's output stays dead) and it is unnecessary.
+ */
 export function ensureAudioContextIsResumed() {
     Application.registerWaitForInteraction(() => {
-        // this is a fix for https://github.com/mrdoob/three.js/issues/27779 & https://linear.app/needle/issue/NE-4257
+        // https://github.com/mrdoob/three.js/issues/27779 & https://linear.app/needle/issue/NE-4257
         const ctx = AudioContext.getContext();
-        ctx.addEventListener("statechange", () => {
-            setTimeout(() => {
-                // on iOS the audiocontext can be interrupted: https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/state#resuming_interrupted_play_states_in_ios_safari
-                const state = ctx.state as AudioContextState | "interrupted";
-                if (state === "suspended" || state === "interrupted") {
-                    ctx.resume()
-                        .then(() => { console.log("AudioContext resumed successfully"); })
-                        .catch((e) => { console.log("Failed to resume AudioContext: " + e); });
-                }
-            }, 500);
-        });
+        ctx.addEventListener("statechange", () => setTimeout(recoverAudioContext, 300));
+
+        // iOS frequently rejects the first resume() right after foregrounding with InvalidStateError,
+        // then accepts one a few hundred ms later with no follow-up statechange — so retry with a
+        // short backoff. Each attempt is a no-op once running.
+        if (typeof document !== "undefined") {
+            document.addEventListener("visibilitychange", () => {
+                if (document.visibilityState !== "visible") return;
+                for (const delay of [0, 250, 600, 1200, 2000]) setTimeout(recoverAudioContext, delay);
+            });
+        }
     });
 }
 setTimeout(ensureAudioContextIsResumed, 1000);

package/src/engine/engine_context.ts

@@ -1,5 +1,6 @@
 import 'three/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodes.js';
 
+import { NEEDLE_progressive } from '@needle-tools/gltf-progressive';
 import type { EffectComposer } from "postprocessing";
 import {
 	BufferGeometry, Camera, Color, DepthTexture, Group,
@@ -16,7 +17,7 @@ import { nodeFrame } from "three/examples/jsm/renderers/webgl-legacy/nodes/WebGL
 import { initSpectorIfAvailable } from './debug/debug_spector.js';
 import { isDevEnvironment, LogType, showBalloonError, showBalloonMessage } from './debug/index.js';
 import { AccessibilityManager } from './engine_accessibility.js';
-import { Addressables } from './engine_addressables.js';
+import { Addressables, clearAssetCaches } from './engine_addressables.js';
 import { AnimationsRegistry } from './engine_animation.js';
 import { Application } from './engine_application.js';
 import { AssetDatabase } from './engine_assetdatabase.js';
@@ -850,6 +851,19 @@ export class Context implements IContext {
 		Context.Current = this;
 		ContextRegistry.dispatchCallback(ContextEvent.ContextDestroying, this);
 		invokeLifecycleFunctions(this, ContextEvent.ContextDestroying);
+		// The global legacy node frame must not retain this context's scene after teardown.
+		if (nodeFrame.camera === this._mainCamera || nodeFrame.camera === this._fallbackCamera
+			|| nodeFrame.camera === this.mainCameraComponent?.threeCamera) {
+			nodeFrame.camera = null;
+		}
+		if (this.renderer && nodeFrame.renderer === this.renderer) {
+			nodeFrame.camera = null;
+			nodeFrame.renderer = null;
+			nodeFrame.object = null;
+			nodeFrame.material = null;
+			nodeFrame.scene = null;
+			nodeFrame.geometry = null;
+		}
 		this.clear();
 		this.renderer?.setAnimationLoop(null);
 		if (this.renderer) {
@@ -862,6 +876,7 @@ export class Context implements IContext {
 		}
 		this.scene = null!;
 		this.renderer = null!;
+		this.application.dispose();
 		this.input.dispose();
 		this.menu.onDestroy();
 		this.animations.onDestroy();
@@ -880,6 +895,15 @@ export class Context implements IContext {
 		ContextRegistry.dispatchCallback(ContextEvent.ContextDestroyed, this);
 		invokeLifecycleFunctions(this, ContextEvent.ContextDestroyed);
 		ContextRegistry.unregister(this);
+		// The asset caches (FileReference/ImageReference) are static and shared by all contexts, so
+		// they can only be released once nothing is left that could still be using them. Without
+		// this they are never emptied: a SPA that repeatedly creates and destroys <needle-engine>
+		// elements keeps every loaded file and image alive for the lifetime of the document.
+		if (ContextRegistry.Registered.length === 0) {
+			clearAssetCaches();
+			// Geometry promises in this shared cache retain resource users and their textures.
+			NEEDLE_progressive.dispose();
+		}
 		if (Context.Current === this) {
 			//@ts-ignore
 			Context.Current = null;

package/src/engine/engine_context_registry.ts

@@ -1,6 +1,6 @@
 import { type IComponent, type IContext, type LoadedModel } from "./engine_types.js";
 
-const debug = typeof window !== undefined ? window.location.search.includes("debugcontext") : false;
+const debug = typeof window !== "undefined" ? window.location.search.includes("debugcontext") : false;
 
 /** The various events that can be dispatched by a Needle Engine {@link IContext} instance
  */

package/src/engine/engine_input.ts

@@ -942,7 +942,7 @@ export class Input implements IInput {
         window.removeEventListener('contextmenu', this.onContextMenu);
 
         this._htmlEventSource?.removeEventListener('pointerdown', this.onPointerDown);
-        window.removeEventListener('pointermove', this.onPointerMove);
+        window.removeEventListener('pointermove', this.onPointerMove, true);
         window.removeEventListener('pointerup', this.onPointerUp);
         window.removeEventListener('pointercancel', this.onPointerCancel);
 
@@ -1597,4 +1597,4 @@ export declare type KeyCode =
 // OPEN_BRACKET = 219,
 // BACK_SLASH = 220,
 // CLOSE_BRACKET = 221,
-// SINGLE_QUOTE = 222
+// SINGLE_QUOTE = 222

package/src/engine/engine_license.ts

@@ -10,6 +10,23 @@ import type { IContext } from "./engine_types.js";
 import { getParam } from "./engine_utils.js";
 import { InternalAttributeUtils } from "./engine_utils_attributes.js";
 
+// License UI polling must stop when its context goes away; otherwise timers retain scenes.
+const licenseIntervals = new WeakMap<IContext, Set<ReturnType<typeof setInterval>>>();
+const disposedLicenseContexts = new WeakSet<IContext>();
+ContextRegistry.registerCallback(ContextEvent.ContextDestroying, ({ context }) => {
+    disposedLicenseContexts.add(context);
+    for (const timer of licenseIntervals.get(context) ?? []) clearInterval(timer);
+    licenseIntervals.delete(context);
+});
+function setLicenseInterval(ctx: IContext, callback: () => void, delay: number) {
+    if (disposedLicenseContexts.has(ctx)) return undefined;
+    let timers = licenseIntervals.get(ctx);
+    if (!timers) licenseIntervals.set(ctx, timers = new Set());
+    const timer = setInterval(callback, delay);
+    timers.add(timer);
+    return timer;
+}
+
 const debug = getParam("debuglicense");
 
 const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
@@ -56,9 +73,15 @@ export function hasCommercialLicense() {
 
 /** @internal */
 export function onLicenseCheckResultChanged(cb: (result: boolean) => void) {
-    if (hasProLicense() || hasIndieLicense() || hasEduLicense())
-        return cb(true);
+    if (hasProLicense() || hasIndieLicense() || hasEduLicense()) {
+        cb(true);
+        return () => {};
+    }
     _licenseCheckResultChangedCallbacks.push(cb);
+    return () => {
+        const index = _licenseCheckResultChangedCallbacks.indexOf(cb);
+        if (index >= 0) _licenseCheckResultChangedCallbacks.splice(index, 1);
+    };
 }
 
 function invokeLicenseCheckResultChanged(result: boolean) {
@@ -328,7 +351,7 @@ async function handleForbidden(ctx: IContext) {
         const expectedTextStyle = text.style.cssText;
         const forbiddenText = applicationForbiddenText?.length > 1 ? applicationForbiddenText : "This web application has been paused.<br/>You might be in violation of the Needle Engine terms of use.<br/>Please contact the Needle support if you think this is a mistake.";
         text.innerHTML = forbiddenText;
-        setInterval(() => {
+        setLicenseInterval(ctx, () => {
             if (text.innerHTML !== forbiddenText) text.innerHTML = forbiddenText;
             if (text.parentNode !== div) div.appendChild(text);
             if (div.style.cssText !== expectedStyle) div.style.cssText = expectedStyle;
@@ -338,7 +361,7 @@ async function handleForbidden(ctx: IContext) {
     }
     let forbiddenElement = createForbiddenElement();
     const expectedCSS = forbiddenElement.style.cssText;
-    setInterval(() => {
+    setLicenseInterval(ctx, () => {
         if (applicationIsForbidden === true) {
             if (forbiddenElement.style.cssText !== expectedCSS) forbiddenElement = createForbiddenElement();
             if (ctx.domElement.shadowRoot) {
@@ -452,7 +475,7 @@ function insertNonCommercialUseHint(ctx: IContext) {
     }, 100);
 
     // ensure the banner is always visible
-    const interval = setInterval(() => {
+    const interval = setLicenseInterval(ctx, () => {
         const parent = ctx.domElement.shadowRoot || ctx.domElement;
         if (banner.parentNode !== parent) {
             parent.appendChild(banner);

package/src/engine/engine_lifecycle_functions_internal.ts

@@ -141,13 +141,27 @@ function internalInvokeLifecycleFunctions(ctx: Context, evt: Event) {
     }
 }
 
-const bufferArray = new Array<RegisteredLifecycleMethod>();
+const buffers: Array<Array<RegisteredLifecycleMethod>> = [];
+let invocationDepth = 0;
 const hookContext: LifecycleHookContext = {
     context: null as any as Context
 };
 
 function invoke(ctx: Context, methods: Array<RegisteredLifecycleMethod>, invokeOnce: boolean) {
-    bufferArray.length = 0;
+    // Reuse storage per nesting depth: hooks may synchronously invoke other hooks.
+    const bufferArray = buffers[invocationDepth] ?? (buffers[invocationDepth] = []);
+    invocationDepth++;
+    try {
+        invokeWithBuffer(ctx, methods, invokeOnce, bufferArray);
+    }
+    finally {
+        // One-time/unregistered callbacks can capture entire scenes as well.
+        bufferArray.length = 0;
+        invocationDepth--;
+    }
+}
+
+function invokeWithBuffer(ctx: Context, methods: Array<RegisteredLifecycleMethod>, invokeOnce: boolean, bufferArray: Array<RegisteredLifecycleMethod>) {
     for (let i = 0; i < methods.length; i++) {
         bufferArray.push(methods[i]);
     }
@@ -161,6 +175,7 @@ function invoke(ctx: Context, methods: Array<RegisteredLifecycleMethod>, invokeO
         }
 
         if (invoke) {
+            const previousContext = hookContext.context;
             try {
                 hookContext.context = ctx;
                 entry.method?.call(hookContext, ctx);
@@ -168,6 +183,10 @@ function invoke(ctx: Context, methods: Array<RegisteredLifecycleMethod>, invokeO
             catch (e) {
                 console.error("Error in lifecycle method", e);
             }
+            finally {
+                // This shared receiver must not keep the last invoked context alive.
+                hookContext.context = previousContext;
+            }
         }
 
         // Remove the method if it's a one time call

package/src/engine/engine_networking_streams.ts

@@ -1,4 +1,5 @@
-import Peer, { CallOption, MediaConnection } from "peerjs"
+import type Peer from "peerjs";
+import type { CallOption, MediaConnection } from "peerjs";
 import { EventDispatcher } from "three";
 
 import { RoomEvents } from "../engine/engine_networking.js";
@@ -7,6 +8,7 @@ import { getPeerjsInstance } from "../engine/engine_networking_peer.js";
 import { showBalloonMessage } from "./debug/index.js";
 import { Application } from "./engine_application.js";
 import { Context } from "./engine_context.js";
+import { ContextEvent, ContextRegistry } from "./engine_context_registry.js";
 import type { IModel } from "./engine_networking_types.js";
 import { type IComponent, isComponent } from "./engine_types.js";
 import { getParam } from "./engine_utils.js";
@@ -120,17 +122,31 @@ function applySdpTransform(sdp) {
 
 export class PeerHandle extends EventDispatcher<any> {
 
-    private static readonly instances: Map<string, PeerHandle> = new Map();
+    // Weak ownership prevents this cache from rooting a context and its scene indefinitely.
+    // IDs are scoped to contexts: separate engine elements may use the same stream ID.
+    private static readonly instances = new WeakMap<Context, Map<string, PeerHandle>>();
+
+    static {
+        ContextRegistry.registerCallback(ContextEvent.ContextDestroying, ({ context }) => {
+            const handles = PeerHandle.instances.get(context as Context);
+            if (!handles) return;
+            PeerHandle.instances.delete(context as Context);
+            for (const handle of handles.values()) handle.dispose();
+            handles.clear();
+        });
+    }
 
     static getOrCreate(context: Context, guid: string): PeerHandle {
-        // if (id === undefined) {
-        //     // randomId
-        //     id = Math.random().toFixed(5);
-        // }
-        if (PeerHandle.instances.has(guid))
-            return PeerHandle.instances.get(guid)!;
-        const peer = new PeerHandle(context, guid);
-        PeerHandle.instances.set(guid, peer);
+        let handles = PeerHandle.instances.get(context);
+        if (!handles) {
+            handles = new Map();
+            PeerHandle.instances.set(context, handles);
+        }
+        let peer = handles.get(guid);
+        if (!peer) {
+            peer = new PeerHandle(context, guid);
+            handles.set(guid, peer);
+        }
         return peer;
     }
 
@@ -150,6 +166,7 @@ export class PeerHandle extends EventDispatcher<any> {
     }
 
     makeCall(peerId: string, stream: MediaStream): CallHandle | undefined {
+        if (this._disposed) return undefined;
         if (!stream?.id) {
             if (debug) console.warn("Can not make a call: mediastream has no id or is undefined");
             else console.debug("Can not make a call: mediastream has no id or is undefined");
@@ -178,10 +195,8 @@ export class PeerHandle extends EventDispatcher<any> {
     }
 
     closeAll() {
-        for (const call of this._incomingCalls) {
-            call.close();
-        }
-        for (const call of this._outgoingCalls) {
+        // Closing a call synchronously removes it from the original array.
+        for (const call of [...this._incomingCalls, ...this._outgoingCalls]) {
             call.close();
         }
         this.updateCalls();
@@ -252,16 +267,33 @@ export class PeerHandle extends EventDispatcher<any> {
         }
     }
 
+    private _disposed = false;
+    private readonly _callIntervals = new Set<ReturnType<typeof setInterval>>();
+
+    private dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        this.disable();
+        this.unsubscribePeerEvents();
+        for (const interval of this._callIntervals) clearInterval(interval);
+        this._callIntervals.clear();
+        this.closeAll();
+        this._incomingCalls.length = 0;
+        this._outgoingCalls.length = 0;
+        this._peer?.destroy();
+        this._peer = undefined;
+    }
+
     private _enabled: boolean = false;
     private _enabledPeer: boolean = false;
-    private onConnectRoomFn: Function = this.onConnectRoom.bind(this);
+    private onConnectRoomFn: () => void = this.onConnectRoom.bind(this);
     // private onUserJoinedOrLeftRoomFn: Function = this.onUserJoinedOrLeftRoom.bind(this);
     // private onPeerConnectFn: (id) => void = this.onPeerConnect.bind(this);
     // private onPeerReceiveCallFn: (call) => void = this.onPeerReceivingCall.bind(this);
     // private _connectionPeerIdMap : Map<string, string> = new Map();
 
     enable() {
-        if (this._enabled) return;
+        if (this._disposed || this._enabled) return;
         this._enabled = true;
         this.context.connection.beginListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
         // this.context.connection.beginListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
@@ -286,13 +318,19 @@ export class PeerHandle extends EventDispatcher<any> {
     // };
 
     private setupPeer() {
-        if (!this.context.connection.connectionId) return;
+        if (this._disposed || !this.context.connection.connectionId) return;
         if (this._enabledPeer) return;
         this._enabledPeer = true;
         if (!this._peer) {
             const peerId = this.getMyPeerId();
-            if (peerId)
-                this._peer = getPeerjsInstance(peerId);
+            if (peerId) {
+                const peer = getPeerjsInstance(peerId);
+                if (this._disposed) {
+                    peer.destroy();
+                    return;
+                }
+                this._peer = peer;
+            }
             else console.error("Failed to setup peerjs because we dont have a connection id", this.context.connection.connectionId);
         }
         if (this._enabled)
@@ -414,6 +452,7 @@ export class PeerHandle extends EventDispatcher<any> {
             });
 
             call.on("stream", () => {
+                if (this._disposed) return;
                 if (debug) console.log("Received stream for call", call.metadata);
                 // workaround for https://github.com/peers/peerjs/issues/636
                 let intervalCounter = 0;
@@ -423,9 +462,15 @@ export class PeerHandle extends EventDispatcher<any> {
                         if (debug) console.warn("Close call because stream is not active", call.metadata);
                         intervalCounter += 1;
                         clearInterval(closeInterval);
+                        this._callIntervals.delete(closeInterval);
                         handle.close();
                     }
                 }, 2000);
+                this._callIntervals.add(closeInterval);
+                call.on("close", () => {
+                    clearInterval(closeInterval);
+                    this._callIntervals.delete(closeInterval);
+                });
             });
         }
         return handle;

package/src/engine/engine_shims.ts

@@ -10,7 +10,7 @@ export declare type OffscreenCanvasExt = OffscreenCanvas & {
 
 // REMOVE once usage of browsers that don't support OffscreenCanvas is low
 // Shim for missing OffscreenCanvas in iOS 16.x
-if (typeof globalThis !== undefined && !('OffscreenCanvas' in globalThis)) {
+if (typeof globalThis !== "undefined" && !('OffscreenCanvas' in globalThis)) {
 	// @ts-ignore
 	globalThis['OffscreenCanvas'] = class OffscreenCanvas  {
 		canvas: HTMLCanvasElement;

package/src/engine/physics/workers/mesh-bvh/GenerateMeshBVHWorker.js

@@ -120,7 +120,14 @@ export class GenerateMeshBVHWorker extends WorkerBase {
 
 			}, transferable.map( arr => arr.buffer ).filter( v => ( typeof SharedArrayBuffer === 'undefined' ) || ! ( v instanceof SharedArrayBuffer ) ) );
 
-		} );
+		} ).finally( () => {
+
+            // Pooled workers outlive each job. Both handlers capture the job scope,
+            // including its geometry, even after the promise has settled.
+            worker.onmessage = null;
+            worker.onerror = null;
+
+        } );
 
 	}