@needle-tools/engine 4.1.0-beta.5 → 4.1.0-beta.8

package/plugins/next/next.js

@@ -2,8 +2,9 @@ import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 import { tryGetNeedleEngineVersion } from '../common/version.js';
 import { tryGetGenerator } from '../common/generator.js';
-import { getMeta } from '../common/config.cjs';
+import { getConfig, getMeta } from '../common/config.cjs';
 import { alias } from './alias.cjs';
+import { createBuildInfoFile } from '../common/buildinfo.js';
 
 
 const __filename = fileURLToPath(import.meta.url);
@@ -24,12 +25,37 @@ export const needleNext = (nextConfig, userSettings) => {
             reactStrictMode: true,
         };
 
+    const needleConfig = getConfig();
+
     // add transpile packages
     if (!nextConfig.transpilePackages) {
         nextConfig.transpilePackages = [];
     }
     nextConfig.transpilePackages.push("three", "peerjs", "three-mesh-ui");
 
+    if (nextConfig.output === undefined) {
+        console.log("Set output to 'export' (see 'https://nextjs.org/docs/pages/building-your-application/deploying/static-exports#configuration' for more information)");
+        nextConfig.output = "export";
+        // we *also* need to turn OFF image optimization for static HTML files to be generated
+        // see https://github.com/vercel/next.js/issues/40240
+        if (nextConfig.images === undefined) {
+            nextConfig.images = {
+                unoptimized: true
+            }
+        }
+    }
+    if (nextConfig.distDir == undefined) {
+        console.log("Export to 'dist'");
+        if (needleConfig?.buildDirectory) {
+            console.log(`Using build directory from needle config: ${needleConfig.buildDirectory}`);
+            nextConfig.distDir = needleConfig.buildDirectory;
+        }
+        else {
+            console.log("Using default build directory 'dist'. You can override the output directory via the needle config or by setting nextConfig.distDir");
+            nextConfig.distDir = "dist";
+        }
+    }
+
     // add webpack config
     if (!nextConfig.webpack) nextConfig.webpack = nextWebPack;
     else {
@@ -43,11 +69,11 @@ export const needleNext = (nextConfig, userSettings) => {
     function nextWebPack(config, { buildId, dev, isServer, defaultLoaders, webpack }) {
 
         // TODO: get public identifier key from license server
-        
+
         const meta = getMeta();
         let useRapier = true;
         if (userSettings.useRapier === false) useRapier = false;
-        else if (meta.useRapier === false) useRapier = false;
+        else if (meta && meta.useRapier === false) useRapier = false;
         // add defines
         const webpackModule = userSettings.modules?.webpack;
         const definePlugin = webpackModule && new webpackModule.DefinePlugin({
@@ -68,7 +94,6 @@ export const needleNext = (nextConfig, userSettings) => {
             test: /engine_license\.(ts|js)$/,
             loader: resolve(__dirname, 'license.cjs')
         });
-
         // add mesh bvh worker transform
         config.module.rules.push({
             test: /generateMeshBVH.worker\.js$/,
@@ -77,6 +102,24 @@ export const needleNext = (nextConfig, userSettings) => {
 
         alias(config);
 
+        // these hooks are invoked but nextjs deletes the files again:
+        // add webpack done plugin https://webpack.js.org/api/compiler-hooks/
+        // config.plugins.push({
+        //     apply(compiler) {
+        //         compiler.hooks.shutdown.tap('NeedleDonePlugin', (stats) => {
+        //             return createBuildInfoFile(nextConfig.distDir);
+        //         });
+        //     }
+        // });
+        // so as a workaround for above's problem:
+        // hook into process quit event since there doesn't seem to be a next hook for "after emit"
+        // node's beforeExit event is not called :(
+        process.on('exit', (code) => {
+            if (code === 0)
+                return createBuildInfoFile(nextConfig.distDir);
+        });
+
+
         return config;
     }
 

package/src/engine/codegen/register_types.ts

@@ -1,6 +1,6 @@
 /* eslint-disable */
 import { TypeStore } from "./../engine_typestore.js"
-
+
 // Import types
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint.js";
 import { Animation } from "../../engine-components/Animation.js";
@@ -220,7 +220,7 @@ import { XRFlag } from "../../engine-components/webxr/XRFlag.js";
 import { PlayerSync } from "../../engine-components-experimental/networking/PlayerSync.js";
 import { PlayerState } from "../../engine-components-experimental/networking/PlayerSync.js";
 import { PresentationMode } from "../../engine-components-experimental/Presentation.js";
-
+
 // Register types
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);
 TypeStore.add("Animation", Animation);

package/src/engine/engine_addressables.ts

@@ -5,10 +5,10 @@ import { destroy, type IInstantiateOptions, instantiate, InstantiateOptions, isD
 import { getLoader } from "./engine_gltf.js";
 import { processNewScripts } from "./engine_mainloop_utils.js";
 import { BlobStorage } from "./engine_networking_blob.js";
-import { registerPrefabProvider, syncInstantiate,SyncInstantiateOptions } from "./engine_networking_instantiate.js";
+import { registerPrefabProvider, syncInstantiate, SyncInstantiateOptions } from "./engine_networking_instantiate.js";
 import { SerializationContext, TypeSerializer } from "./engine_serialization_core.js";
 import { Context } from "./engine_setup.js";
-import type { IComponent, IGameObject, SourceIdentifier } from "./engine_types.js";
+import type { GLTF, IComponent, IGameObject, SourceIdentifier } from "./engine_types.js";
 
 const debug = getParam("debugaddressables");
 
@@ -140,8 +140,11 @@ export class AssetReference {
 
     private static currentlyInstantiating: Map<string, number> = new Map<string, number>();
 
+    /** @returns true if this is an AssetReference instance */
+    get isAssetReference() { return true; }
+
     /** The loaded asset */
-    get asset(): any {
+    get asset(): Object3D | null {
         return this._glbRoot ?? this._asset;
     }
 
@@ -183,7 +186,7 @@ export class AssetReference {
     private _hashedUri: string;
 
     private _isLoadingRawBinary: boolean = false;
-    private _rawBinary?: ArrayBuffer | null;
+    private _rawBinary?: ArrayBufferLike | null;
 
     /** @internal */
     constructor(uri: string, hash?: string, asset: any = null) {
@@ -197,7 +200,7 @@ export class AssetReference {
         registerPrefabProvider(this._url, this.onResolvePrefab.bind(this));
     }
 
-    private async onResolvePrefab(url: string): Promise<IGameObject | null> {
+    private async onResolvePrefab(url: string): Promise<Object3D | null> {
         if (url === this.url) {
             if (this.mustLoad) await this.loadAssetAsync();
             if (this.asset) {
@@ -208,7 +211,7 @@ export class AssetReference {
     }
 
     private get mustLoad() {
-        return !this.asset || this.asset.__destroyed === true || isDestroyed(this.asset) === true;
+        return !this.asset || (this.asset as any).__destroyed === true || isDestroyed(this.asset) === true;
     }
 
     /**
@@ -220,8 +223,8 @@ export class AssetReference {
         if (this.asset) {
             if (debug) console.log("Unload", this.asset);
             // TODO: we need a way to remove objects from the context (including components) without actually "destroying" them
-            if (this.asset.scene)
-                destroy(this.asset.scene, true, true);
+            if ("scene" in this.asset && this.asset.scene)
+                destroy(this.asset.scene as Object3D, true, true);
             destroy(this.asset, true, true);
         }
         this.asset = null;
@@ -234,7 +237,7 @@ export class AssetReference {
     }
 
     /** loads the asset binary without creating an instance */
-    async preload(): Promise<ArrayBuffer | null> {
+    async preload(): Promise<ArrayBufferLike | null> {
         if (!this.mustLoad) return null;
         if (this._isLoadingRawBinary) return null;
         if (this._rawBinary !== undefined) return this._rawBinary;
@@ -268,6 +271,10 @@ export class AssetReference {
         // we should "address" (LUL) this
         // console.log("START LOADING");
         if (this._rawBinary) {
+            if (!(this._rawBinary instanceof ArrayBuffer)) {
+                console.error("Invalid raw binary data", this._rawBinary);
+                return null;
+            }
             this._loading = getLoader().parseSync(context, this._rawBinary, this.url, null);
             this.raiseProgressEvent(new ProgressEvent("progress", { loaded: this._rawBinary.byteLength, total: this._rawBinary.byteLength }));
         }
@@ -283,7 +290,6 @@ export class AssetReference {
         this._glbRoot = this.tryGetActualGameObjectRoot(res);
         this._loading = undefined;
         if (res) {
-
             // Make sure the loaded roots all have a reference to this AssetReference
             // that was originally loading it.
             // We need this when the loaded asset is being disposed
@@ -302,10 +308,11 @@ export class AssetReference {
             }
             return this.asset;
         }
+        return null;
     }
 
     /** loads and returns a new instance of `asset` */
-    async instantiate(parent?: Object3D | IInstantiateOptions) {
+    async instantiate(parent?: Object3D | IInstantiateOptions | null) {
         return this.onInstantiate(parent, false);
     }
 
@@ -332,7 +339,7 @@ export class AssetReference {
         }
     }
 
-    private async onInstantiate(opts?: Object3D | IInstantiateOptions | SyncInstantiateOptions, networked: boolean = false, saveOnServer?: boolean) : Promise<Object3D | null> {
+    private async onInstantiate(opts?: Object3D | IInstantiateOptions | SyncInstantiateOptions | null, networked: boolean = false, saveOnServer?: boolean): Promise<Object3D | null> {
         const context = Context.Current;
 
         // clone the instantiate options immediately

package/src/engine/engine_context.ts

@@ -158,6 +158,8 @@ export class Context implements IContext {
 		// Note: this is due to a bug on OSX devices. See NE-5370
 		powerPreference: (DeviceUtilities.isiOS() || DeviceUtilities.isMacOS()) ? "default" : "high-performance",
 		stencil: true,
+		// logarithmicDepthBuffer: true,
+		// reverseDepthBuffer: true, // https://github.com/mrdoob/three.js/issues/29770
 	};
 	/** The default parameters that will be used when creating a new WebGLRenderer.  
 	 * Modify in global context to change the default parameters for all new contexts.

package/src/engine/engine_gameobject.ts

@@ -1,5 +1,6 @@
 import { Bone, Object3D, Quaternion, SkinnedMesh, Vector3 } from "three";
 
+import { type AssetReference } from "./engine_addressables.js";
 import { __internalNotifyObjectDestroyed as __internalRemoveReferences, disposeObjectResources } from "./engine_assetdatabase.js";
 import { ComponentLifecycleEvents } from "./engine_components_internal.js";
 import { activeInHierarchyFieldName } from "./engine_constants.js";
@@ -10,7 +11,7 @@ import { InstantiateIdProvider } from "./engine_networking_instantiate.js";
 import { assign } from "./engine_serialization_core.js";
 import { Context, registerComponent } from "./engine_setup.js";
 import { 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, IEventList, type IGameObject as GameObject, type UIDProvider } from "./engine_types.js";
 import { getParam, tryFindObject } from "./engine_utils.js";
 import { apply } from "./js-extensions/index.js";
 
@@ -307,9 +308,17 @@ declare type InstantiateReferenceMap = Record<string, ObjectCloneReference>;
  */
 export declare type InstantiateContext = Readonly<InstantiateReferenceMap>;
 
-export function instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
+export function instantiate(instance: AssetReference, opts?: IInstantiateOptions | null): Promise<Object3D | null>
+export function instantiate(instance: GameObject | Object3D, opts?: IInstantiateOptions | null): GameObject
+export function instantiate(instance: AssetReference | GameObject | Object3D, opts?: IInstantiateOptions | null | undefined): GameObject | Promise<Object3D | null> {
+
+    if ("isAssetReference" in instance) {
+        return instance.instantiate(opts ?? undefined);
+    }
+
     let options: InstantiateOptions | null = null;
-    if (opts !== null) {
+
+    if (opts !== null && opts !== undefined) {
         // if x is defined assume this is a vec3 - this is just to not break everything at once and stay a little bit backwards compatible
         if (opts["x"] !== undefined) {
             options = new InstantiateOptions();

package/src/engine/engine_input.ts

@@ -36,8 +36,15 @@ export const enum InputEvents {
     KeyUp = "keyup",
     KeyPressed = "keypress"
 }
+
 /** e.g. `pointerdown` */
-export type InputEventNames = EnumToPrimitiveUnion<InputEvents>;
+type PointerEventNames = EnumToPrimitiveUnion<PointerEnumType>;
+type KeyboardEventNames = EnumToPrimitiveUnion<KeyboardEnumType>;
+export type InputEventNames = PointerEventNames | KeyboardEventNames;
+
+declare type PointerEventListener = (evt: NEPointerEvent) => void;
+declare type KeyboardEventListener = (evt: NEKeyboardEvent) => void;
+declare type InputEventListener = PointerEventListener | KeyboardEventListener;
 
 
 
@@ -217,10 +224,6 @@ export class KeyEventArgs {
 
 
 
-declare type PointerEventListener = (evt: NEPointerEvent) => void;
-declare type KeyboardEventListener = (evt: NEKeyboardEvent) => void;
-declare type InputEventListener = PointerEventListener | KeyboardEventListener;
-
 export enum InputEventQueue {
     Early = -100,
     Default = 0,
@@ -254,6 +257,8 @@ export class Input implements IInput {
      * @param callback The callback to call when the event is triggered
      * @param options The options for adding the event listener 
      */
+    addEventListener(type: PointerEventNames, callback: PointerEventListener, options?: EventListenerOptions);
+    addEventListener(type: KeyboardEventNames, callback: KeyboardEventListener, options?: EventListenerOptions);
     addEventListener(type: InputEvents | InputEventNames, callback: InputEventListener, options?: EventListenerOptions): void {
         if (!this._eventListeners[type]) this._eventListeners[type] = [];
 
@@ -284,6 +289,8 @@ export class Input implements IInput {
      * @param callback The callback to remove
      * @param options The options for removing the event listener 
      */
+    removeEventListener(type: PointerEventNames, callback: PointerEventListener, options?: EventListenerOptions);
+    removeEventListener(type: KeyboardEventNames, callback: KeyboardEventListener, options?: EventListenerOptions);
     removeEventListener(type: InputEvents | InputEventNames, callback: InputEventListener, options?: EventListenerOptions): void {
         if (!this._eventListeners[type]) return;
         if (!callback) return;

package/src/engine/engine_license.ts

@@ -6,6 +6,8 @@ import { getParam } from "./engine_utils.js";
 
 const debug = getParam("debuglicense");
 
+const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
+
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
 let NEEDLE_ENGINE_LICENSE_TYPE: string = "basic";
@@ -36,7 +38,6 @@ export function hasCommercialLicense() {
     return hasProLicense() || hasIndieLicense();
 }
 
-const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
 
 /** @internal */
 export function onLicenseCheckResultChanged(cb: (result: boolean) => void) {

package/src/engine/engine_networking_instantiate.ts

@@ -350,7 +350,7 @@ function instantiateSeeded(obj: GameObject, opts: IInstantiateOptions | null): {
     return { seed: seed, instance: instance };
 }
 
-export declare type PrefabProviderCallback = (guid: string) => Promise<GameObject | null>;
+export declare type PrefabProviderCallback = (guid: string) => Promise<Object3D | null>;
 
 const registeredPrefabProviders: { [key: string]: PrefabProviderCallback } = {};
 

package/src/engine/engine_scenetools.ts

@@ -183,10 +183,14 @@ export async function parseSync(context: Context, data: string | ArrayBuffer, pa
             // https://threejs.org/docs/#examples/en/loaders/GLTFLoader.parse
             // so we make sure that "path" is never a file path
             let gltfLoaderPath = path.split("?")[0].trimEnd();
-            if (gltfLoaderPath.endsWith(".glb") || gltfLoaderPath.endsWith(".gltf")) {
+            // This assumes that the path is a FILE path and not already a directory
+            // (it does not end with "/") – see https://linear.app/needle/issue/NE-6075
+            {
                 // strip file from path
                 const parts = gltfLoaderPath.split("/");
-                parts.pop();
+                // check if the last part is a /, otherwise remove it
+                if (parts.length > 0 && parts[parts.length - 1] !== "")
+                    parts.pop();
                 gltfLoaderPath = parts.join("/");
                 if (!gltfLoaderPath.endsWith("/")) gltfLoaderPath += "/";
             }

package/src/engine/webcomponents/needle menu/needle-menu.ts

@@ -1,7 +1,7 @@
 import type { Context } from "../../engine_context.js";
 import { hasCommercialLicense, onLicenseCheckResultChanged } from "../../engine_license.js";
 import { isLocalNetwork } from "../../engine_networking_utils.js";
-import { DeviceUtilities,getParam } from "../../engine_utils.js";
+import { DeviceUtilities, getParam } from "../../engine_utils.js";
 import { onXRSessionStart, XRSessionEventArgs } from "../../xr/events.js";
 import { ButtonsFactory } from "../buttons.js";
 import { ensureFonts, iconFontUrl, loadFont } from "../fonts.js";
@@ -256,7 +256,12 @@ export class NeedleMenuElement extends HTMLElement {
         if (!element && domElement.shadowRoot) {
             element = domElement.shadowRoot.querySelector(elementName);
         }
+        // if no needle-menu was found in the domelement then we search the document body
         if (!element) {
+            element = window.document.body.querySelector(elementName) as NeedleMenuElement | null;
+        }
+        if (!element) {
+            // OK no menu element exists yet anywhere
             element = NeedleMenuElement.create() as NeedleMenuElement;
             if (domElement.shadowRoot)
                 domElement.shadowRoot.appendChild(element);
@@ -682,14 +687,15 @@ export class NeedleMenuElement extends HTMLElement {
         });
 
         try {
-        // if the user has a license then we CAN hide the needle logo
-        onLicenseCheckResultChanged(res => {
-            if (res == true && hasCommercialLicense() && !debugNonCommercial) {
-                let visible = this._userRequestedLogoVisible;
-                if(visible === undefined) visible = false;
-                this.#onSetLogoVisible(visible);
-            }
-        });
+            // if the user has a license then we CAN hide the needle logo
+            // calling this method immediately will cause an issue with vite bundling tho
+            window.requestAnimationFrame(() => onLicenseCheckResultChanged(res => {
+                if (res == true && hasCommercialLicense() && !debugNonCommercial) {
+                    let visible = this._userRequestedLogoVisible;
+                    if (visible === undefined) visible = false;
+                    this.#onSetLogoVisible(visible);
+                }
+            }));
         } catch (e) {
             console.error("[Needle Menu] License check failed.", e);
         }
@@ -824,7 +830,7 @@ export class NeedleMenuElement extends HTMLElement {
         this.logoContainer.style.display = "";
         this.logoContainer.style.opacity = "1";
         this.logoContainer.style.visibility = "visible";
-        if(visible) { 
+        if (visible) {
             this.root.classList.remove("logo-hidden");
             this.root.classList.add("logo-visible");
         }

package/src/engine-components/AvatarLoader.ts

@@ -52,7 +52,7 @@ export class AvatarLoader {
             if (!root) {
                 const opts = new InstantiateOptions();
                 // opts.parent = context.scene.uuid;
-                root = GameObject.instantiate(utils.tryFindObject(avatarId, context.scene), opts);
+                root = GameObject.instantiate(utils.tryFindObject(avatarId, context.scene) as Object3D, opts);
             }
         }
         else root = avatarId;

package/src/engine-components/Component.ts

@@ -1,6 +1,7 @@
 import { Euler, Object3D, Quaternion, Scene, Vector3 } from "three";
 
 import { isDevEnvironment } from "../engine/debug/index.js";
+import { type AssetReference } from "../engine/engine_addressables.js";
 import { addComponent, destroyComponentInstance, findObjectOfType, findObjectsOfType, getComponent, getComponentInChildren, getComponentInParent, getComponents, getComponentsInChildren, getComponentsInParent, getOrAddComponent, removeComponent } from "../engine/engine_components.js";
 import { activeInHierarchyFieldName } from "../engine/engine_constants.js";
 import { destroy, findByGuid, foreachComponent, HideFlags, type IInstantiateOptions, instantiate, isActiveInHierarchy, isActiveSelf, isDestroyed, isUsingInstancing, markAsInstancedRendered, setActive } from "../engine/engine_gameobject.js";
@@ -117,15 +118,20 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
      */
     public static instantiateSynced(instance: GameObject | Object3D | null, opts: SyncInstantiateOptions): GameObject | null {
         if (!instance) return null;
-        return syncInstantiate(instance as any, opts) as GameObject | null;
+        return syncInstantiate(instance, opts) as GameObject | null;
     }
 
     /** Creates a new instance of the provided object (like cloning it including all components and children) 
      * @param instance object to instantiate
      * @param opts options for the instantiation (e.g. with what parent, position, etc.)
     */
-    public static instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
-        return instantiate(instance, opts) as GameObject;
+    public static instantiate(instance: AssetReference, opts?: IInstantiateOptions | null | undefined): Promise<Object3D | null>
+    public static instantiate(instance: GameObject | Object3D, opts?: IInstantiateOptions | null | undefined): GameObject
+    public static instantiate(instance: AssetReference | GameObject | Object3D, opts: IInstantiateOptions | null | undefined = null): GameObject | Promise<Object3D | null> {
+        if ('isAssetReference' in instance) {
+            return instantiate(instance as AssetReference, opts);
+        }
+        return instantiate(instance as GameObject | Object3D, opts) as GameObject;
     }
 
     /** Destroys a object on all connected clients (if you are in a networked session) 

package/src/engine-components/SceneSwitcher.ts

@@ -760,7 +760,7 @@ export class SceneSwitcher extends Behaviour {
             }
             this._lastLoadingScene = this.loadingScene;
             if (!this._loadingScenePromise) {
-                this._loadingScenePromise = this.loadingScene?.loadAssetAsync();
+                this._loadingScenePromise = this.loadingScene?.loadAssetAsync().then(res => res != null);
             }
             await this._loadingScenePromise;
             if (this._isCurrentlyLoading && this.loadingScene?.asset) {

package/src/engine-components/webxr/Avatar.ts

@@ -101,7 +101,7 @@ export class Avatar extends Behaviour {
             headObj.quaternion.x *= -1;
 
             // HACK: XRFlag limitation workaround to make sure first person user head is never rendered
-            if (this.context.time.frameCount % 10 === 0) {
+            if (this.context.time.frameCount % 10 === 0 && this.head.asset) {
                 const xrflags = GameObject.getComponentsInChildren(this.head.asset, XRFlag);
                 for (const flag of xrflags) {
                     flag.enabled = false;
@@ -242,9 +242,9 @@ export class Avatar extends Behaviour {
         await this.loadAvatarObjects(this.head, this.leftHand, this.rightHand);
 
         this._leftHandMeshes = [];
-        this.leftHand.asset.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._leftHandMeshes!.push(obj); });
+        this.leftHand.asset?.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._leftHandMeshes!.push(obj as Mesh); });
         this._rightHandMeshes = [];
-        this.rightHand.asset.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._rightHandMeshes!.push(obj); });
+        this.rightHand.asset?.traverse((obj) => { if ((obj as Mesh)?.isMesh) this._rightHandMeshes!.push(obj as Mesh); });
 
         if (PlayerState.isLocalPlayer(this.gameObject)) {
             this._syncTransforms = GameObject.getComponentsInChildren(this.gameObject, SyncedTransform);

package/src/engine-components/webxr/WebXRImageTracking.ts

@@ -4,6 +4,7 @@ import { Object3DEventMap } from "three";
 import { isDevEnvironment, showBalloonWarning } from "../../engine/debug/index.js";
 import { AssetReference } from "../../engine/engine_addressables.js";
 import { serializable } from "../../engine/engine_serialization.js";
+import { IGameObject } from "../../engine/engine_types.js";
 import { CircularBuffer, DeviceUtilities, getParam } from "../../engine/engine_utils.js";
 import { type NeedleXREventArgs, NeedleXRSession } from "../../engine/xr/api.js";
 import { IUSDExporterExtension } from "../../engine-components/export/usdz/Extension.js";
@@ -355,7 +356,7 @@ export class WebXRImageTracking extends Behaviour {
         }
     }
 
-    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: GameObject | null, frames: number, lastTrackingTime: number }>();
+    private readonly imageToObjectMap = new Map<WebXRImageTrackingModel, { object: Object3D | null, frames: number, lastTrackingTime: number }>();
     private readonly currentImages: WebXRTrackedImage[] = [];
 
     
@@ -456,7 +457,7 @@ export class WebXRImageTracking extends Behaviour {
                 trackedData = { object: null, frames: 0, lastTrackingTime: Date.now() };
                 this.imageToObjectMap.set(model, trackedData);
 
-                model.object.loadAssetAsync().then((asset: GameObject | null) => {
+                model.object.loadAssetAsync().then((asset: Object3D | null) => {
                     if (model.createObjectInstance && asset) {
                         asset = GameObject.instantiate(asset);
                     }
@@ -475,7 +476,7 @@ export class WebXRImageTracking extends Behaviour {
                         if (xr.rig) {
                             xr.rig.gameObject.add(asset);
                             image.applyToObject(asset);
-                            if (!asset.activeSelf)
+                            if (!(asset as IGameObject).activeSelf)
                                 GameObject.setActive(asset, true);
                             // InstancingUtil.markDirty(asset);
                         }
@@ -503,7 +504,7 @@ export class WebXRImageTracking extends Behaviour {
                     xr.rig.gameObject.add(trackedData.object);
 
                     image.applyToObject(trackedData.object, this.smooth ? this.context.time.deltaTimeUnscaled * 3 : undefined);
-                    if (!trackedData.object.activeSelf) {
+                    if (!(trackedData.object as IGameObject).activeSelf) {
                         GameObject.setActive(trackedData.object, true);
                     }
                     // InstancingUtil.markDirty(trackedData.object);

package/src/engine-components-experimental/networking/PlayerSync.ts

@@ -36,7 +36,7 @@ export class PlayerSync extends Behaviour {
         const assetReference = AssetReference.getOrCreateFromUrl(url);
         if (!assetReference.asset) {
             const i = await assetReference.loadAssetAsync();
-            GameObject.getOrAddComponent(i, PlayerState);
+            if(i) GameObject.getOrAddComponent(i, PlayerState);
         }
         const ps = new PlayerSync();
         ps._internalInit(init);