@needle-tools/engine 5.1.0-experimental.03e8105 → 5.1.0-experimental.08fa2ef

package/plugins/dts-generator/index.js

@@ -0,0 +1,36 @@
+// @ts-check
+/**
+ * Needle Engine — HTML binding DTS generator
+ *
+ * Scans all GLB/glTF files in the project's assets directory, extracts
+ * NEEDLE_components data, and emits a `needle-bindings.d.ts` virtual-module
+ * declaration so that TypeScript can type-check HTML ↔ 3D component bindings.
+ *
+ * Typical generated output:
+ *
+ *   declare module "needle-bindings" {
+ *     interface SceneData {
+ *       Sphere: {
+ *         MyBall: { speed: number; label: string; };
+ *       };
+ *     }
+ *   }
+ *
+ * How component field types are resolved:
+ *   - For built-in Needle Engine components, types are read from
+ *     `components.needle.json` which lists only @serializable fields with
+ *     their proper TypeScript types.
+ *   - For user-defined components (not in the manifest), types are inferred
+ *     from the JSON value in the GLB (number/string/boolean → typed, else → unknown).
+ *   - Known Three.js types (Color, Vector3, Object3D, …) are emitted as
+ *     `import("three").TypeName` and known Needle types (RGBAColor, AssetReference, …)
+ *     as `import("@needle-tools/engine").TypeName`.
+ *   - Truly unknown types fall back to `unknown`.
+ */
+
+export { resolveEntrypointGlbs, collectSceneFiles } from './glb.discovery.js';
+export { readGlbJsonChunk, readGltfJsonFile, readRemoteGlbJsonChunk } from './glb.reader.js';
+export { extractComponentBindings, sanitizeNodeName, inferNodeThreeType, inferTsType } from './glb.extractor.js';
+export { scanBindings } from './dts.scan.js';
+export { generateDts, generateHtmlCustomData } from './dts.codegen.js';
+export { generateBindingsDts } from './dts.writer.js';

package/plugins/dts-generator/manifest.types.js

