@needle-tools/engine 5.1.0-canary.db0c38f → 5.1.0-canary.deec6e4

package/src/engine/engine_license.ts

@@ -1,6 +1,3 @@
-import { dof } from "three/src/nodes/TSL.js";
-
-import { isDevEnvironment } from "./debug/index.js";
 import { BUILD_TIME, GENERATOR, PUBLIC_KEY, VERSION } from "./engine_constants.js";
 import { ContextEvent, ContextRegistry } from "./engine_context_registry.js";
 import { onInitialized } from "./engine_lifecycle_api.js";
@@ -8,7 +5,7 @@ import { isLocalNetwork } from "./engine_networking_utils.js";
 import { Context } from "./engine_setup.js";
 import type { IContext } from "./engine_types.js";
 import { getParam } from "./engine_utils.js";
-import { InternalAttributeUtils } from "./engine_utils_attributes.js";
+import { SSR } from "./engine_ssr.js";
 
 const debug = getParam("debuglicense");
 
@@ -90,7 +87,9 @@ export namespace Telemetry {
         });
     }
 
-    onInitialized((ctx => sendPageViewEvent(ctx)), { once: true });
+    export function init() {
+        if(!SSR) onInitialized((ctx => sendPageViewEvent(ctx)), { once: true });
+    }
 
     function sendPageViewEvent(ctx: IContext): Promise<void> | void {
         if (!isAllowed(ctx)) {
@@ -243,11 +242,14 @@ export namespace Telemetry {
 }
 
 
-ContextRegistry.registerCallback(ContextEvent.ContextRegistered, evt => {
-    showLicenseInfo(evt.context);
-    handleForbidden(evt.context);
-    setTimeout(() => sendUsageMessageToAnalyticsBackend(evt.context), 2000);
-});
+export function initLicense() {
+    Telemetry.init();
+    ContextRegistry.registerCallback(ContextEvent.ContextRegistered, evt => {
+        showLicenseInfo(evt.context);
+        handleForbidden(evt.context);
+        setTimeout(() => sendUsageMessageToAnalyticsBackend(evt.context), 2000);
+    });
+}
 
 export let runtimeLicenseCheckPromise: Promise<void> | undefined = undefined;
 let applicationIsForbidden = false;

package/src/engine/engine_lifecycle_functions_internal.ts

@@ -1,5 +1,6 @@
 import { type Context, FrameEvent } from "./engine_context.js";
 import { ContextEvent } from "./engine_context_registry.js";
+import { SSR } from "./engine_ssr.js";
 
 export declare type Event = ContextEvent | FrameEvent;
 
@@ -38,6 +39,12 @@ let methodsWarningCounter = 0;
  * @param evt the event to call the function at
  */
 export function registerFrameEventCallback(cb: LifecycleMethod, evt: Event, opts?: LifecycleMethodOptions) {
+    
+    // Don't register the callback if we are in SSR, because it will never be called and might cause memory leaks
+    if(SSR) {
+        return;
+    }
+
     if (!newMethods.has(evt)) {
         newMethods.set(evt, new Array());
     }

package/src/engine/engine_pmrem.ts

@@ -1,8 +1,8 @@
 import { createLoaders } from "@needle-tools/gltf-progressive";
 import { CubeUVReflectionMapping, EquirectangularRefractionMapping, SRGBColorSpace, Texture, TextureLoader, WebGLRenderer } from "three";
-import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader";
-import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader";
-import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader";
+import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
+import { KTX2Loader } from "three/examples/jsm/loaders/KTX2Loader.js";
+import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
 
 const running: Map<string, Promise<Texture | null>> = new Map();
 

package/src/engine/engine_scenedata.ts

@@ -1,4 +1,5 @@
-import type { SceneData } from "needle:bindings";
+import type { SceneData } from "needle-bindings";
+export type { SceneData };
 import type { IContext } from "./engine_types.js";
 import { getComponent } from "./engine_components.js";
 import { TypeStore } from "./engine_typestore.js";
@@ -6,15 +7,13 @@ import { isDevEnvironment } from "./debug/index.js";
 import { ContextRegistry } from "./engine_context_registry.js";
 
 /**
- * Global proxy for the primary Needle Engine context.
- * Resolves lazily on property access via `ContextRegistry.Current` —
- * safe to import at module level, including in SSR environments
- * (returns a silent error proxy when no context is active).
+ * Quick access to the current Needle Engine context from anywhere — no need to pass `ctx` around.
+ * Use it in React/Svelte/Vue components, button handlers, or plain JavaScript.
  *
- * Use this outside of Needle component lifecycle (e.g. in Svelte/React/Vue
- * components, button handlers, or vanilla JS) instead of threading `ctx` around.
+ * Safe to import at module level, including in SSR environments.
+ * For pages with multiple `<needle-engine>` elements, use `ctx` directly instead.
  *
- * For multiple `<needle-engine>` elements on the same page, use `ctx` directly.
+ * @experimental This API may change in future releases.
  *
  * @example
  * import { needle } from "@needle-tools/engine";
@@ -28,7 +27,7 @@ export const needle: IContext = new Proxy({} as IContext, {
         const ctx = ContextRegistry.Current;
         if (!ctx) {
             const fn = isDevEnvironment() ? console.error : console.warn;
-            fn(`[needle] needle.${prop} accessed before scene started`);
+            fn(`[needle] needle.${prop} was accessed before the scene started. Use "needle" inside event handlers or callbacks, not at module top-level. For setup code use: onStart(ctx => { ... })`);
             return makeErrorProxy(`needle not ready — scene hasn't started yet`);
         }
         const val = (ctx as any)[prop];
@@ -38,7 +37,7 @@ export const needle: IContext = new Proxy({} as IContext, {
         const ctx = ContextRegistry.Current;
         if (!ctx) {
             const fn = isDevEnvironment() ? console.error : console.warn;
-            fn(`[needle] needle.${prop} set before scene started`);
+            fn(`[needle] needle.${prop} was set before the scene started. Use "needle" inside event handlers or callbacks, not at module top-level. For setup code use: onStart(ctx => { ... })`);
             return true;
         }
         (ctx as any)[prop] = value;
@@ -70,36 +69,63 @@ function makeErrorProxy(message: string): object {
     return new Proxy({}, handler);
 }
 
+/**
+ * Returns a proxy for a scene node that exposes `$object`, `$components`,
+ * and child nodes as nested properties.
+ */
+function makeNodeProxy(ctx: IContext, node: import("three").Object3D): object {
+    return new Proxy({}, {
+        get(_t, prop: string) {
+            if (prop === "$object") return node;
+            if (prop === "$components") {
+                return new Proxy({}, {
+                    get(_t2, compName: string) {
+                        if (compName === "then") return undefined;
+                        const ctor = TypeStore.get(compName);
+                        if (!ctor) return makeErrorProxy(`Component type "${compName}" not registered (node "${node.name}")`);
+                        const comp = getComponent(node, ctor);
+                        if (!comp) return makeErrorProxy(`Component "${compName}" not found on node "${node.name}"`);
+                        return comp;
+                    }
+                });
+            }
+            if (prop === "then") return undefined; // not a Promise
+            // Child node lookup by name
+            const child = node.children.find(c => c.name === prop) ?? null;
+            if (!child) {
+                const fn = isDevEnvironment() ? console.error : console.warn;
+                fn(`[SceneData] "${prop}" is not a child of "${node.name}". Use .$object to get the Three.js object or .$components.Name to access a component.`);
+                return makeErrorProxy(`"${prop}" not found on node "${node.name}"`);
+            }
+            return makeNodeProxy(ctx, child);
+        }
+    });
+}
+
 /**
  * Returns a lazily-resolved proxy typed as {@link SceneData}.
  * The proxy is cached per context — each context gets exactly one instance.
  *
- * Accessing a property traverses the scene graph on demand:
- * - First level  → find Object3D by node name
- * - Second level → getComponent by component name (via TypeStore)
- * - Third level  → read/write a field on the real component instance
+ * Shape mirrors the generated `needle-bindings.gen.d.ts`:
+ *   ctx.sceneData.MyGlb.Camera.$components.OrbitControls.autoRotate = true;
+ *   ctx.sceneData.MyGlb.Camera.$object  // → THREE.Camera
+ *   ctx.sceneData.MyGlb.UI.Button.$components.Button  // → Needle Button component
  *
- * If a node or component is not found, property accesses log a warning
- * instead of throwing, so chained access never crashes.
- *
- * @example
- * ctx.sceneData.Camera.OrbitControls.autoRotate = true;
+ * GLB name is ignored at runtime (scene is already loaded).
+ * Node lookup starts at the scene root.
  */
 export function getSceneData(ctx: IContext): SceneData {
     let proxy = cache.get(ctx);
     if (!proxy) {
         proxy = new Proxy({} as SceneData, {
-            get(_target, nodeName: string) {
+            get(_target, _glbName: string) {
+                // GLB name level — ignored at runtime, return node-name proxy
                 return new Proxy({}, {
-                    get(_target, compName: string) {
+                    get(_target, nodeName: string) {
+                        if (nodeName === "then") return undefined;
                         const node = ctx.scene.getObjectByName(nodeName) ?? null;
                         if (!node) return makeErrorProxy(`Node "${nodeName}" not found in scene`);
-                        if (compName === "$node") return node;
-                        const ctor = TypeStore.get(compName);
-                        if (!ctor) return makeErrorProxy(`Component type "${compName}" not registered (node "${nodeName}")`);
-                        const comp = getComponent(node, ctor);
-                        if (!comp) return makeErrorProxy(`Component "${compName}" not found on node "${nodeName}"`);
-                        return comp;
+                        return makeNodeProxy(ctx, node);
                     }
                 });
             }

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -11,24 +11,6 @@ import { IComponent } from "./engine_types.js";
 import { resolveUrl } from "./engine_utils.js";
 import { RGBAColor } from "./js-extensions/index.js";
 
-// export class SourcePath {
-//     src?:string
-// };
-
-// class SourcePathSerializer extends TypeSerializer{
-//     constructor(){
-//         super(SourcePath);
-//     }
-//     onDeserialize(data: any, _context: SerializationContext) {
-//         if(data.src && typeof data.src === "string"){
-//             return data.src;
-//         }
-//     }
-//     onSerialize(_data: any, _context: SerializationContext) {
-
-//     }
-// }
-// new SourcePathSerializer();
 
 class ColorSerializer extends TypeSerializer {
     constructor() {
@@ -52,7 +34,6 @@ class ColorSerializer extends TypeSerializer {
             return { r: data.r, g: data.g, b: data.b }
     }
 }
-export const colorSerializer = new ColorSerializer();
 
 class EulerSerializer extends TypeSerializer {
     constructor() {
@@ -72,7 +53,6 @@ class EulerSerializer extends TypeSerializer {
         return { x: data.x, y: data.y, z: data.z, order: data.order };
     }
 }
-export const euler = new EulerSerializer();
 
 declare type ObjectData = {
     node?: number;
@@ -107,16 +87,6 @@ class ObjectSerializer extends TypeSerializer {
                 console.warn(`Wrong usage of @serializable detected in your script \"${scriptname}\"\n\nIt looks like you used @serializable(Object3D) or @serializable(GameObject) for a prefab or scene reference which is exported to a separate glTF file.\n\nTo fix this please change your code to:\n\n@serializable(AssetReference)\n${context.path}! : AssetReference;\n\0`);
             }
             // ACTUALLY: this is already handled by the extension_utils where we resolve json pointers recursively
-            // if(data.startsWith("/nodes/")){
-            //     const node = parseInt(data.substring("/nodes/".length));
-            //     if (context.nodeToObject) {
-            //         const res = context.nodeToObject[node];
-            //         if (debugExtension)
-            //             console.log("Deserialized object reference?", data, res, context?.nodeToObject);
-            //         if (!res) console.warn("Did not find node: " + data, context.nodeToObject, context.object);
-            //         return res;
-            //     }
-            // }
             return undefined;
         }
 
@@ -166,7 +136,6 @@ class ObjectSerializer extends TypeSerializer {
         return undefined;
     }
 }
-export const objectSerializer = new ObjectSerializer();
 
 
 class ComponentSerializer extends TypeSerializer {
@@ -241,7 +210,6 @@ class ComponentSerializer extends TypeSerializer {
         }
     }
 }
-export const componentSerializer = new ComponentSerializer();
 
 
 declare class EventListData {
@@ -396,21 +364,12 @@ class EventListSerializer extends TypeSerializer {
     //     };
     // }
 }
-export const eventListSerializer = new EventListSerializer();
 
 
 /** Map<Clone, Original> texture. This is used for compressed textures (or when the GLTFLoader is cloning RenderTextures)
  * It's a weak map so we don't have to worry about memory leaks
  */
 const cloneOriginalMap = new WeakMap<Texture, Texture>();
-const textureClone = Texture.prototype.clone;
-Texture.prototype.clone = function () {
-    const clone = textureClone.call(this);
-    if (!cloneOriginalMap.has(clone)) {
-        cloneOriginalMap.set(clone, this);
-    }
-    return clone;
-}
 
 export class RenderTextureSerializer extends TypeSerializer {
     constructor() {
@@ -452,7 +411,6 @@ export class RenderTextureSerializer extends TypeSerializer {
         return undefined;
     }
 }
-new RenderTextureSerializer();
 
 
 export class UriSerializer extends TypeSerializer {
@@ -471,4 +429,35 @@ export class UriSerializer extends TypeSerializer {
         return undefined;
     }
 }
-new UriSerializer();
+
+
+// Module-level references used by EventListSerializer internally
+export let colorSerializer: ColorSerializer;
+export let objectSerializer: ObjectSerializer;
+export let componentSerializer: ComponentSerializer;
+export let eventListSerializer: EventListSerializer;
+
+/** Register all builtin serializers and prototype patches.
+ * Must be called from {@link initEngine} so the registrations survive tree-shaking
+ * when the package declares `sideEffects: false`.
+ */
+export function initBuiltinSerializers() {
+    // Prototype patches
+    const textureClone = Texture.prototype.clone;
+    Texture.prototype.clone = function () {
+        const clone = textureClone.call(this);
+        if (!cloneOriginalMap.has(clone)) {
+            cloneOriginalMap.set(clone, this);
+        }
+        return clone;
+    }
+
+    // Register all serializers
+    colorSerializer = new ColorSerializer();
+    new EulerSerializer();
+    objectSerializer = new ObjectSerializer();
+    componentSerializer = new ComponentSerializer();
+    eventListSerializer = new EventListSerializer();
+    new RenderTextureSerializer();
+    new UriSerializer();
+}

package/src/engine/engine_ssr.ts

@@ -9,14 +9,40 @@
  * to a plain empty class so that `class Foo extends HTMLElementBase` is valid.
  */
 
+
+/** True when running in an SSR/Node environment (no browser globals). */
+export const SSR: boolean = typeof window === "undefined";
+
 /** SSR-safe base class for web components. */
 export const HTMLElementBase: typeof HTMLElement =
-    typeof HTMLElement !== "undefined" ? HTMLElement : (class {} as unknown as typeof HTMLElement);
+    typeof HTMLElement !== "undefined" ? HTMLElement : (class { } as unknown as typeof HTMLElement);
 
 /** SSR-safe base class for pointer events. */
 export const PointerEventBase: typeof PointerEvent =
-    typeof PointerEvent !== "undefined" ? PointerEvent : (class {} as unknown as typeof PointerEvent);
+    typeof PointerEvent !== "undefined" ? PointerEvent : (class { } as unknown as typeof PointerEvent);
 
 /** SSR-safe base class for keyboard events. */
 export const KeyboardEventBase: typeof KeyboardEvent =
-    typeof KeyboardEvent !== "undefined" ? KeyboardEvent : (class {} as unknown as typeof KeyboardEvent);
+    typeof KeyboardEvent !== "undefined" ? KeyboardEvent : (class { } as unknown as typeof KeyboardEvent);
+
+
+
+
+// #region minimal polyfills
+// Three.js FileLoader uses ProgressEvent in fetch stream callbacks.
+// It doesn't exist in Node — install a minimal stub so SSR doesn't crash.
+if (typeof globalThis.ProgressEvent === "undefined") {
+    (globalThis as any).ProgressEvent = class ProgressEvent {
+        readonly type: string;
+        readonly lengthComputable: boolean;
+        readonly loaded: number;
+        readonly total: number;
+        constructor(type: string, init?: { lengthComputable?: boolean; loaded?: number; total?: number }) {
+            this.type = type;
+            this.lengthComputable = init?.lengthComputable ?? false;
+            this.loaded = init?.loaded ?? 0;
+            this.total = init?.total ?? 0;
+        }
+    };
+}
+// #endregion

package/src/engine/engine_types.ts

@@ -258,6 +258,8 @@ export declare interface ICameraController {
 export declare interface ILight extends IComponent {
     intensity: number;
     color: Color;
+    /** The type of light as a lowercase string: `"directional"`, `"point"`, `"spot"` */
+    readonly type: "directional" | "point" | "spot";
 }
 
 export declare interface ISharedMaterials {

package/src/engine/webcomponents/jsx.d.ts

@@ -0,0 +1,51 @@
+/**
+ * JSX IntrinsicElements declarations for Needle Engine web components.
+ *
+ * Covers both the global JSX namespace (Preact, SolidJS, Svelte, vanilla TS)
+ * and React's module-scoped JSX namespace (react-jsx / react-jsxdev transform).
+ *
+ * IMPORTANT: This file must be a module (has a top-level import/export) so that
+ * `declare module "react"` is treated as a *module augmentation* (merging into
+ * the existing React types) rather than an *ambient module declaration* (which
+ * would shadow/replace @types/react).
+ */
+
+import type { NeedleEngineAttributes } from "./needle-engine.js";
+
+interface NeedleButtonJSXAttributes extends Partial<Omit<HTMLElement, "style" | "children">> {
+    style?: Partial<CSSStyleDeclaration>;
+    ar?: boolean | string;
+    vr?: boolean | string;
+    quicklook?: boolean | string;
+    qrcode?: boolean | string;
+    unstyled?: boolean | string;
+}
+
+interface NeedleMenuJSXAttributes extends Partial<Omit<HTMLElement, "style" | "children">> {
+    style?: Partial<CSSStyleDeclaration>;
+}
+
+interface NeedleLogoElementJSXAttributes extends Partial<Omit<HTMLElement, "style" | "children">> {
+    style?: Partial<CSSStyleDeclaration>;
+}
+
+interface NeedleElements {
+    "needle-engine": Partial<NeedleEngineAttributes>;
+    "needle-button": NeedleButtonJSXAttributes;
+    "needle-menu": NeedleMenuJSXAttributes;
+    "needle-logo-element": NeedleLogoElementJSXAttributes;
+}
+
+// Global JSX namespace — Preact, SolidJS, Svelte, vanilla TS
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends NeedleElements {}
+    }
+}
+
+// React module-scoped JSX namespace (module augmentation, not ambient declaration)
+declare module "react" {
+    namespace JSX {
+        interface IntrinsicElements extends NeedleElements {}
+    }
+}

package/src/engine/webcomponents/logo-element.ts

@@ -3,6 +3,7 @@ import { HTMLElementBase } from "../engine_ssr.js";
 
 const elementName = "needle-logo-element";
 
+// NOTE: keep JSX attributes in sync with ./jsx.d.ts
 declare global {
     interface HTMLElementTagNameMap {
         "needle-logo-element": NeedleLogoElement;

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

@@ -12,9 +12,10 @@ import { NeedleLogoElement } from "../logo-element.js";
 import { getElementPriority, setElementPriority as _setElementPriority } from "./menu-priority.js";
 import { NeedleSpatialMenu } from "./needle-menu-spatial.js";
 
+// NOTE: keep JSX attributes in sync with ../jsx.d.ts
 declare global {
     interface HTMLElementTagNameMap {
-        "needle-logo-element": NeedleLogoElement;
+        "needle-menu": NeedleMenuElement;
     }
 }
 

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

@@ -4,6 +4,7 @@ import { ButtonsFactory } from "./buttons.js";
 import { iconFontUrl, loadFont } from "./fonts.js";
 import { WebXRButtonFactory } from "./WebXRButtons.js";
 
+// NOTE: keep JSX attributes in sync with ./jsx.d.ts
 declare global {
     interface HTMLElementTagNameMap {
         "needle-button": NeedleButtonElement;

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

@@ -17,6 +17,7 @@ import { arContainerClassName, AROverlayHandler } from "./needle-engine.ar-overl
 import type { registerObservableAttribute } from "./needle-engine.extras.js";
 import { calculateProgress01, EngineLoadingView, type ILoadingViewHandler } from "./needle-engine.loading.js";
 
+// NOTE: keep JSX attributes in sync with ./jsx.d.ts
 declare global {
     interface HTMLElementTagNameMap {
         "needle-engine": NeedleEngineWebComponent;

package/src/engine-components/AnimatorController.ts

@@ -1586,4 +1586,7 @@ class AnimatorControllerSerializator extends TypeSerializer {
         return undefined;
     }
 }
-new AnimatorControllerSerializator(AnimatorController);
+/** @internal */
+export function initAnimatorControllerSerializer() {
+    new AnimatorControllerSerializator(AnimatorController);
+}

package/src/engine-components/Light.ts

@@ -106,11 +106,40 @@ enum LightShadows {
 export class Light extends Behaviour implements ILight {
 
     /**
-     * The type of light (spot, directional, point, etc.)  
-     * Can not be changed at runtime.  
+     * The type of light as a lowercase string: `"directional"`, `"point"`, `"spot"`.
+     * Implements {@link ILight.type}. Can not be changed at runtime.
      */
+    get type(): ILight["type"] {
+        return this._type;
+    }
+
+    /** Numeric LightType serialized from Unity/Blender — converts to string on write */
     @serializable()
-    private type: LightType = 0;
+    set type(value: LightType | ILight["type"]) {
+        if (this.light && this.__didAwake) {
+            throw new Error("Changing the light type at runtime is not supported");
+        }
+        switch (value) {
+            case LightType.Directional:
+                this._type = "directional";
+                break;
+            case LightType.Point:
+                this._type = "point";
+                break;
+            case LightType.Spot:
+                this._type = "spot";
+                break;
+            case "directional":
+            case "point":
+            case "spot":
+                this._type = value;
+                break;
+            default:
+                throw new Error("Invalid light type: " + value);
+        }
+    }
+    private _type: ILight["type"] = "point";
+
 
     /**
      * The maximum distance the light affects.  
@@ -345,7 +374,7 @@ export class Light extends Behaviour implements ILight {
      */
     public getWorldPosition(vec: Vector3): Vector3 {
         if (this.light) {
-            if (this.type === LightType.Directional) {
+            if (this.type === "directional") {
                 return this.light.getWorldPosition(vec).multiplyScalar(1);
             }
             return this.light.getWorldPosition(vec);
@@ -372,12 +401,13 @@ export class Light extends Behaviour implements ILight {
             else if (this.light.parent !== this.gameObject)
                 this.gameObject.add(this.light);
         }
-        if (this.type === LightType.Directional)
-            this.startCoroutine(this.updateMainLightRoutine(), FrameEvent.LateUpdate);
+        this.context.lights.push(this);
     }
 
     onDisable() {
         if (debug) console.log("DISABLE LIGHT", this.name);
+        const index = this.context.lights.indexOf(this);
+        if (index !== -1) this.context.lights.splice(index, 1);
         if (this.light) {
             if (this.selfIsLight)
                 this.light.intensity = 0;
@@ -399,14 +429,14 @@ export class Light extends Behaviour implements ILight {
             this._intensity = this.light.intensity;
 
             switch (this.type) {
-                case LightType.Directional:
+                case "directional":
                     this.setDirectionalLight(this.light as DirectionalLight);
                     break;
             }
         }
         else if (!this.light) {
             switch (this.type) {
-                case LightType.Directional:
+                case "directional":
                     // console.log(this);
                     const dirLight = new DirectionalLight(this.color, this.intensity * Math.PI);
                     // directional light target is at 0 0 0 by default
@@ -425,7 +455,7 @@ export class Light extends Behaviour implements ILight {
                     }
                     break;
 
-                case LightType.Spot:
+                case "spot":
                     const spotLight = new SpotLight(this.color, this.intensity * Math.PI, this.range, toRadians(this.spotAngle / 2), 1 - toRadians(this.innerSpotAngle / 2) / toRadians(this.spotAngle / 2), 2);
                     spotLight.position.set(0, 0, 0);
                     spotLight.rotation.set(0, 0, 0);
@@ -437,7 +467,7 @@ export class Light extends Behaviour implements ILight {
                     spotLightTarget.rotation.set(0, 0, 0);
                     break;
 
-                case LightType.Point:
+                case "point":
                     const pointLight = new PointLight(this.color, this.intensity * Math.PI, this.range);
                     this.light = pointLight;
 
@@ -526,22 +556,6 @@ export class Light extends Behaviour implements ILight {
 
     }
 
-    /**
-     * Coroutine that updates the main light reference in the context
-     * if this directional light should be the main light
-     */
-    *updateMainLightRoutine() {
-        while (true) {
-            if (this.type === LightType.Directional) {
-                if (!this.context.mainLight || this.intensity > this.context.mainLight.intensity) {
-                    this.context.mainLight = this;
-                }
-                yield;
-            }
-            break;
-        }
-    }
-
     /**
      * Controls whether the renderer's shadow map type can be changed when soft shadows are used
      */

package/src/engine-components/ReflectionProbe.ts

@@ -290,6 +290,8 @@ export class ReflectionProbe extends Behaviour {
             const current = block.getOverride("envMap")?.value;
             if (current === this.texture) {
                 block.removeOveride("envMap");
+                block.removeOveride("envMapRotation");
+                block.removeOveride("envMapIntensity");
             }
         }
     }

package/src/engine-components/postprocessing/VolumeParameter.ts

@@ -156,4 +156,7 @@ class VolumeParameterSerializer extends TypeSerializer {
         return parameter;
     }
 }
-new VolumeParameterSerializer();
+/** @internal */
+export function initVolumeParameterSerializer() {
+    new VolumeParameterSerializer();
+}

package/src/needle-engine.ts

@@ -1,3 +1,6 @@
+/// <reference path="../plugins/types/needle-bindings.d.ts" />
+/// <reference path="./engine/webcomponents/jsx.d.ts" />
+
 import { initEngine } from "./engine/engine_init.js";
 initEngine();
 import "./engine/webcomponents/needle-engine.js";