@needle-tools/engine 5.1.0-alpha.3 → 5.1.0-alpha.4

package/src/engine/codegen/register_types.ts

@@ -7,11 +7,6 @@ import { Animation } from "../../engine-components/Animation.js";
 import { Animator } from "../../engine-components/Animator.js";
 import { AudioListener } from "../../engine-components/AudioListener.js";
 import { AudioSource } from "../../engine-components/AudioSource.js";
-import { Avatar_Brain_LookAt } from "../../engine-components/avatar/Avatar_Brain_LookAt.js";
-import { Avatar_MouthShapes } from "../../engine-components/avatar/Avatar_MouthShapes.js";
-import { Avatar_MustacheShake } from "../../engine-components/avatar/Avatar_MustacheShake.js";
-import { AvatarBlink_Simple } from "../../engine-components/avatar/AvatarBlink_Simple.js";
-import { AvatarEyeLook_Rotation } from "../../engine-components/avatar/AvatarEyeLook_Rotation.js";
 import { AxesHelper } from "../../engine-components/AxesHelper.js";
 import { BasicIKConstraint } from "../../engine-components/BasicIKConstraint.js";
 import { BoxHelperComponent } from "../../engine-components/BoxHelperComponent.js";
@@ -110,6 +105,7 @@ import { AnimationTrackHandler } from "../../engine-components/timeline/Timeline
 import { AudioTrackHandler } from "../../engine-components/timeline/TimelineTracks.js";
 import { MarkerTrackHandler } from "../../engine-components/timeline/TimelineTracks.js";
 import { SignalTrackHandler } from "../../engine-components/timeline/TimelineTracks.js";
+import { ActivationTrackHandler } from "../../engine-components/timeline/TimelineTracks.js";
 import { ControlTrackHandler } from "../../engine-components/timeline/TimelineTracks.js";
 import { TransformGizmo } from "../../engine-components/TransformGizmo.js";
 import { BaseUIComponent } from "../../engine-components/ui/BaseUIComponent.js";