@@ -0,0 +1,174 @@
+// @ts-check
+/**
+ * Type tables and components.needle.json manifest loader.
+ *
+ * Knows about primitive TS types, known Three.js types, known Needle Engine
+ * types, and how to resolve field types from the manifest.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/** Primitive TS type strings that can safely appear in an ambient declaration. */
+export const PRIMITIVE_TYPES = new Set(["number", "string", "boolean"]);
+
+/**
+ * Known Three.js types → import("three").TypeName
+ * @type {Record<string, string>}
+ */
+export const THREE_TYPES = {
+    Color: `import("three").Color`,
+    ColorRepresentation: `import("three").ColorRepresentation`,
+    Euler: `import("three").Euler`,
+    Texture: `import("three").Texture`,
+    // Materials
+    Material: `import("three").Material`,
+    MeshStandardMaterial: `import("three").MeshStandardMaterial`,
+    // Objects
+    Object3D: `import("three").Object3D`,
+    Mesh: `import("three").Mesh`,
+    SkinnedMesh: `import("three").SkinnedMesh`,
+    // Other
+    Vector2: `import("three").Vector2`,
+    Vector3: `import("three").Vector3`,
+    Vector4: `import("three").Vector4`,
+    Matrix3: `import("three").Matrix3`,
+    Matrix4: `import("three").Matrix4`,
+    Quaternion: `import("three").Quaternion`,
+    // Animation
+    AnimationClip: `import("three").AnimationClip`,
+    AnimationMixer: `import("three").AnimationMixer`,
+};
+
+/**
+ * Known Needle Engine types → import("@needle-tools/engine").TypeName
+ * @type {Record<string, string>}
+ */
+export const NEEDLE_TYPES = {
+    AssetReference: `import("@needle-tools/engine").AssetReference`,
+    EventList: `import("@needle-tools/engine").EventList`,
+    GameObject: `import("@needle-tools/engine").GameObject`,
+    LookAtConstraint: `import("@needle-tools/engine").LookAtConstraint`,
+    RGBAColor: `import("@needle-tools/engine").RGBAColor`,
+    RenderTexture: `import("@needle-tools/engine").RenderTexture`,
+    Renderer: `import("@needle-tools/engine").Renderer`,
+    Rigidbody: `import("@needle-tools/engine").Rigidbody`,
+    Sprite: `import("@needle-tools/engine").Sprite`,
+    Vec2: `import("@needle-tools/engine").Vec2`,
+};
+
+/**
+ * Map a single non-array, non-primitive type token to its TS representation.
+ * Returns null if unknown.
+ * @param {string} token
+ * @returns {string | null}
+ */
+function mapKnownType(token) {
+    if (token in THREE_TYPES) return THREE_TYPES[token];
+    if (token in NEEDLE_TYPES) return NEEDLE_TYPES[token];
+    return null;
+}
+
+/**
+ * Convert a manifest type string to a safe ambient TS type.
+ * Primitives and known Three.js/Needle types are resolved precisely.
+ * For unknown types on a manifest component, falls back to
+ * `import("@needle-tools/engine").ComponentName["fieldName"]`.
+ * Truly unresolvable types → "unknown".
+ *
+ * @param {string} typeStr
+ * @param {string} [componentName]  The manifest component class name (enables indexed-access fallback)
+ * @param {string} [fieldName]      The field name on that component
+ * @returns {string}
+ */
+export function manifestTypeToTs(typeStr, componentName, fieldName) {
+    const parts = typeStr.split(" | ").map(p => p.trim());
+    const safeParts = parts.map(p => {
+        if (p === "undefined" || p === "null") return p;
+        const arrayMatch = p.match(/^(number|string|boolean)\[\]$/);
+        if (arrayMatch) return p;
+        if (PRIMITIVE_TYPES.has(p)) return p;
+        const arrayTypeMatch = p.match(/^(\w+)\[\]$/);
+        if (arrayTypeMatch) {
+            const base = arrayTypeMatch[1];
+            const mapped = mapKnownType(base);
+            if (mapped) return `${mapped}[]`;
+        }
+        const known = mapKnownType(p);
+        if (known) return known;
+        return null;
+    });
+    if (safeParts.every(p => p !== null)) {
+        return /** @type {string[]} */ (safeParts).join(" | ");
+    }
+    if (componentName && fieldName) {
+        return `import("@needle-tools/engine").${componentName}["${fieldName}"]`;
+    }
+    return "unknown";
+}
+
+/**
+ * Load components.needle.json and build a lookup:
+ *   componentName → Map<fieldName, tsType>
+ * Inherited fields are flattened (inheritedFrom chain is resolved).
+ *
+ * @returns {Map<string, Map<string, string>>}
+ */
+export function loadComponentsManifest() {
+    /** @type {Map<string, Map<string, string>>} */
+    const manifest = new Map();
+    const manifestPath = join(__dirname, "../../components.needle.json");
+    if (!existsSync(manifestPath)) return manifest;
+    try {
+        /** @type {Array<{name: string, inheritedFrom?: string, children?: Array<{name: string, kind: string, type: string}>}>} */
+        const entries = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+        /** @type {Map<string, Map<string, string>>} */
+        const ownFields = new Map();
+        /** @type {Map<string, string>} */
+        const inheritedFrom = new Map();
+        for (const entry of entries) {
+            if (!entry.name) continue;
+            inheritedFrom.set(entry.name, entry.inheritedFrom || "");
+            /** @type {Map<string, string>} */
+            const fields = new Map();
+            if (Array.isArray(entry.children)) {
+                for (const child of entry.children) {
+                    if (child.kind === "property" && child.name && child.type) {
+                        fields.set(child.name, manifestTypeToTs(child.type, entry.name, child.name));
+                    }
+                }
+            }
+            ownFields.set(entry.name, fields);
+        }
+
+        /** @param {string} name @returns {Map<string, string>} */
+        function resolveFields(name) {
+            if (manifest.has(name)) return /** @type {Map<string, string>} */ (manifest.get(name));
+            const own = ownFields.get(name) ?? new Map();
+            const parent = inheritedFrom.get(name);
+            if (parent && ownFields.has(parent)) {
+                const parentFields = resolveFields(parent);
+                const merged = new Map([...parentFields, ...own]);
+                manifest.set(name, merged);
+                return merged;
+            }
+            manifest.set(name, own);
+            return own;
+        }
+
+        for (const name of ownFields.keys()) {
+            resolveFields(name);
+        }
+    } catch (e) {
+        console.warn("[needle:dts-generator] Failed to load components.needle.json:", (/** @type {any} */ (e))?.message ?? e);
+    }
+    return manifest;
+}
+
+/** @type {Map<string, Map<string, string>>} */
+export const componentsManifest = loadComponentsManifest();

