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

package/src/engine/engine_networking_blob.ts

@@ -1,11 +1,9 @@
-import * as _md5 from "md5";
-// CJS interop: md5 may appear as { default: fn } or fn depending on bundler
-const md5 = typeof _md5 === "function" ? _md5 : (_md5 as any).default;
 import { FileLoader } from "three";
 
 import { showBalloonWarning } from "./debug/index.js";
 import { hasCommercialLicense } from "./engine_license.js";
 import { delay } from "./engine_utils.js";
+import { md5AsBytes, md5Hex, sha256Base64 } from "./engine_utils_hash.js";
 
 
 export namespace BlobStorage {
@@ -22,21 +20,17 @@ export namespace BlobStorage {
     /**
      * Generates an md5 hash from a given buffer
      * @param buffer The buffer to hash
-     * @returns The md5 hash
+     * @returns The md5 hash as a hex string
      */
     export function hashMD5(buffer: ArrayBuffer): string {
-        return md5(new Uint8Array(buffer))
+        return md5Hex(new Uint8Array(buffer));
     }
     export function hashMD5_Base64(buffer: ArrayBuffer): string {
-        const bytes = md5(new Uint8Array(buffer), { encoding: "binary", asBytes: true });
+        const bytes = md5AsBytes(new Uint8Array(buffer));
         return btoa(String.fromCharCode(...bytes));
     }
     export function hashSha256(buffer: ArrayBuffer): Promise<string> {
-        const bytes = new Uint8Array(buffer);
-        const hash = crypto.subtle.digest('SHA-256', bytes).then(res => {
-            return btoa(String.fromCharCode(...new Uint8Array(res)));
-        })
-        return hash;
+        return sha256Base64(buffer);
     }
 
     export type Upload_Result = {

package/src/engine/engine_physics_rapier.ts

@@ -44,9 +44,6 @@ const $bodyKey = Symbol("physics body");
 const $colliderRigidbody = Symbol("rigidbody");
 
 
-declare const NEEDLE_USE_RAPIER: boolean;
-globalThis["NEEDLE_USE_RAPIER"] = globalThis["NEEDLE_USE_RAPIER"] !== undefined ? globalThis["NEEDLE_USE_RAPIER"] : true;
-
 /** Register the Rapier physics backend. Called from {@link initEngine}
  * to ensure it runs regardless of tree-shaking. */
 export function initPhysics() {

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

@@ -0,0 +1,136 @@
+import type { SceneData } from "needle-bindings";
+export type { SceneData };
+import { isDevEnvironment } from "./debug/index.js";
+import { getComponent } from "./engine_components.js";
+import { ContextRegistry } from "./engine_context_registry.js";
+import type { IContext } from "./engine_types.js";
+import { TypeStore } from "./engine_typestore.js";
+
+/**
+ * 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.
+ *
+ * Safe to import at module level, including in SSR environments.
+ * For pages with multiple `<needle-engine>` elements, use `ctx` directly instead.
+ *
+ * @experimental This API may change in future releases.
+ *
+ * @example
+ * import { needle } from "@needle-tools/engine";
+ * button.onclick = () => {
+ *   needle.sceneData.Camera.OrbitControls.autoRotate = true;
+ * };
+ */
+export const needle: IContext = new Proxy({} as IContext, {
+    get(_target, prop: string) {
+        if (prop === "then") return undefined; // not a Promise
+        const ctx = ContextRegistry.Current;
+        if (!ctx) {
+            const fn = isDevEnvironment() ? console.error : console.warn;
+            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];
+        return typeof val === "function" ? val.bind(ctx) : val;
+    },
+    set(_target, prop: string, value: unknown) {
+        const ctx = ContextRegistry.Current;
+        if (!ctx) {
+            const fn = isDevEnvironment() ? console.error : console.warn;
+            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;
+        return true;
+    },
+});
+
+const cache = new WeakMap<IContext, SceneData>();
+
+/**
+ * Returns a proxy that silently absorbs any property get/set and logs a
+ * developer-friendly warning. Used when a node or component lookup fails so
+ * that chained access like `ctx.sceneData.Foo.Bar.baz = 1` never throws.
+ */
+function makeErrorProxy(message: string): object {
+    const handler: ProxyHandler<object> = {
+        get(_t, prop: string) {
+            if (prop === "then") return undefined; // not a Promise
+            const fn = isDevEnvironment() ? console.error : console.warn;
+            fn(`[SceneData] ${message}`);
+            return makeErrorProxy(message);
+        },
+        set(_t, prop: string) {
+            const fn = isDevEnvironment() ? console.error : console.warn;
+            fn(`[SceneData] ${message} (tried to set "${prop}")`);
+            return true; // suppress TypeError
+        },
+    };
+    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.
+ *
+ * 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
+ *
+ * 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, _glbName: string) {
+                // GLB name level — ignored at runtime, return node-name proxy
+                return new Proxy({}, {
+                    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`);
+                        return makeNodeProxy(ctx, node);
+                    }
+                });
+            }
+        });
+        cache.set(ctx, proxy);
+    }
+    return proxy;
+}

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -4,6 +4,7 @@ import { isDevEnvironment, showBalloonMessage, showBalloonWarning } from "../eng
 import { Behaviour, Component, GameObject } from "../engine-components/Component.js";
 import { CallInfo, EventList } from "../engine-components/EventList.js";
 import { AssetReference } from "./engine_addressables.js";
+import { AudioClip } from "./engine_audio.js";
 import { debugExtension } from "./engine_default_parameters.js";
 import { SerializationContext, TypeSerializer } from "./engine_serialization_core.js";
 import { RenderTexture } from "./engine_texture.js";
@@ -11,25 +12,7 @@ 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();
-
+// #region Color
 class ColorSerializer extends TypeSerializer {
     constructor() {
         super([Color, RGBAColor], "ColorSerializer")
@@ -52,7 +35,8 @@ class ColorSerializer extends TypeSerializer {
             return { r: data.r, g: data.g, b: data.b }
     }
 }
-export const colorSerializer = new ColorSerializer();
+
+// #region Euler
 
 class EulerSerializer extends TypeSerializer {
     constructor() {
@@ -72,12 +56,13 @@ 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;
     guid?: string;
 }
+
+// #region ObjectSerializer
 class ObjectSerializer extends TypeSerializer {
     constructor() {
         super(Object3D, "ObjectSerializer");
@@ -107,16 +92,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,9 +141,8 @@ class ObjectSerializer extends TypeSerializer {
         return undefined;
     }
 }
-export const objectSerializer = new ObjectSerializer();
-
 
+// #region ComponentSerializer
 class ComponentSerializer extends TypeSerializer {
 
     constructor() {
@@ -241,7 +215,6 @@ class ComponentSerializer extends TypeSerializer {
         }
     }
 }
-export const componentSerializer = new ComponentSerializer();
 
 
 declare class EventListData {
@@ -258,6 +231,7 @@ declare type EventListCall = {
 
 const $eventListDebugInfo = Symbol("eventListDebugInfo");
 
+// #region EventListSerializer
 class EventListSerializer extends TypeSerializer {
     constructor() {
         super([EventList]);
@@ -396,22 +370,14 @@ 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;
-}
 
+// #region RenderTextureSerializer
 export class RenderTextureSerializer extends TypeSerializer {
     constructor() {
         super([RenderTexture, WebGLRenderTarget]);
@@ -452,9 +418,8 @@ export class RenderTextureSerializer extends TypeSerializer {
         return undefined;
     }
 }
-new RenderTextureSerializer();
-
 
+// #region UriSerializer
 export class UriSerializer extends TypeSerializer {
     constructor() {
         super([URL]);
@@ -471,4 +436,56 @@ export class UriSerializer extends TypeSerializer {
         return undefined;
     }
 }
-new UriSerializer();
+
+// #region AudioClipSerializer
+class AudioClipSerializer extends TypeSerializer {
+    constructor() {
+        super([AudioClip]);
+    }
+
+    onSerialize(_data: AudioClip, _context: SerializationContext) {
+        return null;
+    }
+
+    onDeserialize(data: string, context: SerializationContext) {
+        if (typeof data === "string" && data.length > 0) {
+            const url = resolveUrl(context.gltfId, data);
+            if (url) return new AudioClip(url);
+        }
+        return undefined;
+    }
+}
+
+
+// #region Init serializer
+// 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();
+    new AudioClipSerializer();
+}

package/src/engine/engine_ssr.ts

@@ -0,0 +1,48 @@
+/**
+ * SSR-safe base classes for browser globals that are not available in Node/SSR environments.
+ *
+ * Use these instead of extending browser globals directly so that class definitions
+ * do not throw a ReferenceError at module evaluation time in SSR/Node contexts
+ * (SvelteKit, Next.js, etc.).
+ *
+ * In browser environments each constant is the real global; in SSR it falls back
+ * 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);
+
+/** SSR-safe base class for pointer events. */
+export const PointerEventBase: 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);
+
+
+
+
+// #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_three_utils.ts

@@ -493,13 +493,21 @@ void main(){
  * Utility class to perform various graphics operations like copying textures to canvas
  */
 export class Graphics {
-    private static readonly planeGeometry = new PlaneGeometry(2, 2, 1, 1);
-    private static readonly renderer: WebGLRenderer = new WebGLRenderer({ antialias: false, alpha: true });
-    private static readonly perspectiveCam = new PerspectiveCamera();
-    private static readonly orthographicCam = new OrthographicCamera();
-    private static readonly scene = new Scene();
-    private static readonly blitMaterial: BlitMaterial = new BlitMaterial();
-    private static readonly mesh: Mesh = new Mesh(Graphics.planeGeometry, Graphics.blitMaterial);
+    private static _planeGeometry: PlaneGeometry | undefined;
+    private static _renderer: WebGLRenderer | undefined;
+    private static _perspectiveCam: PerspectiveCamera | undefined;
+    private static _orthographicCam: OrthographicCamera | undefined;
+    private static _scene: Scene | undefined;
+    private static _blitMaterial: BlitMaterial | undefined;
+    private static _mesh: Mesh | undefined;
+
+    private static get planeGeometry() { return this._planeGeometry ??= new PlaneGeometry(2, 2, 1, 1); }
+    private static get renderer() { return this._renderer ??= new WebGLRenderer({ antialias: false, alpha: true }); }
+    private static get perspectiveCam() { return this._perspectiveCam ??= new PerspectiveCamera(); }
+    private static get orthographicCam() { return this._orthographicCam ??= new OrthographicCamera(); }
+    private static get scene() { return this._scene ??= new Scene(); }
+    private static get blitMaterial() { return this._blitMaterial ??= new BlitMaterial(); }
+    private static get mesh() { return this._mesh ??= new Mesh(Graphics.planeGeometry, Graphics.blitMaterial); }
 
 
     /** 

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/engine_utils.ts

@@ -597,6 +597,7 @@ export namespace DeviceUtilities {
     /** @returns `true` for MacOS or Windows devices. `false` for Hololens and other headsets. */
     export function isDesktop() {
         if (_isDesktop !== undefined) return _isDesktop;
+        if (typeof window === "undefined") return _isDesktop = false;
         const ua = window.navigator.userAgent;
         const standalone = /Windows|MacOS|Mac OS/.test(ua);
         const isHololens = /Windows NT/.test(ua) && /Edg/.test(ua) && !/Win64/.test(ua);

package/src/engine/engine_utils_hash.ts

@@ -0,0 +1,65 @@
+/**
+ * Pure-JS hashing utilities — no external dependencies, works in browser and Node/SSR.
+ */
+
+// MD5 based on the public-domain RSA Data Security MD5 algorithm.
+function md5Bytes(input: Uint8Array): number[] {
+    function safeAdd(x: number, y: number) { const lsw = (x & 0xffff) + (y & 0xffff); return ((x >> 16) + (y >> 16) + (lsw >> 16)) << 16 | lsw & 0xffff; }
+    function bitRotateLeft(num: number, cnt: number) { return num << cnt | num >>> 32 - cnt; }
+    function md5cmn(q: number, a: number, b: number, x: number, s: number, t: number) { return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); }
+    function md5ff(a: number, b: number, c: number, d: number, x: number, s: number, t: number) { return md5cmn(b & c | ~b & d, a, b, x, s, t); }
+    function md5gg(a: number, b: number, c: number, d: number, x: number, s: number, t: number) { return md5cmn(b & d | c & ~d, a, b, x, s, t); }
+    function md5hh(a: number, b: number, c: number, d: number, x: number, s: number, t: number) { return md5cmn(b ^ c ^ d, a, b, x, s, t); }
+    function md5ii(a: number, b: number, c: number, d: number, x: number, s: number, t: number) { return md5cmn(c ^ (b | ~d), a, b, x, s, t); }
+
+    const len8 = input.length;
+    const padded = new Uint8Array((Math.ceil((len8 + 9) / 64) * 64));
+    padded.set(input);
+    padded[len8] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, len8 << 3, true);
+    view.setUint32(padded.length - 4, (len8 / 0x20000000) | 0, true);
+
+    let a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476;
+    for (let i = 0; i < padded.length >> 2; i += 16) {
+        const M = (j: number) => view.getInt32((i + j) * 4, true);
+        const [oa, ob, oc, od] = [a, b, c, d];
+        a = md5ff(a,b,c,d,M(0),7,-680876936); d=md5ff(d,a,b,c,M(1),12,-389564586); c=md5ff(c,d,a,b,M(2),17,606105819); b=md5ff(b,c,d,a,M(3),22,-1044525330);
+        a=md5ff(a,b,c,d,M(4),7,-176418897); d=md5ff(d,a,b,c,M(5),12,1200080426); c=md5ff(c,d,a,b,M(6),17,-1473231341); b=md5ff(b,c,d,a,M(7),22,-45705983);
+        a=md5ff(a,b,c,d,M(8),7,1770035416); d=md5ff(d,a,b,c,M(9),12,-1958414417); c=md5ff(c,d,a,b,M(10),17,-42063); b=md5ff(b,c,d,a,M(11),22,-1990404162);
+        a=md5ff(a,b,c,d,M(12),7,1804603682); d=md5ff(d,a,b,c,M(13),12,-40341101); c=md5ff(c,d,a,b,M(14),17,-1502002290); b=md5ff(b,c,d,a,M(15),22,1236535329);
+        a=md5gg(a,b,c,d,M(1),5,-165796510); d=md5gg(d,a,b,c,M(6),9,-1069501632); c=md5gg(c,d,a,b,M(11),14,643717713); b=md5gg(b,c,d,a,M(0),20,-373897302);
+        a=md5gg(a,b,c,d,M(5),5,-701558691); d=md5gg(d,a,b,c,M(10),9,38016083); c=md5gg(c,d,a,b,M(15),14,-660478335); b=md5gg(b,c,d,a,M(4),20,-405537848);
+        a=md5gg(a,b,c,d,M(9),5,568446438); d=md5gg(d,a,b,c,M(14),9,-1019803690); c=md5gg(c,d,a,b,M(3),14,-187363961); b=md5gg(b,c,d,a,M(8),20,1163531501);
+        a=md5gg(a,b,c,d,M(13),5,-1444681467); d=md5gg(d,a,b,c,M(2),9,-51403784); c=md5gg(c,d,a,b,M(7),14,1735328473); b=md5gg(b,c,d,a,M(12),20,-1926607734);
+        a=md5hh(a,b,c,d,M(5),4,-378558); d=md5hh(d,a,b,c,M(8),11,-2022574463); c=md5hh(c,d,a,b,M(11),16,1839030562); b=md5hh(b,c,d,a,M(14),23,-35309556);
+        a=md5hh(a,b,c,d,M(1),4,-1530992060); d=md5hh(d,a,b,c,M(4),11,1272893353); c=md5hh(c,d,a,b,M(7),16,-155497632); b=md5hh(b,c,d,a,M(10),23,-1094730640);
+        a=md5hh(a,b,c,d,M(13),4,681279174); d=md5hh(d,a,b,c,M(0),11,-358537222); c=md5hh(c,d,a,b,M(3),16,-722521979); b=md5hh(b,c,d,a,M(6),23,76029189);
+        a=md5hh(a,b,c,d,M(9),4,-640364487); d=md5hh(d,a,b,c,M(12),11,-421815835); c=md5hh(c,d,a,b,M(15),16,530742520); b=md5hh(b,c,d,a,M(2),23,-995338651);
+        a=md5ii(a,b,c,d,M(0),6,-198630844); d=md5ii(d,a,b,c,M(7),10,1126891415); c=md5ii(c,d,a,b,M(14),15,-1416354905); b=md5ii(b,c,d,a,M(5),21,-57434055);
+        a=md5ii(a,b,c,d,M(12),6,1700485571); d=md5ii(d,a,b,c,M(3),10,-1894986606); c=md5ii(c,d,a,b,M(10),15,-1051523); b=md5ii(b,c,d,a,M(1),21,-2054922799);
+        a=md5ii(a,b,c,d,M(8),6,1873313359); d=md5ii(d,a,b,c,M(15),10,-30611744); c=md5ii(c,d,a,b,M(6),15,-1560198380); b=md5ii(b,c,d,a,M(13),21,1309151649);
+        a=md5ii(a,b,c,d,M(4),6,-145523070); d=md5ii(d,a,b,c,M(11),10,-1120210379); c=md5ii(c,d,a,b,M(2),15,718787259); b=md5ii(b,c,d,a,M(9),21,-343485551);
+        a=safeAdd(a,oa); b=safeAdd(b,ob); c=safeAdd(c,oc); d=safeAdd(d,od);
+    }
+    const result = new DataView(new ArrayBuffer(16));
+    result.setUint32(0, a, true); result.setUint32(4, b, true); result.setUint32(8, c, true); result.setUint32(12, d, true);
+    return Array.from(new Uint8Array(result.buffer));
+}
+
+/** Returns the MD5 hash of the given bytes as a lowercase hex string. */
+export function md5Hex(input: Uint8Array): string {
+    return md5Bytes(input).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+
+/** Returns the MD5 hash of the given bytes as a raw byte array. */
+export function md5AsBytes(input: Uint8Array): number[] {
+    return md5Bytes(input);
+}
+
+/** Returns the SHA-256 hash of the given buffer as a base64 string. */
+export function sha256Base64(buffer: ArrayBuffer): Promise<string> {
+    return crypto.subtle.digest("SHA-256", new Uint8Array(buffer)).then(res =>
+        btoa(String.fromCharCode(...new Uint8Array(res)))
+    );
+}

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

@@ -35,7 +35,7 @@ export class GenerateMeshBVHWorker extends WorkerBase {
 
             worker.onerror = e => {
 
-                reject(new Error(`[GenerateMeshBVHWorker] ${e.message || "Unknown error. Please check the server console. If you're using vite try adding 'three-mesh-bvh' to 'optimizeDeps.exclude' in your vite.config.js"}`));
+                reject(new Error(`[GenerateMeshBVHWorker] ${e.message || "Could not load worker."}`));
             
 			};
 

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

@@ -1,7 +1,9 @@
 import { madeWithNeedleSVG, needleLogoOnlySVG, needleLogoSVG } from "../assets/index.js";
+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;
@@ -12,7 +14,7 @@ declare global {
  * Needle logo web component used in the hosting UI (small, compact logo or full)
  * @element needle-logo-element
  */
-export class NeedleLogoElement extends HTMLElement {
+export class NeedleLogoElement extends HTMLElementBase {
 
     static get elementName() { return elementName; }
 

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

@@ -2,6 +2,7 @@ import { showBalloonMessage } from "../../debug/debug.js";
 import type { Context } from "../../engine_context.js";
 import { hasCommercialLicense, onLicenseCheckResultChanged, Telemetry } from "../../engine_license.js";
 import { isLocalNetwork } from "../../engine_networking_utils.js";
+import { HTMLElementBase } from "../../engine_ssr.js";
 import { DeviceUtilities, getParam } from "../../engine_utils.js";
 import { onXRSessionStart, XRSessionEventArgs } from "../../xr/events.js";
 import { ButtonsFactory } from "../buttons.js";
@@ -11,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;
     }
 }
 
@@ -303,7 +305,7 @@ export class NeedleMenu {
  *
  * @element needle-menu
  */
-export class NeedleMenuElement extends HTMLElement {
+export class NeedleMenuElement extends HTMLElementBase {
 
     static create() {
         // Ensure the element is registered before creating — guards against