@@ -167,11 +163,6 @@ export function initBuiltinTypes() {
 	TypeStore.add("Animator", Animator);
 	TypeStore.add("AudioListener", AudioListener);
 	TypeStore.add("AudioSource", AudioSource);
-	TypeStore.add("Avatar_Brain_LookAt", Avatar_Brain_LookAt);
-	TypeStore.add("Avatar_MouthShapes", Avatar_MouthShapes);
-	TypeStore.add("Avatar_MustacheShake", Avatar_MustacheShake);
-	TypeStore.add("AvatarBlink_Simple", AvatarBlink_Simple);
-	TypeStore.add("AvatarEyeLook_Rotation", AvatarEyeLook_Rotation);
 	TypeStore.add("AxesHelper", AxesHelper);
 	TypeStore.add("BasicIKConstraint", BasicIKConstraint);
 	TypeStore.add("BoxHelperComponent", BoxHelperComponent);
@@ -270,6 +261,7 @@ export function initBuiltinTypes() {
 	TypeStore.add("AudioTrackHandler", AudioTrackHandler);
 	TypeStore.add("MarkerTrackHandler", MarkerTrackHandler);
 	TypeStore.add("SignalTrackHandler", SignalTrackHandler);
+	TypeStore.add("ActivationTrackHandler", ActivationTrackHandler);
 	TypeStore.add("ControlTrackHandler", ControlTrackHandler);
 	TypeStore.add("TransformGizmo", TransformGizmo);
 	TypeStore.add("BaseUIComponent", BaseUIComponent);

package/src/engine/engine_context.ts

@@ -863,7 +863,7 @@ export class Context implements IContext {
 		this.scene = new Scene();
 		this.addressables?.dispose();
 		this.lightmaps?.clear();
-		this.physics?.engine?.clearCaches();
+		this.physics?.engine?.dispose();
 		this.lodsManager.disable();
 		this.accessibility?.clear();
 
@@ -912,6 +912,7 @@ export class Context implements IContext {
 		this.scene = null!;
 		this.renderer = null!;
 		this.input.dispose();
+		this.connection.dispose();
 		this.menu.onDestroy();
 		this.animations.onDestroy();
 		for (const cb of this._disposeCallbacks) {

package/src/engine/engine_disposable.ts

@@ -0,0 +1,214 @@
+/** A function that performs cleanup when called */
+export type DisposeFn = () => void;
+
+/**
+ * Interface for objects that hold resources and can be disposed.
+ * Implement this interface on any object that needs deterministic cleanup.
+ *
+ * @example
+ * ```ts
+ * class MyResource implements IDisposable {
+ *     dispose() { /* release resources *\/ }
+ * }
+ * ```
+ *
+ * @category Utilities
+ * @group Lifecycle
+ */
+export interface IDisposable {
+    dispose(): void;
+}
+
+/**
+ * Type guard to check if an object implements {@link IDisposable}.
+ *
+ * @example
+ * ```ts
+ * if (isDisposable(obj)) {
+ *     obj.dispose(); // safe to call
+ * }
+ * ```
+ */
+export function isDisposable(value: unknown): value is IDisposable {
+    return value !== null
+        && typeof value === "object"
+        && "dispose" in (value as object)
+        && typeof (value as IDisposable).dispose === "function";
+}
+
+/**
+ * @experimental
+ * Subscribe to a DOM event on any {@link EventTarget} (window, document, HTML elements, etc.)
+ * and return an {@link IDisposable} that removes the listener when disposed.
+ *
+ * Provides full TypeScript event type inference — the callback parameter
+ * is automatically typed based on the event name (e.g. `"resize"` → `UIEvent`,
+ * `"click"` → `MouseEvent`).
+ *
+ * Use with {@link DisposableStore.add} for automatic lifecycle cleanup in components.
+ *
+ * @param target The EventTarget to listen on (window, document, an element, etc.)
+ * @param type The event name (e.g. `"resize"`, `"click"`, `"keydown"`)
+ * @param listener The event handler callback
+ * @param options Optional addEventListener options (passive, capture, once, signal)
+ * @returns An {@link IDisposable} that removes the event listener when disposed
+ *
+ * @example Standalone usage
+ * ```ts
+ * import { on } from "@needle-tools/engine";
+ *
+ * const sub = on(window, "resize", (ev) => {
+ *     // ev is typed as UIEvent
+ *     console.log("resized", ev.target);
+ * });
+ *
+ * // Later: clean up
+ * sub.dispose();
+ * ```
+ *
+ * @example With autoCleanup in a component
+ * ```ts
+ * import { Behaviour, on } from "@needle-tools/engine";
+ *
+ * export class MyComponent extends Behaviour {
+ *     onEnable() {
+ *         this.autoCleanup(on(window, "resize", (ev) => { /* UIEvent *\/ }));
+ *         this.autoCleanup(on(document, "keydown", (ev) => { /* KeyboardEvent *\/ }));
+ *         this.autoCleanup(on(this.context.domElement, "click", (ev) => { /* MouseEvent *\/ }));
+ *     }
+ *     // All listeners removed automatically on disable!
+ * }
+ * ```
+ *
+ * @category Utilities
+ * @group Lifecycle
+ */
+// #region on
+export function on<K extends keyof WindowEventMap>(target: Window, type: K, listener: (ev: WindowEventMap[K]) => void, options?: boolean | AddEventListenerOptions): IDisposable;
+export function on<K extends keyof DocumentEventMap>(target: Document, type: K, listener: (ev: DocumentEventMap[K]) => void, options?: boolean | AddEventListenerOptions): IDisposable;
+export function on<K extends keyof HTMLElementEventMap>(target: HTMLElement, type: K, listener: (ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): IDisposable;
+export function on(target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): IDisposable;
+export function on(target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): IDisposable {
+    target.addEventListener(type, listener, options);
+    return {
+        dispose() {
+            target.removeEventListener(type, listener, options);
+        }
+    };
+}
+
+
+/**
+ * A store for managing disposable resources (event subscriptions, listeners, callbacks)
+ * that should be cleaned up together.
+ *
+ * DisposableStore collects disposables and disposes them all at once when
+ * {@link dispose} is called. After disposal, the store can be reused — new items
+ * can be added and a subsequent {@link dispose} call will clean those up.
+ *
+ * This is the same pattern used internally by VSCode for lifecycle-bound resource management.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { DisposableStore, on } from "@needle-tools/engine";
+ *
+ * const store = new DisposableStore();
+ *
+ * // Register a DOM event listener (typed!)
+ * store.add(on(window, "resize", (ev) => console.log(ev)));
+ *
+ * // Register the return value of EventList.on()
+ * store.add(myEventList.on(data => console.log(data)));
+ *
+ * // Register a raw cleanup function
+ * store.add(() => someSDK.off("event", handler));
+ *
+ * // Later: dispose everything at once
+ * store.dispose();
+ * ```
+ *
+ * @example Use with Needle Engine components
+ * ```ts
+ * import { Behaviour, serializable, EventList, on } from "@needle-tools/engine";
+ *
+ * export class MyComponent extends Behaviour {
+ *     @serializable(EventList)
+ *     onClick?: EventList;
+ *
+ *     onEnable() {
+ *         // DOM events — fully typed
+ *         this.autoCleanup(on(window, "resize", (ev) => this.onResize(ev)));
+ *
+ *         // EventList — .on() returns a function, autoCleanup accepts it
+ *         this.autoCleanup(this.onClick?.on(() => console.log("clicked!")));
+ *     }
+ *     // No onDisable needed — cleaned up automatically!
+ * }
+ * ```
+ *
+ * @category Utilities
+ * @group Lifecycle
+ */
+// #region DisposableStore
+export class DisposableStore implements IDisposable {
+
+    private _disposables: Array<DisposeFn> = [];
+
+    /** The number of registered disposables */
+    get size() { return this._disposables.length; }
+
+    /**
+     * Register a disposable resource. Accepts:
+     * - An {@link IDisposable} object (has a `dispose()` method) — e.g. from {@link on}
+     * - A cleanup function (e.g. return value of `EventList.on()`)
+     * - `null` or `undefined` (safe no-op for conditional subscriptions)
+     *
+     * When {@link dispose} is called, all registered resources are cleaned up.
+     *
+     * @param disposable The resource to register for disposal
+     *
+     * @example
+     * ```ts
+     * const store = new DisposableStore();
+     *
+     * // IDisposable object from on()
+     * store.add(on(window, "resize", handler));
+     *
+     * // Function returned by EventList.on()
+     * store.add(myEvent.on(handler));
+     *
+     * // Raw cleanup function
+     * store.add(() => connection.close());
+     *
+     * // Conditional — safe with undefined
+     * store.add(this.maybeEvent?.on(handler));
+     * ```
+     */
+    add(disposable: IDisposable | DisposeFn | Function | null | undefined): void {
+        if (!disposable) return;
+        if (typeof disposable === "function") {
+            this._disposables.push(disposable as DisposeFn);
+        }
+        else if (typeof disposable === "object" && "dispose" in disposable) {
+            this._disposables.push(() => disposable.dispose());
+        }
+    }
+
+    /**
+     * Dispose all registered resources. Each registered disposable is cleaned up,
+     * then the internal list is cleared. The store can be reused after disposal.
+     *
+     * Called automatically by the engine when a component's `onDisable` lifecycle fires.
+     */
+    dispose(): void {
+        for (let i = this._disposables.length - 1; i >= 0; i--) {
+            try {
+                this._disposables[i]();
+            }
+            catch (err) {
+                console.error("Error disposing resource", err);
+            }
+        }
+        this._disposables.length = 0;
+    }
+}

package/src/engine/engine_gameobject.ts

@@ -10,10 +10,11 @@ import { $isUsingInstancing, InstancingUtil } from "./engine_instancing.js";
 import { processNewScripts } from "./engine_mainloop_utils.js";
 import type { syncInstantiate } from "./engine_networking_instantiate.js";
 import { InstantiateIdProvider } from "./engine_networking_instantiate.js";
-import { assign, ISerializable } from "./engine_serialization_core.js";
+import { resolveInstanceReferences, type InstantiateReferenceMap, type InstantiateContext, type ObjectCloneReference } from "./engine_instantiate_resolve.js";
+import { assign } from "./engine_serialization_core.js";
 import { Context, registerComponent } from "./engine_setup.js";
 import { getTempQuaternion, logHierarchy, setWorldPosition, setWorldQuaternion } from "./engine_three_utils.js";
-import { type Constructor, type GuidsMap, type IComponent as Component, type IComponent, IEventList, type IGameObject as GameObject, type UIDProvider } from "./engine_types.js";
+import { type Constructor, type GuidsMap, type IComponent as Component, type IComponent, type IGameObject as GameObject, type UIDProvider, isComponent } from "./engine_types.js";
 import { deepClone, getParam, tryFindObject } from "./engine_utils.js";
 import { apply } from "./js-extensions/index.js";
 
@@ -324,19 +325,8 @@ function internalForEachComponent(instance: Object3D, cb: ForEachComponentCallba
 
 }
 
-declare type ObjectCloneReference = {
-    readonly original: object;
-    readonly clone: object;
-}
-
-
-declare type InstantiateReferenceMap = Record<string, ObjectCloneReference>;
-declare type NewObjectReferenceMap = Record<string, { target: object, key: string }>;
-
-/**
- * Provides access to the instantiated object and its clone
- */
-export declare type InstantiateContext = Readonly<InstantiateReferenceMap>;
+// Re-export types from the unified resolution module
+export type { InstantiateContext, InstantiateReferenceMap, ObjectCloneReference } from "./engine_instantiate_resolve.js";
 
 /**
  * Creates a copy (clone) of a GameObject or loads and instantiates an AssetReference.
@@ -410,7 +400,7 @@ export function instantiate(instance: AssetReference | GameObject | Object3D, op
     const clone = internalInstantiate(context, instance, options, components, referencemap, skinnedMeshes);
 
     if (clone) {
-        resolveReferences(clone, referencemap);
+        resolveInstanceReferences(referencemap);
         resolveAndBindSkinnedMeshBones(skinnedMeshes, referencemap);
     }
 
@@ -420,6 +410,18 @@ export function instantiate(instance: AssetReference | GameObject | Object3D, op
     }
 
     const guidsMap: GuidsMap = {};
+
+    // Cloned object guids
+    for (const ref in referencemap) {
+        const val = referencemap[ref];
+        const original = val.original;
+        const clone = val.clone;
+        if (original instanceof Object3D && clone instanceof Object3D) {
+            guidsMap[original.guid || original.uuid] = clone.guid || clone.uuid;
+        }
+    }
+
+    // Cloned component guids (generate new guids for components that dont have one and add them to the map)
     if (options?.components !== false) {
         for (const i in components) {
             const copy = components[i];
@@ -427,8 +429,7 @@ export function instantiate(instance: AssetReference | GameObject | Object3D, op
             if (options && options.idProvider) {
                 copy.guid = options.idProvider.generateUUID();
                 guidsMap[oldGuid] = copy.guid;
-                if (debug)
-                    console.log(copy.name, copy.guid)
+                if (debug) console.log(copy.name, copy.guid)
             }
             registerComponent(copy, context);
             if (copy.__internalNewInstanceCreated)
@@ -436,8 +437,6 @@ export function instantiate(instance: AssetReference | GameObject | Object3D, op
         }
         for (const i in components) {
             const copy = components[i];
-            if (copy.resolveGuids)
-                copy.resolveGuids(guidsMap);
             if (copy.enabled === false) continue;
             else copy.enabled = true;
         }
@@ -478,7 +477,12 @@ function internalInstantiate(
     instance.children = children;
 
     // make reference from old id to new object
-    objectsMap[instance.uuid] = { original: instance, clone: clone };
+    const ref: ObjectCloneReference = { original: instance, clone: clone };
+    objectsMap[instance.uuid] = ref;
+    // Also key by guid so string guid references (e.g. PlayableDirector track.outputs) can be resolved
+    if ((instance).guid && (instance).guid !== instance.uuid) {
+        objectsMap[(instance).guid] = ref;
+    }
     if (debugInstantiate) console.log("ADD", instance, clone)
 
     if (instance.type === "SkinnedMesh") {
@@ -612,32 +616,32 @@ function internalInstantiate(
 function onAssignComponent(source: any, target: any, _newObjectsMap: InstantiateReferenceMap) {
     assign(target, source, undefined, {
         // onAssigned: (target, key, _oldValue, value) => {
-            // if (value !== null && typeof value === "object") {
-            //     const serializable = target as ISerializable;
-            //     if (serializable?.$serializedTypes?.[key]) {
-            //         if (!(value instanceof Object3D)) {
-            //             // let clone = null;
-            //             // if ("clone" in value) {
-            //             //     if (canClone(value)) clone = (value as any).clone();
-            //             // }
-            //             // else {
-            //             //     clone = Object.assign(Object.create(Object.getPrototypeOf(value)), value);
-            //             // }
-            //             // if (clone) {
-            //             //     console.debug(key, { target, value, clone })
-            //             //     target[key] = clone;
-            //             //     findNestedReferences(clone, objectsMap);
-            //             // }
-            //             // else console.debug("Could not clone value for key", key, value);
-            //         }
-            //         else {
-            //             console.log("ASSIGNED", value)
-            //         }
-
-            //         recursiveAssign(target, target[key], newObjectsMap);
-            //     }
-
-            // }
+        // if (value !== null && typeof value === "object") {
+        //     const serializable = target as ISerializable;
+        //     if (serializable?.$serializedTypes?.[key]) {
+        //         if (!(value instanceof Object3D)) {
+        //             // let clone = null;
+        //             // if ("clone" in value) {
+        //             //     if (canClone(value)) clone = (value as any).clone();
+        //             // }
+        //             // else {
+        //             //     clone = Object.assign(Object.create(Object.getPrototypeOf(value)), value);
+        //             // }
+        //             // if (clone) {
+        //             //     console.debug(key, { target, value, clone })
+        //             //     target[key] = clone;
+        //             //     findNestedReferences(clone, objectsMap);
+        //             // }
+        //             // else console.debug("Could not clone value for key", key, value);
+        //         }
+        //         else {
+        //             console.log("ASSIGNED", value)
+        //         }
+
+        //         recursiveAssign(target, target[key], newObjectsMap);
+        //     }
+
+        // }
         // }
     });
 }
@@ -742,113 +746,4 @@ function resolveAndBindSkinnedMeshBones(
 
 // }
 
-function resolveReferences(_newInstance: Object3D, newObjectsMap: InstantiateReferenceMap) {
-    // for every object that is newly created we want to update references to their newly created counterparts
-    // e.g. a collider instance referencing a rigidbody instance should be updated so that 
-    // the cloned collider does not reference the cloned rigidbody (instead of the original rigidbody)
-    for (const key in newObjectsMap) {
-        const val = newObjectsMap[key];
-        const clone = val.clone as Object3D | null;
-        // resolve references
-        if (clone?.isObject3D && clone?.userData?.components) {
-            for (let i = 0; i < clone.userData.components.length; i++) {
-                const copy = clone.userData.components[i];
-                // find referenced within a cloned gameobject
-                const entries = Object.entries(copy);
-                // console.log(copy, entries);
-                for (const [key, value] of entries) {
-                    if (Array.isArray(value)) {
-                        const clonedArray: Array<any> = [];
-                        copy[key] = clonedArray;
-                        // console.log(copy, key, value, copy[key]);
-                        for (let i = 0; i < value.length; i++) {
-                            const entry = value[i];
-                            // push value types into new array
-                            if (typeof entry !== "object") {
-                                clonedArray.push(entry);
-                                continue;
-                            }
-                            const res: any = postProcessNewInstance(copy, key, entry, newObjectsMap);
-                            if (res !== undefined) {
-                                if (debugInstantiate) console.log("Found new instance for", key, entry, "->", res);
-                                clonedArray.push(res);
-                            }
-                            else {
-                                if (debugInstantiate) console.warn("Could not find new instance for", key, entry);
-                                clonedArray.push(entry);
-                            }
-                        }
-                        // console.log(copy[key])
-                    }
-                    else if (typeof value === "object") {
-                        const res = postProcessNewInstance(copy, key, value as IComponent | Object3D, newObjectsMap);
-                        if (res !== undefined) {
-                            copy[key] = res;
-                        }
-                        else {
-                            if (debugInstantiate) console.warn("Could not find new instance for", key, value);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-}
-
-function postProcessNewInstance(copy: Object3D, key: string, value: IComponent | Object3D | any, newObjectsMap: InstantiateReferenceMap) {
-    if (value === null || value === undefined) return;
-    if ((value as IComponent).isComponent === true) {
-        const originalGameObjectReference = value["gameObject"];
-        // console.log(key, value, originalGameObjectReference);
-        if (originalGameObjectReference) {
-            const id = originalGameObjectReference.uuid;
-            const newGameObject = newObjectsMap[id]?.clone;
-            if (!newGameObject) {
-                // reference has not changed!
-                if (debugInstantiate)
-                    console.log("reference did not change", key, copy, value);
-                return;
-            }
-            const index = originalGameObjectReference.userData.components.indexOf(value);
-            if (index >= 0 && (newGameObject as Object3D).isObject3D) {
-                if (debugInstantiate)
-                    console.log(key, id);
-                const found = (newGameObject as Object3D).userData.components[index];
-                return found;
-            }
-            else {
-                console.warn("could not find component", key, value);
-            }
-        }
-    } else if ((value as Object3D).isObject3D === true) {
-        // console.log(value);
-        if (key === "gameObject") return;
-        const originalGameObjectReference = value as Object3D;
-        if (originalGameObjectReference) {
-            const id = originalGameObjectReference.uuid;
-            const newGameObject = newObjectsMap[id]?.clone;
-            if (newGameObject) {
-                if (debugInstantiate)
-                    console.log(key, "old", value, "new", newGameObject);
-                return newGameObject;
-            }
-        }
-    }
-    else {
-        // create new instances for some types that we know should usually not be shared and can safely be cloned
-        if (value.isVector4 || value.isVector3 || value.isVector2 || value.isQuaternion || value.isEuler) {
-            return value.clone();
-        }
-        else if (value.isColor === true) {
-            return value.clone();
-        }
-        else if ((value as IEventList).isEventList === true) {
-            // create a new instance of the object
-            const copy = (value as IEventList).__internalOnInstantiate(newObjectsMap);
-            return copy;
-        }
-    }
-}
-
-// const canClone = (value: any) => value.isVector4 || value.isVector3 || value.isVector2 || value.isQuaternion || value.isEuler || value.isColor === true;
+// Reference resolution is now handled by the unified module: engine_instantiate_resolve.ts

package/src/engine/engine_gltf_builtin_components.ts

@@ -5,6 +5,7 @@ import { LogType, showBalloonMessage } from "./debug/index.js";
 import { addNewComponent } from "./engine_components.js";
 import { builtinComponentKeyName, editorGuidKeyName } from "./engine_constants.js";
 import { debugExtension } from "./engine_default_parameters.js";
+import { generateGuidsForHierarchy, resolveStringGuidsInHierarchy, originalComponentNameKey } from "./engine_instantiate_resolve.js";
 import { InstantiateIdProvider } from "./engine_networking_instantiate.js"
 import { isLocalNetwork } from "./engine_networking_utils.js";
 import { deserializeObject, serializeObject } from "./engine_serialization.js";
@@ -98,88 +99,18 @@ export async function createBuiltinComponents(context: Context, gltfId: SourceId
         // doing it here at the end of resolving of references should ensure that
         // and this should run before awake and onenable of newly created components
         if (idProvider) {
-            // TODO: should we do this after setup callbacks now?
             const guidsMap: GuidsMap = {};
-            const resolveGuids: IHasResolveGuids[] = [];
-            // TODO: when is the gltf here an object3d?
-            recursiveCreateGuids(gltf as any, idProvider, guidsMap, resolveGuids);
+            generateGuidsForHierarchy(gltf as any, idProvider, guidsMap);
             for (const scene of gltf.scenes)
-                recursiveCreateGuids(scene, idProvider, guidsMap, resolveGuids);
-            // make sure to resolve all guids AFTER new guids have been assigned
-            for (const res of resolveGuids) {
-                res.resolveGuids(guidsMap);
-            }
+                generateGuidsForHierarchy(scene, idProvider, guidsMap);
+            // Resolve string guid references in component fields (e.g. PlayableDirector track.outputs)
+            resolveStringGuidsInHierarchy(gltf as any, guidsMap);
+            for (const scene of gltf.scenes)
+                resolveStringGuidsInHierarchy(scene, guidsMap);
         }
     });
 }
 
-declare type IHasResolveGuids = {
-    resolveGuids: (guidsMap: GuidsMap) => void;
-}
-
-const originalComponentNameKey = Symbol("original-component-name");
-
-/** 
- * We want to create one id provider per component
- * If a component is used multiple times we want to create a new id provider for each instance
- * That way the order of components in the scene doesnt affect the result GUID
- */
-// TODO: clear this when re-loading the context
-const idProviderCache = new Map<string, InstantiateIdProvider>();
-
-function recursiveCreateGuids(obj: Object3D, idProvider: UIDProvider | null, guidsMap: GuidsMap, resolveGuids: IHasResolveGuids[]) {
-    if (idProvider === null) return;
-    if (!obj) return;
-    const prev = obj.guid;
-
-    // we also want to use the idproviderCache for objects because they might be removed or re-ordered in the scene hierarchy
-    // in which case we dont want to e.g. change the syncedInstantiate objects that get created because suddenly another object has that guid
-    const idProviderKey = obj.guid;
-    if (idProviderKey?.length) {
-        if (!idProviderCache.has(idProviderKey)) {
-            if (debug) console.log("Creating InstanceIdProvider with key \"" + idProviderKey + "\" for object " + obj.name);
-            idProviderCache.set(idProviderKey, new InstantiateIdProvider(idProviderKey));
-        }
-    }
-    const objectIdProvider = idProviderKey && idProviderCache.get(idProviderKey) || idProvider;
-
-    obj.guid = objectIdProvider.generateUUID();
-    if (prev && prev !== "invalid")
-        guidsMap[prev] = obj.guid;
-
-    // console.log(obj);
-    if (obj && obj.userData && obj.userData.components) {
-        for (const comp of obj.userData.components) {
-            if (comp === null) continue;
-
-            // by default we use the component guid as a key - order of the components in the scene doesnt matter with this approach
-            // this is to prevent cases where multiple GLBs are loaded with the same component guid
-            const idProviderKey = comp.guid;
-            if (idProviderKey) {
-                if (!idProviderCache.has(idProviderKey)) {
-                    if (debug) console.log("Creating InstanceIdProvider with key \"" + idProviderKey + "\" for component " + comp[originalComponentNameKey]);
-                    idProviderCache.set(idProviderKey, new InstantiateIdProvider(idProviderKey));
-                }
-            }
-            else if (debug) console.warn("Can not create IdProvider: component " + comp[originalComponentNameKey] + " has no guid", comp.guid);
-            const componentIdProvider = idProviderCache.get(idProviderKey) || idProvider
-
-            const prev = comp.guid;
-            comp.guid = componentIdProvider.generateUUID();
-            if (prev && prev !== "invalid")
-                guidsMap[prev] = comp.guid;
-            if (comp.resolveGuids)
-                resolveGuids.push(comp);
-        }
-
-    }
-    if (obj.children) {
-        for (const child of obj.children) {
-            recursiveCreateGuids(child as IGameObject, idProvider, guidsMap, resolveGuids);
-        }
-    }
-}
-
 declare interface IGltfbuiltinComponent {
     name: string;
 }