@needle-tools/engine 5.1.0-canary.e9062c0 → 5.1.0-canary.f57972c

package/plugins/common/license.js

@@ -86,24 +86,38 @@ async function requestNeedleCloud(path, options) {
 
 /** @typedef {{ ok: boolean, status: number, statusText: string, text: string }} NeedleCloudHttpResponse */
 
+/** @typedef {{ type: string, jwt: string | null }} LicenseResult */
+
 /**
  * Replace license string - used for webpack
  * @param {string} code
  * @param {DefaultOptions & {accessToken?:string, team:string|undefined}} opts
  */
 export async function replaceLicense(code, opts) {
-    const index = code?.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
+    const index = code?.indexOf("_EubmJj");
     if (index >= 0) {
-        const licenseType = await resolveLicense(opts);
-        if (!licenseType) {
+        const licenseResult = await resolveLicense(opts);
+        if (!licenseResult) {
             return code;
         }
         const end = code.indexOf(";", index);
         if (end >= 0) {
             const line = code.substring(index, end);
-            const replaced = "NEEDLE_ENGINE_LICENSE_TYPE = \"" + licenseType + "\"";
+            const replaced = "_EubmJj = \"" + licenseResult.type + "\"";
             code = code.replace(line, replaced);
-            return code;
+        }
+
+        // Also inject JWT if available
+        if (licenseResult.jwt) {
+            const jwtIndex = code.indexOf("__OXddGMYg");
+            if (jwtIndex >= 0) {
+                const jwtEnd = code.indexOf(";", jwtIndex);
+                if (jwtEnd >= 0) {
+                    const jwtLine = code.substring(jwtIndex, jwtEnd);
+                    const jwtReplaced = "__OXddGMYg = \"" + licenseResult.jwt + "\"";
+                    code = code.replace(jwtLine, jwtReplaced);
+                }
+            }
         }
     }
     return code;
@@ -112,7 +126,7 @@ export async function replaceLicense(code, opts) {
 /**
  * Resolve the license using the needle engine licensing server
  * @param {DefaultOptions & {accessToken?:string, team?:string} | null} args
- * @returns {Promise<string | null>}
+ * @returns {Promise<LicenseResult | null>}
  */
 export async function resolveLicense(args = null) {
     let accessToken = args?.accessToken;
@@ -210,7 +224,7 @@ export async function resolveLicense(args = null) {
         return null;
     }
     else if (!licenseResponse.ok) {
-        if (licenseResponse.status === 500)
+        if (licenseResponse.status >= 500)
             logLicense(`ERROR: Failed to fetch license (${licenseResponse.status})`, "error");
         else
             logLicense(`No license found (${licenseResponse.status})`);
@@ -226,10 +240,11 @@ export async function resolveLicense(args = null) {
 /**
  * @param {string} str License string
  * @param {{includeFetchLine?: boolean}} [options]
+ * @returns {LicenseResult | null}
  */
 function tryParseLicense(str, options = undefined) {
     try {
-        /** @type {{needle_engine_license:string}} */
+        /** @type {{needle_engine_license:string, needle_license_jwt?:string}} */
         const licenseJson = JSON.parse(str);
         if (licenseJson.needle_engine_license) {
             const success = `INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`;
@@ -239,7 +254,10 @@ function tryParseLicense(str, options = undefined) {
             else {
                 logLicense(success);
             }
-            return licenseJson.needle_engine_license;
+            return {
+                type: licenseJson.needle_engine_license,
+                jwt: licenseJson.needle_license_jwt || null,
+            };
         }
         if ("error" in licenseJson) {
             logLicense(`ERROR in license check: \"${licenseJson.error}\"`, "error");
@@ -361,7 +379,10 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
         return null;
     }
     else if (!res.ok) {
-        logIdentifier("ERROR: Failed to fetch project identifier", "error");
+        if (res.status >= 500)
+            logIdentifier(`Failed to fetch project identifier (${res.status})`, "error");
+        else
+            logIdentifier(`No project identifier found (${res.status})`);
         await releaseResponse(res);
         return null;
     }

package/plugins/common/worker.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { needleLog } from '../vite/logging.js';
 
 
@@ -53,13 +54,17 @@ export function rollupFixWorkerImport(opts = { logFail: true }) {
                         // console.log("WORKER?", url)
                         if (url?.startsWith("/")) {
                             needleLog("rollup", `Rewrite worker import in ${chunk.fileName}`, "log", { leadingNewline: true, dimBody: false });
-                            // Make url file-relative
-                            const newUrl = url.replace(/^\//, "");
+                            // Compute the relative path from the chunk's directory to the worker file.
+                            // url is absolute from build root (e.g. "/assets/worker.js") and the chunk
+                            // may itself be inside assets/ — using path.posix.relative avoids producing
+                            // a double "assets/assets/" path.
+                            const workerPath = url.replace(/^\//, "");
+                            const chunkDir = path.posix.dirname(chunk.fileName);
+                            const relativeUrl = path.posix.relative(chunkDir, workerPath) || workerPath;
                             // For CORS issues we need to use importScripts: https://linear.app/needle/issue/NE-6572#comment-ea5dc65e
-                            const output = `/* new-worker */ new Worker(URL.createObjectURL(new Blob(["import '" + \`\${new URL('./${newUrl}', import.meta.url).toString()}\` + "';"], { type: 'text/javascript' }))`;
+                            const output = `/* new-worker */ new Worker(URL.createObjectURL(new Blob(["import '" + \`\${new URL('./${relativeUrl}', import.meta.url).toString()}\` + "';"], { type: 'text/javascript' }))`;
                             needleLog("rollup", "Did rewrite worker output to: " + output, "log", { leadingNewline: true });
                             return output;
-                            // return `new Worker(new URL("./${newUrl}", import.meta.url)`;
                         }
                         return match;
                     });

package/plugins/vite/asap.js

@@ -50,7 +50,7 @@ export async function needleAsap(command, config, userSettings) {
                 const tags = [];
 
                 try {
-                    generateGltfPreloadLinks(config, html, tags);
+                    generateGltfPreloadLinks(config, html, tags, viteConfig?.base);
                 }
                 catch (err) {
                     console.error("Error generating gltf preload links", err);
@@ -173,18 +173,21 @@ function fixMainTs() {
  * @param {import('vite').ResolvedConfig} _config
  * @param {import('vite').HtmlTagDescriptor[]} tags
  */
-function generateScriptPreloadLinks(_config, tags) {
+function generateScriptPreloadLinks(config, tags) {
     try {
+        const base = config.base || '/';
         const chunks = preloadScriptPaths;
         // console.log("ASAP", chunks)
         if (chunks.length > 0) {
             for (const chunk of chunks) {
+                // Apply base path so preload hrefs resolve correctly under SPA routing
+                const href = chunk.startsWith('./') ? base + chunk.slice(2) : chunk;
                 tags.push({
                     tag: 'link',
                     attrs: {
                         rel: "modulepreload",
                         as: "script",
-                        href: chunk,
+                        href: href,
                     }
                 });
             }
@@ -203,15 +206,16 @@ const codegenRegex = /\"(?<gltf>.+(.glb|.gltf)(\?.*)?)\"/gm;
 /**
  * @param {import('../types').needleConfig} config
  * @param {string} html
- * @param {import('vite').HtmlTagDescriptor[]} tags 
+ * @param {import('vite').HtmlTagDescriptor[]} tags
+ * @param {string} [base]
  **/
-function generateGltfPreloadLinks(config, html, tags) {
+function generateGltfPreloadLinks(config, html, tags, base) {
 
     // TODO: try to get the <needle-engine src> element src attribute and preload that
     const needleEngineMatches = tryParseNeedleEngineSrcAttributeFromHtml(html);
     if (needleEngineMatches?.length) {
         for (const item of needleEngineMatches) {
-            insertPreloadLink(tags, item, "model/gltf+json");
+            insertPreloadLink(tags, item, "model/gltf+json", base);
         }
     }
 
@@ -246,7 +250,7 @@ function generateGltfPreloadLinks(config, html, tags) {
                             }
                         }
                         needleLog("needle:asap", `Insert glTF preload link: ${value}`);
-                        insertPreloadLink(tags, value, "model/gltf+json");
+                        insertPreloadLink(tags, value, "model/gltf+json", base);
                     }
                 }
             }
@@ -258,9 +262,14 @@ function generateGltfPreloadLinks(config, html, tags) {
  * @param {import('vite').HtmlTagDescriptor[]} tags
  * @param {string} href
  * @param {string} type
+ * @param {string} [base]
  */
-function insertPreloadLink(tags, href, type) {
+function insertPreloadLink(tags, href, type, base) {
     if (!href) return;
+    // Apply base path so preload hrefs resolve correctly under SPA routing
+    if (base && !href.startsWith('http') && !href.startsWith('/')) {
+        href = base + (href.startsWith('./') ? href.slice(2) : href);
+    }
     tags.push({
         tag: 'link',
         attrs: {

package/plugins/vite/dependencies.js

@@ -61,6 +61,35 @@ export function needleDependencies(command, config, userSettings) {
                 }
             },
         },
+        // Vite 8's optimizer rebases `new URL(specifier, import.meta.url)` paths
+        // inside pre-bundled dependencies (PR #21434), but only handles truly relative
+        // paths (./  ../).  Bare-specifier paths like `three-mesh-bvh/src/workers/...`
+        // are treated as relative to the *source file* that contained the `new URL()`
+        // call, producing a wrong URL such as:
+        //   /node_modules/@needle-tools/engine/.../three-mesh-bvh/src/workers/generateMeshBVH.worker.js
+        // This middleware rewrites those broken URLs so the dev server finds the file at
+        // its real location in node_modules.
+        {
+            name: 'needle:worker-url-rewrite',
+            configureServer(server) {
+                const rewritePackages = ['three-mesh-bvh'];
+                server.middlewares.use((req, _res, next) => {
+                    if (req.url) {
+                        for (const pkg of rewritePackages) {
+                            const marker = `/${pkg}/`;
+                            if (req.url.includes(marker) && !req.url.startsWith(`/node_modules/${pkg}/`) && !req.url.startsWith('/@fs/')) {
+                                const idx = req.url.indexOf(marker);
+                                const rewritten = '/node_modules' + req.url.slice(idx);
+                                needleLog('needle-dependencies', `Rewriting worker URL → ${rewritten}`);
+                                req.url = rewritten;
+                                break;
+                            }
+                        }
+                    }
+                    next();
+                });
+            },
+        },
     ]
 }
 
@@ -158,16 +187,6 @@ function handleOptimizeDeps(config) {
             config.optimizeDeps.exclude.push('@needle-tools/engine');
             needleLog("needle-dependencies", 'Detected local @needle-tools/engine package → will exclude it from optimization');
         }
-        // When engine is excluded from optimizeDeps, three-mesh-bvh must also be excluded.
-        // The BVH worker (generateMeshBVH.worker.js) uses bare imports like `import 'three'`
-        // which only resolve correctly when served through Vite's dev server module system.
-        // If three-mesh-bvh is pre-bundled, the worker URL points into the cache and bare
-        // imports fail at runtime → "Unknown error. Please check the server console."
-        if (!config.optimizeDeps.include?.includes('three-mesh-bvh') &&
-            !config.optimizeDeps.exclude.includes('three-mesh-bvh')) {
-            config.optimizeDeps.exclude.push('three-mesh-bvh');
-            needleLog("needle-dependencies", 'Detected local @needle-tools/engine package → will also exclude three-mesh-bvh from optimization');
-        }
     }
 }
 

package/plugins/vite/dependency-watcher.js

@@ -98,7 +98,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
 
     setTimeout(() => {
         requireInstall = testIfInstallIsRequired(projectDir, packageJson);
-    }, 1000);
+    }, 1000).unref();
 
     setInterval(() => {
         if (!packageJson || lastEditTime === undefined) return;
@@ -149,7 +149,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
                 restart(server, projectDir, cachePath);
             }
         }
-    }, 2000);
+    }, 2000).unref();
 }
 
 /** @param {string} projectDir @param {PackageJson | undefined} packageJson @returns {boolean} */

package/plugins/vite/editor-connection.js

@@ -27,7 +27,7 @@ export async function editorConnection(command, config, userSettings, pluginsArr
     if (typeof config.generator === "string" && !config.generator.includes("Unity")) return;
 
     if (!config) {
-        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync can not be installed automatically to vite: missing config", "warn"), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync can not be installed automatically to vite: missing config", "warn"), 1000).unref();
         return createPlugin(false);
     }
 
@@ -42,14 +42,14 @@ export async function editorConnection(command, config, userSettings, pluginsArr
     //     }
     // }
     if (needleEditorSettings && needleEditorSettings.enabled === false) {
-        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync is not enabled. Add a 'Needle Editor Sync' component to your scene to enable", "warn"), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync is not enabled. Add a 'Needle Editor Sync' component to your scene to enable", "warn"), 1000).unref();
         return createPlugin(false);
     }
 
     // Check if the editor package is installed
     let path = root + `/node_modules/${editorSyncPackageName}/plugins/index.js`;
     if (existsSync(path) === false) {
-        setTimeout(() => needleLog("needle-editor-sync", `${editorSyncPackageName} is not installed: Add the "Needle Editor Sync" component to your scene if you want to send changes directly from the Unity Editor to web app`, "warn"), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", `${editorSyncPackageName} is not installed: Add the "Needle Editor Sync" component to your scene if you want to send changes directly from the Unity Editor to web app`, "warn"), 1000).unref();
         return createPlugin(false);
     }
 

package/plugins/vite/license.js

@@ -8,7 +8,9 @@ import { loadConfig } from './config.js';
  * @returns {import('vite').Plugin}
  */
 export function needleLicense(command, config, userSettings) {
-    let license = undefined;
+    /** @type {import('../common/license.js').LicenseResult | null | undefined} */
+    let licenseResult = undefined;
+    let appliedLicense = false;
 
     return {
         name: "needle:license",
@@ -23,7 +25,7 @@ export function needleLicense(command, config, userSettings) {
                 }
             }
 
-            license = await resolveLicense({
+            licenseResult = await resolveLicense({
                 team: team,
                 accessToken: userSettings?.license?.accessToken,
                 loglevel: userSettings?.debugLicense === true ? "verbose" : undefined
@@ -31,25 +33,58 @@ export function needleLicense(command, config, userSettings) {
 
         },
         async transform(src, id) {
-            const isNeedleEngineFile = id.includes("engine/engine_license") || id.includes("needle-tools_engine");
+            // Vite 4 and 8 handling:
+            const isNeedleEngineFile = id.includes("engine/engine_license")
+                || id.includes("needle-tools_engine")
+                || id.includes("@needle-tools")
+                || id.includes("needle-engine");
             // sometimes the actual license parameter is in a unnamed chunk file
             const isViteChunkFile = id.includes("chunk") && id.includes(".vite");
             if (isNeedleEngineFile || isViteChunkFile) {
 
-                if (!license) {
+                if (!licenseResult) {
                     return;
                 }
 
-                const index = src.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
+                let modified = false;
+
+                // Replace license type
+                const index = src.indexOf("_EubmJj");
                 if (index >= 0) {
                     const end = src.indexOf(";", index);
                     if (end >= 0) {
                         const line = src.substring(index, end);
-                        const replaced = "NEEDLE_ENGINE_LICENSE_TYPE = \"" + license + "\"";
+                        const replaced = "_EubmJj = \"" + licenseResult.type + "\"";
                         src = src.replace(line, replaced);
-                        return { code: src, map: null }
+                        modified = true;
                     }
                 }
+
+                // Replace license JWT (same pattern)
+                if (licenseResult.jwt) {
+                    const jwtIndex = src.indexOf("__OXddGMYg");
+                    if (jwtIndex >= 0) {
+                        const jwtEnd = src.indexOf(";", jwtIndex);
+                        if (jwtEnd >= 0) {
+                            const jwtLine = src.substring(jwtIndex, jwtEnd);
+                            const jwtReplaced = "__OXddGMYg = \"" + licenseResult.jwt + "\"";
+                            src = src.replace(jwtLine, jwtReplaced);
+                            modified = true;
+                        }
+                    }
+                }
+
+                if (modified) {
+                    appliedLicense = true;
+                    return { code: src, map: null }
+                }
+            }
+        },
+        buildEnd() {
+            if (!appliedLicense) {
+                if (process.env.NEEDLE_TEST_ENV) {
+                    console.error("ERR: License was not applied!");
+                }
             }
         }
     }

package/plugins/vite/local-files-core.js

@@ -291,7 +291,7 @@ export function needleMakeFilesLocal(command, _config, userSettings) {
                     failedDownloads,
                     localizationStats,
                 }, activeHandlers);
-                src = fixRelativeNewURL(src);
+                src = fixRelativeNewURL(src, viteConfig?.base);
             }
             catch (err) {
                 needleLog("needle:local-files", "Error in transform: " + getErrMessage(err), "error");
@@ -303,7 +303,7 @@ export function needleMakeFilesLocal(command, _config, userSettings) {
         },
         renderChunk(code, chunk) {
             if (!chunk.fileName?.endsWith(".js")) return null;
-            const fixed = fixRelativeNewURL(code);
+            const fixed = fixRelativeNewURL(code, viteConfig?.base);
             if (fixed === code) return null;
             return {
                 code: fixed,
@@ -314,7 +314,7 @@ export function needleMakeFilesLocal(command, _config, userSettings) {
             for (const output of Object.values(bundle)) {
                 if (output.type !== "chunk") continue;
                 if (!output.fileName?.endsWith(".js")) continue;
-                const fixed = fixRelativeNewURL(output.code);
+                const fixed = fixRelativeNewURL(output.code, viteConfig?.base);
                 if (fixed !== output.code) output.code = fixed;
             }
         },

package/plugins/vite/local-files-utils.d.ts

@@ -24,9 +24,11 @@ export function normalizeWebPath(path: string): string;
 export function ensureTrailingSlash(path: string): string;
 /**
  * @param {string} src
+ * @param {string} [base] - Vite base path (e.g. "/" or "/app/"). When provided,
+ *   ext/ paths are made absolute so they resolve correctly under SPA routing.
  * @returns {string}
  */
-export function fixRelativeNewURL(src: string): string;
+export function fixRelativeNewURL(src: string, base?: string): string;
 /**
  * @param {string} src
  * @returns {string}

package/plugins/vite/local-files-utils.js

@@ -113,25 +113,49 @@ export function ensureTrailingSlash(path) {
 
 /**
  * @param {string} src
+ * @param {string} [base] - Vite base path (e.g. "/" or "/app/"). When provided,
+ *   ext/ paths are made absolute so they resolve correctly under SPA routing.
  * @returns {string}
  */
-export function fixRelativeNewURL(src) {
+export function fixRelativeNewURL(src, base) {
+    /** @param {string} path */
+    function makeAbsolute(path) {
+        // Strip any leading ./ ../ or / prefix to get the clean ext/... path
+        const clean = path.replace(/^(?:\.\.?\/)+/, '').replace(/^\//, '');
+        if (base) return base.replace(/\/+$/, '') + '/' + clean;
+        return clean;
+    }
+
     src = src.replace(
         /(?<==\s*)(["'])((?:(?:\.{1,2}\/)|\/)?ext\/[^"']*\/)\1/g,
         (/** @type {string} */ _match, /** @type {string} */ quote, /** @type {string} */ path) => {
-            const runtimePath = path.startsWith("/ext/") ? path.substring(1) : path;
-            return `new URL(${quote}${runtimePath}${quote}, self.location?.href || ${quote}${quote}).href`;
+            const resolved = makeAbsolute(path);
+            return `new URL(${quote}${resolved}${quote}, self.location?.href || ${quote}${quote}).href`;
         }
     );
 
     src = src.replace(
         /new\s+URL\s*\(\s*(["'`])((?:(?:\.{1,2}\/)|\/)?ext\/[^"'`]+)\1\s*\)/g,
         (/** @type {string} */ _match, /** @type {string} */ quote, /** @type {string} */ path) => {
-            const runtimePath = path.startsWith("/ext/") ? path.substring(1) : path;
-            return `new URL(${quote}${runtimePath}${quote}, self.location?.href)`;
+            const resolved = makeAbsolute(path);
+            return `new URL(${quote}${resolved}${quote}, self.location?.href)`;
         }
     );
 
+    // Make remaining ext/ string literals absolute (e.g. font paths passed as
+    // function arguments like addVariant("normal","normal","ext/fonts/...")).
+    // The regexes above already consumed paths inside new URL() calls and
+    // assignment-based patterns, so this only catches leftover bare strings.
+    if (base) {
+        src = src.replace(
+            /(["'`])((?:\.{1,2}\/)?ext\/[^"'`]+)\1/g,
+            (/** @type {string} */ _match, /** @type {string} */ quote, /** @type {string} */ path) => {
+                const resolved = makeAbsolute(path);
+                return `${quote}${resolved}${quote}`;
+            }
+        );
+    }
+
     return src;
 }
 

package/plugins/vite/reload.js

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { needleLog } from './logging.js';
 
+const pluginName = "needle-reload";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -39,7 +40,7 @@ export function needleReload(_command, config, userSettings) {
     const buildDirectory = projectConfig?.buildDirectory?.length ? process.cwd().replaceAll("\\", "/") + "/" + projectConfig?.buildDirectory : "";
     if (buildDirectory?.length) {
         const relativeBuildDirectory = path.relative(process.cwd(), buildDirectory).replaceAll("\\", "/") || ".";
-        setTimeout(() => needleLog("needle-reload", "Build directory: " + relativeBuildDirectory), 100);
+        setTimeout(() => needleLog(pluginName, "Build directory: " + relativeBuildDirectory), 100);
     }
 
     // These ignore patterns will be injected into user config to better control vite reloading
@@ -59,7 +60,7 @@ export function needleReload(_command, config, userSettings) {
                 // @ts-ignore - watch.ignored is guaranteed to be string[] by the guards above
                 config.server.watch.ignored.push(pattern);
             if (userSettings?.debug === true)
-                setTimeout(() => needleLog("needle-reload", "Updated server ignore patterns: " + JSON.stringify(config.server?.watch?.ignored)), 100);
+                setTimeout(() => needleLog(pluginName, "Updated server ignore patterns: " + JSON.stringify(config.server?.watch?.ignored)), 100);
         },
         /** @param {import('vite').HmrContext & {buildDirectory?: string}} args */
         handleHotUpdate(args) {
@@ -118,7 +119,7 @@ function getHot(server) {
 
 /** @param {import('vite').ViteDevServer} server @param {string} [file] */
 function notifyClientWillReload(server, file) {
-    console.log("Send reload notification");
+    needleLog(pluginName, "Send reload notification");
     getHot(server).send('needle:reload', { type: 'will-reload', file: file });
 }
 
@@ -134,7 +135,7 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
 
     // Dont reload the whole server when a file that is using hot reload changes
     if (filesUsingHotReload.has(file)) {
-        console.log("File is using hot reload: " + file);
+        needleLog(pluginName, "File is using hot reload: " + file);
         return null;
     }
 
@@ -153,7 +154,7 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
     // instead of relying on the vite server watch ignore array
     // we could here also match paths that we know we dont want to track
     if (ignorePatterns.length > 0 && ignoreRegex.test(file)) {
-        console.log("Ignore change in file: " + getFileNameLog(file));
+        needleLog(pluginName, "Ignore change in file: " + getFileNameLog(file));
         return [];
     }
 
@@ -163,7 +164,7 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
     if (buildDirectory?.length) {
         const dir = path.dirname(file).replaceAll("\\", "/");
         if (dir.startsWith(buildDirectory)) {
-            console.log("Ignore change in build directory: " + getFileNameLog(file));
+            needleLog(pluginName, "Ignore change in build directory: " + getFileNameLog(file));
             return [];
         }
     }
@@ -178,13 +179,13 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
             return [];
         }
         if (await testIfFileContentChanged(file, read) === false) {
-            console.log("File content didnt change: " + getFileNameLog(file));
+            needleLog(pluginName, "File content didnt change: " + getFileNameLog(file));
             return [];
         }
     }
 
     // these are known file types we export from integrations
-    const knownExportFileTypes = [ ".glb", ".gltf", ".bin", "exr", ".ktx2", ".mp3", ".ogg", ".mp4", ".webm" ];
+    const knownExportFileTypes = [".glb", ".gltf", ".bin", "exr", ".ktx2", ".mp3", ".ogg", ".mp4", ".webm"];
     if (!knownExportFileTypes.some((type) => file.endsWith(type)))
         return null;
 
@@ -208,7 +209,7 @@ async function handleReload({ file, server, modules: _modules, read, buildDirect
         }
     }
 
-    console.log("> Detected file change: ", getFileNameLog(file) + " (" + ((fileSize / (1024 * 1024)).toFixed(1)) + " MB)");
+    needleLog(pluginName, "> Detected file change: " + getFileNameLog(file) + " (" + ((fileSize / (1024 * 1024)).toFixed(1)) + " MB)");
     notifyClientWillReload(server);
     scheduleReload(server);
     return [];
@@ -223,8 +224,8 @@ async function scheduleReload(server, level = 0) {
     const lockFile = path.join(process.cwd(), lockFileName);
     if (existsSync(lockFile)) {
         if (level === 0)
-            console.log("Lock file exists, waiting for export to finish...");
-        setTimeout(() => scheduleReload(server, level += 1), 300);
+            needleLog(pluginName, "Lock file exists, waiting for export to finish...");
+        setTimeout(() => scheduleReload(server, level += 1), 300).unref();
         return;
     }
 
@@ -234,13 +235,13 @@ async function scheduleReload(server, level = 0) {
     if (timeDiff < 1000) {
         // Sometimes file changes happen immediately after triggering a reload 
         // we dont want to reload again in that case
-        console.log("Ignoring reload, last reload was too recent", timeDiff);
+        needleLog(pluginName, "Ignoring reload, last reload was too recent" + timeDiff + "ms ago");
         return;
     }
 
     lastReloadTime = Date.now();
     const readableTime = new Date(lastReloadTime).toLocaleTimeString();
-    console.log("< Reloading... " + readableTime)
+    needleLog(pluginName, "< Reloading... " + readableTime);
     getHot(server).send({
         type: 'full-reload',
         path: '*'
@@ -299,10 +300,10 @@ function removeVersionQueryArgument(content) {
 function insertScriptRegisterHotReloadCode(src, filePath) {
 
     // We only want to inject the hot reload code in the needle-engine root file
-    if(!filePath.includes("/src/needle-engine.ts")) {
+    if (!filePath.includes("/src/needle-engine.ts")) {
         return src;
     }
-    console.log("[Needle HMR] Hot reload is enabled");
+    needleLog(pluginName, "[Needle HMR] Hot reload is enabled");
     // this code let's the engine know that we are in hot reload mode
     const code = `
 globalThis.NEEDLE_HOT_RELOAD_ENABLED = true;
@@ -338,12 +339,12 @@ function insertScriptHotReloadCode(src, filePath) {
             return undefined;
         // make import path from engine package
         const fullPathToHotReload = process.cwd() + "/node_modules/@needle-tools/engine/src/engine/engine_hot_reload.ts";
-        // console.log(fullPathToHotReload);
+        // needleLog(pluginName, fullPathToHotReload);
         const fileDirectory = path.dirname(filePath);
-        // console.log("DIR", fileDirectory)
+        // needleLog(pluginName, "DIR", fileDirectory)
         const relativePath = path.relative(fileDirectory, fullPathToHotReload);
         importPath = relativePath.replace(/\\/g, "/");
-        // console.log("importPath: ", importPath);
+        // needleLog(pluginName, "importPath: ", importPath);
     }
 
     // console.log(importPath, ">", filePath);

package/plugins/vite/server.js

@@ -60,7 +60,8 @@ export function needleServer(command, config, userSettings) {
                             })
                             .catch((err) => console.error("ERR: [needle:server] 'open' package not found - please make sure to install 'open' in your package.json\n", err));
                     }
-                }, 100)
+                }, 100);
+                i.unref();
             }
         },
     }