package/plugins/gltf-packer.mjs

@@ -0,0 +1 @@
+console.error('ERR: this is an old version of the gltf packer, please update gltf-pack in your package.json. The pack-gltf script should now look something like this: "npm run pack-gltf --prefix node_modules/@needle-tools/engine" \nSee the ExportInfo component for more info.');

package/plugins/vite/license.js

@@ -33,10 +33,6 @@ export function needleLicense(command, config, userSettings) {
 
         },
         async transform(src, id) {
-            if (appliedLicense === true) {
-                return;
-            }
-
             // Vite 4 and 8 handling:
             const isNeedleEngineFile = id.includes("engine/engine_license")
                 || id.includes("needle-tools_engine")
@@ -53,12 +49,12 @@ export function needleLicense(command, config, userSettings) {
                 let modified = false;
 
                 // Replace license type
-                const index = src.indexOf("_PQYikbj");
+                const index = src.indexOf("_TqYlV");
                 if (index >= 0) {
                     const end = src.indexOf(";", index);
                     if (end >= 0) {
                         const line = src.substring(index, end);
-                        const replaced = "_PQYikbj = \"" + licenseResult.type + "\"";
+                        const replaced = "_TqYlV = \"" + licenseResult.type + "\"";
                         src = src.replace(line, replaced);
                         modified = true;
                     }
@@ -66,13 +62,14 @@ export function needleLicense(command, config, userSettings) {
 
                 // Replace license JWT (same pattern)
                 if (licenseResult.jwt) {
-                    const jwtIndex = src.indexOf("_$QHon");
+                    const jwtIndex = src.indexOf("_GYfnW");
                     if (jwtIndex >= 0) {
                         const jwtEnd = src.indexOf(";", jwtIndex);
                         if (jwtEnd >= 0) {
                             const jwtLine = src.substring(jwtIndex, jwtEnd);
-                            const jwtReplaced = "_$QHon = \"" + licenseResult.jwt + "\"";
+                            const jwtReplaced = "_GYfnW = \"" + licenseResult.jwt + "\"";
                             src = src.replace(jwtLine, jwtReplaced);
+                            modified = true;
                         }
                     }
                 }
@@ -81,7 +78,6 @@ export function needleLicense(command, config, userSettings) {
                     appliedLicense = true;
                     return { code: src, map: null }
                 }
-                // @TODO: detect local needle engine dev setup and log error if not found
             }
         },
         buildEnd() {

package/src/engine/api.ts

@@ -230,7 +230,7 @@ export * from "./engine_input.js";
 export { InstancingUtil } from "./engine_instancing.js";
 
 /** License checking utilities */
-export { _BGpnKD, __tFkl, UFadk } from "./engine_license.js";
+export { _$MQoX, $JOB, _DTayQW } from "./engine_license.js";
 
 
 // ============================================================================

package/src/engine/engine_init.ts

@@ -8,7 +8,7 @@ import { initBuiltinTypes } from "./codegen/register_types.js";
 import { initSpatialConsole } from "./debug/debug_spatial_console.js";
 import { initAddressableSerializers } from "./engine_addressables.js";
 import { ensureAudioContextIsResumed } from "./engine_audio.js";
-import { rFPJwMWf } from "./engine_license.js";
+import { _$PUXWQ } from "./engine_license.js";
 import { initNeedleLoader } from "./engine_loaders.js";
 import { initPhysics } from "./engine_physics_rapier.js";
 import { initBuiltinSerializers } from "./engine_serialization_builtin_serializer.js";
@@ -59,5 +59,5 @@ export function initEngine() {
     initPhysics();
     initXR();
     initSpatialConsole();
-    rFPJwMWf();
+    _$PUXWQ();
 }

package/src/engine/engine_license.ts

@@ -9,19 +9,19 @@ import { getParam } from "./engine_utils.js";
 
 const debug = getParam("__debuglic__");
 
-const dXgxU: ((result: boolean) => void)[] = [];
+const $jvc: ((result: boolean) => void)[] = [];
 
 // These are modified by a bundler (e.g. vite)
 // Do not edit manually
-let _PQYikbj: string = "basic";
+let _TqYlV: string = "basic";
 // eslint-disable-next-line prefer-const -- value is replaced by the bundler at build time
-let _$QHon: string = "";
+let _GYfnW: string = "";
 if (debug) {
-    console.log("License Type: " + _PQYikbj);
-    if (_$QHon) {
-        console.log("License JWT: " + _$QHon);
+    console.log("License Type: " + _TqYlV);
+    if (_GYfnW) {
+        console.log("License JWT: " + _GYfnW);
         try {
-            const payload = JSON.parse(atob(_$QHon.split(".")[1].replace(/-/g, '+').replace(/_/g, '/')));
+            const payload = JSON.parse(atob(_GYfnW.split(".")[1].replace(/-/g, '+').replace(/_/g, '/')));
             console.log("License JWT payload:", payload);
         }
         catch { console.log("License JWT payload: (failed to decode)"); }
@@ -32,8 +32,8 @@ if (debug) {
 }
 
 /** @internal */
-export function UFadk() {
-    switch (_PQYikbj) {
+export function _DTayQW() {
+    switch (_TqYlV) {
         case "pro":
         case "enterprise":
             return true;
@@ -42,8 +42,8 @@ export function UFadk() {
 }
 
 /** @internal */
-export function __tFkl() {
-    switch (_PQYikbj) {
+export function $JOB() {
+    switch (_TqYlV) {
         case "indie":
             return true;
     }
@@ -51,8 +51,8 @@ export function __tFkl() {
 }
 
 /** @internal */
-export function rxRjHuj() {
-    switch (_PQYikbj) {
+export function __eNCB() {
+    switch (_TqYlV) {
         case "edu":
             return true;
     }
@@ -60,20 +60,20 @@ export function rxRjHuj() {
 }
 
 /** @internal */
-export function _BGpnKD() {
-    return UFadk() || __tFkl() || rxRjHuj();
+export function _$MQoX() {
+    return _DTayQW() || $JOB() || __eNCB();
 }
 
 
 /** @internal */
-export function __pLOnb(cb: (result: boolean) => void) {
-    if (UFadk() || __tFkl() || rxRjHuj())
+export function _HMnTDWqR(cb: (result: boolean) => void) {
+    if (_DTayQW() || $JOB() || __eNCB())
         return cb(true);
-    dXgxU.push(cb);
+    $jvc.push(cb);
 }
 
-function _csklVr(result: boolean) {
-    for (const cb of dXgxU) {
+function wUuS(result: boolean) {
+    for (const cb of $jvc) {
         try {
             cb(result);
         }
@@ -88,7 +88,7 @@ function _csklVr(result: boolean) {
 
 // ECDSA P-256 public key for verifying license JWTs (verification-only, safe to ship)
 /* eslint-disable no-secrets/no-secrets -- public key, not a secret */
-const _$OYBbo = {
+const $dnAvsc = {
     kty: "EC",
     crv: "P-256",
     x: "A34nyKMjhQYVgzeE4tyLUYdx34TAKogDa7v7PRaO9Lg",
@@ -112,7 +112,7 @@ function base64urlDecode(str: string): Uint8Array {
  * Verify a JWT license token and return the `type` claim if valid.
  * Returns null if the JWT is missing, malformed, or has an invalid signature.
  */
-async function GTeeZaHi(jwt: string): Promise<string | null> {
+async function __YUuTdC(jwt: string): Promise<string | null> {
     if (!jwt) return null;
     try {
         const parts = jwt.split(".");
@@ -122,7 +122,7 @@ async function GTeeZaHi(jwt: string): Promise<string | null> {
 
         const key = await crypto.subtle.importKey(
             "jwk",
-            _$OYBbo,
+            $dnAvsc,
             { name: "ECDSA", namedCurve: "P-256" },
             false,
             ["verify"]
@@ -182,23 +182,23 @@ async function GTeeZaHi(jwt: string): Promise<string | null> {
 }
 
 /** Verify the injected JWT and update the license type if valid.
- * The engine ONLY trusts the JWT — the plain _PQYikbj string is ignored. */
+ * The engine ONLY trusts the JWT — the plain _TqYlV string is ignored. */
 let _jwtVerificationPromise: Promise<void> | undefined = undefined;
-async function $sATIKYrT(): Promise<void> {
-    if (!_$QHon) {
-        // No JWT present: license stays "basic" regardless of what _PQYikbj says
-        _PQYikbj = "basic";
+async function _$tvXXHlah(): Promise<void> {
+    if (!_GYfnW) {
+        // No JWT present: license stays "basic" regardless of what _TqYlV says
+        _TqYlV = "basic";
         return;
     }
-    const verifiedType = await GTeeZaHi(_$QHon);
+    const verifiedType = await __YUuTdC(_GYfnW);
     if (verifiedType) {
-        _PQYikbj = verifiedType;
+        _TqYlV = verifiedType;
         if (debug) console.log("License type set from verified JWT: " + verifiedType);
-        _csklVr(_BGpnKD());
+        wUuS(_$MQoX());
     }
     else {
         // JWT present but invalid: reset to basic
-        _PQYikbj = "basic";
+        _TqYlV = "basic";
         if (debug) console.warn("JWT verification failed — license reset to basic");
     }
 }
@@ -270,7 +270,7 @@ export namespace Telemetry {
 
         const attribute = domElement?.getAttribute("no-telemetry");
         if (attribute === "" || attribute === "true" || attribute === "1") {
-            if (_PQYikbj === "pro" || _PQYikbj === "enterprise") {
+            if (_TqYlV === "pro" || _TqYlV === "enterprise") {
                 if (debug) console.debug("Telemetry is disabled via no-telemetry attribute");
                 return false;
             }
@@ -377,29 +377,29 @@ export namespace Telemetry {
 }
 
 
-export function rFPJwMWf() {
+export function _$PUXWQ() {
     // Start JWT verification — must be here (not top-level) to avoid tree-shaking
-    _jwtVerificationPromise = $sATIKYrT();
+    _jwtVerificationPromise = _$tvXXHlah();
 
     Telemetry.init();
     ContextRegistry.registerCallback(ContextEvent.ContextRegistered, evt => {
-        __loEAQjNJ(evt.context);
-        __msk(evt.context);
-        setTimeout(() => $tlH(evt.context), 2000);
+        $lHQle(evt.context);
+        _$dIKVrNJ(evt.context);
+        setTimeout(() => _mRKmGB(evt.context), 2000);
     });
 }
 
-export let _$YsQVksF: Promise<void> | undefined = undefined;
+export let _$vBFuyQsS: Promise<void> | undefined = undefined;
 let applicationIsForbidden = false;
 let applicationForbiddenText = "";
-async function _fYB() {
+async function _xWdntM() {
     // Only perform the runtime license check once
-    if (_$YsQVksF) return _$YsQVksF;
+    if (_$vBFuyQsS) return _$vBFuyQsS;
     // Wait for JWT verification to complete first (if running)
     if (_jwtVerificationPromise) {
         await _jwtVerificationPromise;
     }
-    if (_PQYikbj === "basic") {
+    if (_TqYlV === "basic") {
         try {
             const licenseUrl = "https://needle.tools/api/v1/needle-engine/check?location=" + encodeURIComponent(window.location.href) + "&version=" + VERSION + "&generator=" + encodeURIComponent(GENERATOR);
             const res = await fetch(licenseUrl, {
@@ -411,29 +411,29 @@ async function _fYB() {
             if (res?.status === 200) {
                 applicationIsForbidden = false;
                 if (debug) console.log("License check succeeded");
-                _PQYikbj = "pro";
-                _csklVr(true);
+                _TqYlV = "pro";
+                wUuS(true);
             }
             else if (res?.status === 403) {
-                _csklVr(false);
+                wUuS(false);
                 applicationIsForbidden = true;
                 applicationForbiddenText = await res.text();
             }
             else {
-                _csklVr(false);
+                wUuS(false);
                 if (debug) console.log("License check failed with status " + res?.status);
             }
         }
         catch (err) {
-            _csklVr(false);
+            wUuS(false);
             if (debug) console.error("License check failed", err);
         }
     }
-    else if (debug) console.log("Runtime license check is skipped because license is already applied as \"" + _PQYikbj + "\"");
+    else if (debug) console.log("Runtime license check is skipped because license is already applied as \"" + _TqYlV + "\"");
 }
-_$YsQVksF = _fYB();
+_$vBFuyQsS = _xWdntM();
 
-async function __msk(ctx: IContext) {
+async function _$dIKVrNJ(ctx: IContext) {
     function createForbiddenElement() {
         const div = document.createElement("div");
         div.className = "needle-forbidden";
@@ -498,40 +498,40 @@ async function __msk(ctx: IContext) {
     }, 500)
 }
 
-async function __loEAQjNJ(ctx: IContext) {
+async function $lHQle(ctx: IContext) {
     try {
-        if (!UFadk() && !__tFkl()) {
-            return __pJSUSLs(ctx);
+        if (!_DTayQW() && !$JOB()) {
+            return LkcJKXX(ctx);
         }
     }
     catch (err) {
         if (debug) console.log("License check failed", err)
-        return __pJSUSLs(ctx)
+        return LkcJKXX(ctx)
     }
-    if (debug) __pJSUSLs(ctx)
+    if (debug) LkcJKXX(ctx)
 }
 
 
 
-async function __pJSUSLs(ctx: IContext) {
+async function LkcJKXX(ctx: IContext) {
 
     // if the engine loads faster than the license check, we need to capture the ready event here
     let isReady = false;
     ctx.domElement.addEventListener("ready", () => isReady = true);
 
-    await _$YsQVksF?.catch(() => { });
+    await _$vBFuyQsS?.catch(() => { });
 
 
-    if (UFadk() || __tFkl()) return;
-    if (_BGpnKD() === false) _ArTbiTUU();
+    if (_DTayQW() || $JOB()) return;
+    if (_$MQoX() === false) __Dnv();
 
     // check if the engine is already ready (meaning has finished loading)
     if (isReady) {
-        _$gRXdD(ctx);
+        $ThBU(ctx);
     }
     else {
         ctx.domElement.addEventListener("ready", () => {
-            _$gRXdD(ctx);
+            $ThBU(ctx);
         });
     }
 }
@@ -539,7 +539,7 @@ async function __pJSUSLs(ctx: IContext) {
 // const licenseElementIdentifier = "needle-license-element";
 // const licenseDuration = 10000;
 // const licenseDelay = 1200;
-function _$gRXdD(ctx: IContext) {
+function $ThBU(ctx: IContext) {
 
     const style = `
         position: relative;
@@ -552,7 +552,7 @@ function _$gRXdD(ctx: IContext) {
         padding: 10px;
         padding-left: 30px;
     `;
-    if (_PQYikbj === "edu") {
+    if (_TqYlV === "edu") {
         if (navigator.webdriver) {
             console.log("This project is supported by Needle for Education – https://needle.tools");
         }
@@ -609,7 +609,7 @@ function _$gRXdD(ctx: IContext) {
         }
     }, 1000);
 
-    if (rxRjHuj()) {
+    if (__eNCB()) {
         const removeDelay = 20_000;
         setTimeout(() => {
             clearInterval(interval);
@@ -618,7 +618,7 @@ function _$gRXdD(ctx: IContext) {
             const intervalInMinutes = 5;
             setTimeout(() => {
                 if (ctx.domElement.parentNode)
-                    _$gRXdD(ctx);
+                    $ThBU(ctx);
             }, 1000 * 60 * intervalInMinutes)
         }, removeDelay);
     }
@@ -629,7 +629,7 @@ function _$gRXdD(ctx: IContext) {
 const base64Logo = "data:image/webp;base64,UklGRrABAABXRUJQVlA4WAoAAAAQAAAAHwAAHwAAQUxQSKEAAAARN6CmbSM4WR7vdARON11EBDq3fLiNbVtVzpMCPlKAEzsx0Y/x+Ovuv4dn0EFE/ydAvz6YggXzgh5sVgXM/zOC/4sii7qgGvB5N7hmuQYwkvazWAu1JPW41FXSHq6pnaQWvqYH18Fc0j1hO/BFTtIeSBlJi5w6qIIO7IOrwhFsB2Yxukif0FTRLpXswHR8MxbslKe9VZsn/Ub5C7YFOpqSTABWUDgg6AAAAFAGAJ0BKiAAIAA+7VyoTqmkpCI3+qgBMB2JbACdMt69DwMIQBLhkTO6XwY00UEDK6cNIDnuNibPf0EgAP7Y1myuiQHLDsF/0h5unrGh6WAbv7aegg2ZMd3uRKfT/3SJztcaujYfTvMXspfCTmYcoO6a+vhC3ss4M8uM58t4siiu59I4aOl59e9Sr6xoxYlHf2v+NnBNpJYeJf8jABQAId/PXuBkLEFkiCucgSGEcfhvajql/j3reCGl0M5/9gQWy7ayNPs+wlvIxFnNfSlfuND4CZOCyxOHhRqOmHN4ULHo3tCSrUNvgAA=";
 
 let lastLogTime = 0;
-async function _ArTbiTUU(_logo?: string) {
+async function __Dnv(_logo?: string) {
     const now = Date.now();
     if (now - lastLogTime < 2000) return;
     lastLogTime = now;
@@ -662,7 +662,7 @@ async function _ArTbiTUU(_logo?: string) {
 }
 
 
-async function $tlH(context: IContext) {
+async function _mRKmGB(context: IContext) {
     // We can't send beacons from cross-origin isolated pages
     if (window.crossOriginIsolated) return;
 
@@ -677,7 +677,7 @@ async function $tlH(context: IContext) {
 
             // current url without query parameters
             const currentUrl = window.location.href.split("?")[0];
-            const license = _PQYikbj;
+            const license = _TqYlV;
 
             const beaconData = {
                 license,

package/src/engine/engine_networking_blob.ts

@@ -1,7 +1,7 @@
 import { FileLoader } from "three";
 
 import { showBalloonWarning } from "./debug/index.js";
-import { _BGpnKD } from "./engine_license.js";
+import { _$MQoX } from "./engine_license.js";
 import { delay } from "./engine_utils.js";
 import { md5AsBytes, md5Hex, sha256Base64 } from "./engine_utils_hash.js";
 
@@ -45,7 +45,7 @@ export namespace BlobStorage {
      */
     export function canUpload(info: { filesize: number }) {
         const sizeInMB = info.filesize / 1024 / 1024;
-        if (_BGpnKD()) {
+        if (_$MQoX()) {
             return sizeInMB < maxSizeInMB;
         }
         return sizeInMB < maxFreeSizeInMB;
@@ -100,7 +100,7 @@ export namespace BlobStorage {
             console.warn(`Your file is too large for uploading (${filesizeInMB.toFixed(1)}MB). Max allowed size is ${maxSizeInMB}MB`);
             return null;
         }
-        else if (!_BGpnKD() && filesizeInMB > maxFreeSizeInMB) {
+        else if (!_$MQoX() && filesizeInMB > maxFreeSizeInMB) {
             if (opts?.silent !== true) showBalloonWarning(`File is too large for uploading. Please get a <a href=\"https://needle.tools/pricing\" target=\"_blank\">commercial license</a> to upload files larger than 5MB`);
             console.warn(`Your file is too large for uploading (${filesizeInMB.toFixed(1)}MB). Max size is 5MB for non-commercial users. Please get a commercial license at https://needle.tools/pricing for larger files (up to 50MB)`);
             return null;