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

package/plugins/common/license.js

@@ -86,35 +86,71 @@ 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("_Ktp");
     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 = "_Ktp = \"" + licenseResult.type + "\"";
             code = code.replace(line, replaced);
-            return code;
+        }
+
+        // Also inject JWT if available
+        if (licenseResult.jwt) {
+            const jwtIndex = code.indexOf("_HXKeIG");
+            if (jwtIndex >= 0) {
+                const jwtEnd = code.indexOf(";", jwtIndex);
+                if (jwtEnd >= 0) {
+                    const jwtLine = code.substring(jwtIndex, jwtEnd);
+                    const jwtReplaced = "_HXKeIG = \"" + licenseResult.jwt + "\"";
+                    code = code.replace(jwtLine, jwtReplaced);
+                }
+            }
         }
     }
     return code;
 }
 
 /**
- * Resolve the license using the needle engine licensing server
+ * Module-level cache keyed by `team:accessToken`. The license is stable for
+ * the lifetime of the process, so multiple callers (license plugin, build
+ * pipeline) share one fetch.
+ * @type {Map<string, Promise<LicenseResult | null>>}
+ */
+const licenseCache = new Map();
+
+/**
+ * Resolve the license using the needle engine licensing server.
+ * Memoized per (team, accessToken).
  * @param {DefaultOptions & {accessToken?:string, team?:string} | null} args
- * @returns {Promise<string | null>}
+ * @returns {Promise<LicenseResult | null>}
  */
-export async function resolveLicense(args = null) {
+export function resolveLicense(args = null) {
+    const cacheKey = `${args?.team || ""}:${args?.accessToken || ""}`;
+    const cached = licenseCache.get(cacheKey);
+    if (cached) return cached;
+    const promise = resolveLicenseUncached(args);
+    licenseCache.set(cacheKey, promise);
+    return promise;
+}
+
+/**
+ * @param {DefaultOptions & {accessToken?:string, team?:string} | null} args
+ * @returns {Promise<LicenseResult | null>}
+ */
+async function resolveLicenseUncached(args = null) {
     let accessToken = args?.accessToken;
 
     // If a process.env.NEEDLE_CLOUD_TOKEN is set we want to use this (e.g. via nextjs)
@@ -210,7 +246,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 +262,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 +276,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 +401,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/types/userconfig.d.ts

@@ -82,7 +82,10 @@ export type userSettings = {
         */
         version?: string;
 
-        /** If defined the access token will be used to run compression on Needle Cloud */
+        /** If defined the access token will be used to run compression on Needle Cloud.
+         *
+         * Expected to be a Needle Cloud access token (created in the Needle Cloud UI),
+         * NOT a JWT. Do not pass a licensing JWT here. */
         accessToken?: string | undefined;
 
         /**

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/build-pipeline.js

@@ -1,5 +1,6 @@
 import { ChildProcess, exec } from 'child_process';
 import { NEEDLE_CLOUD_CLI_NAME } from '../common/cloud.js';
+import { resolveLicense } from '../common/license.js';
 import { getOutputDirectory, loadConfig } from './config.js';
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
 import { relative } from 'path';
@@ -10,6 +11,8 @@ import { needleBlue, needleDim, needleLog, needleSupportsColor, setTransientLogL
 const PIPELINE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const PIPELINE_STRUCTURED_LOG_PREFIX = "__needle_pipeline_log__:";
 
+// #region Validation
+
 /**
  * @param {import('../types').userSettings} config
  * @returns {boolean}
@@ -37,8 +40,11 @@ env:
     return true;
 }
 
+// #endregion
+
 // see https://linear.app/needle/issue/NE-3798
 
+// #region State
 
 /**  @type {Promise<void>|null} */
 let buildPipelineTask;
@@ -87,6 +93,10 @@ function increaseMaxWaitTime(debugLog) {
     }
 }
 
+// #endregion
+
+// #region Plugin
+
 /** Runs the needle build pipeline as part of the vite build process.
  * @param {"build" | "serve"} command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
@@ -237,9 +247,12 @@ export async function needleBuildPipeline(command, config, userSettings) {
     }
 }
 
+// #endregion
+
+// #region Migration
 
 /**
- * Previously we did always install the build pipeline and run an extra command to invoke the build pipeline.  
+ * Previously we did always install the build pipeline and run an extra command to invoke the build pipeline.
  * This is now done automatically by the needle build pipeline plugin - so we update all legacy projects to use the new method.
  * @param {string} packageJsonPath
  */
@@ -258,6 +271,10 @@ async function fixPackageJson(packageJsonPath) {
     writeFileSync(packageJsonPath, fixed);
 }
 
+// #endregion
+
+// #region Logging
+
 /** @param {...unknown} args */
 function log(...args) {
     needleLog("needle-buildpipeline", args.join(" "));
@@ -267,11 +284,15 @@ function warn(...args) {
     needleLog("needle-buildpipeline", args.join(" "), "warn");
 }
 
+// #endregion
+
+// #region Execution
+
 /**
  * @typedef {{ event?: string, phase?: string, target?: string, message?: string, level?: string }} BuildPipelinePayload
  */
 /**
- * @param {import('../types').userSettings} opts 
+ * @param {import('../types').userSettings} opts
  * @param {{verbose?:boolean}} [options]
  * @returns {Promise<boolean>}
  */
@@ -283,12 +304,7 @@ async function invokeBuildPipeline(opts, options = {}) {
     const supportsColor = needleSupportsColor();
     const key = (/** @type {string} */ text) => supportsColor ? needleBlue(text) : text;
 
-    const installPath = "node_modules/@needle-tools/gltf-build-pipeline";
-    const fullInstallPath = process.cwd() + "/" + installPath;
-    const existsLocally = existsSync(fullInstallPath);
-    if (existsLocally) {
-        log("Found local installation at " + fullInstallPath);
-    }
+    // #region Wait for output
     await delay(500);
     const outputDirectory = getOutputDirectory() + "/assets";
     const startWaitTime = Date.now();
@@ -332,17 +348,18 @@ async function invokeBuildPipeline(opts, options = {}) {
         `${key("Files to process")}: ${files.length} in ${rel(outputDirectory)}, ${formatBytes(filesBytes)}`,
         existsSync(process.cwd() + "/node_modules/.needle/build-pipeline/output") ? needleDim("Removing temporary output directory") : undefined,
     ].filter(Boolean), "log", { dimBody: false });
+    // #endregion
+
+    // #region Setup
 
     /** @type {null | ChildProcess} */
     let proc = null;
 
-    let cloudAccessToken = opts.buildPipeline?.accessToken || opts.license?.accessToken;
-    if (!cloudAccessToken) {
-        cloudAccessToken = process.env.NEEDLE_CLOUD_TOKEN;
-    }
+    // Cloud token used by `${NEEDLE_CLOUD_CLI_NAME} optimize --token <token>`.
+    // This is a Needle Cloud access token (created in the Needle Cloud UI), NOT a JWT.
+    const cloudAccessToken = opts.buildPipeline?.accessToken;
     const runInCloud = typeof cloudAccessToken === "string" && cloudAccessToken.length > 0;
-    // if a user has defined the build pipeline settings object but not passed in a token we should print out some information 
-    // or perhaps log an error / prevent the build from running completely
+
     if (opts.buildPipeline && !runInCloud && process.env.CI) {
         warn(`No cloud access token found. Please set it via process.env.NEEDLE_CLOUD_TOKEN`);
         return false;
@@ -367,6 +384,10 @@ async function invokeBuildPipeline(opts, options = {}) {
         }
     }
 
+    // #endregion
+
+    // #region Run
+
     // allow running the build pipeline in the cloud. It requires and access token to be set in the vite.config.js
     // this can be set via e.g. process.env.NEEDLE_CLOUD_TOKEN
     const commandEnv = { ...process.env, NEEDLE_PIPELINE_STRUCTURED_LOGS: "1" };
@@ -393,11 +414,6 @@ async function invokeBuildPipeline(opts, options = {}) {
         log(`Running compression in cloud ⛅ using access token: ${obfuscatedToken}`);
         proc = exec(cmd, { env: commandEnv });
     }
-    else if (existsLocally) {
-        const cmd = `needle-gltf transform "${outputDirectory}" \"${tempOutputPath}\"`;
-        log("Running command \"" + cmd + "\" at " + process.cwd() + "...");
-        proc = exec(cmd, { cwd: installPath, env: commandEnv });
-    }
     else {
         // First check if the user passed in a specific version to use via the vite config
         let version = opts.buildPipeline?.version;
@@ -424,10 +440,21 @@ async function invokeBuildPipeline(opts, options = {}) {
         if (!version) version = "stable";
 
         const versionInfo = versionSource ? `'${version}' (${versionSource})` : `'${version}'`;
-        const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"`;
+        // needle-gltf 3.x requires a JWT via `--auth-token <jwt>` on every CLI invocation.
+        // The JWT comes from the needle license server — it is NOT the Needle Cloud access token.
+        const licenseResult = await resolveLicense({
+            team: opts.license?.team,
+            accessToken: opts.license?.accessToken,
+            loglevel: opts.debugLicense === true ? "verbose" : undefined,
+        });
+        const authTokenArg = licenseResult?.jwt ? ` --auth-token ${licenseResult.jwt}` : "";
+        const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"${authTokenArg}`;
         log(`Running compression locally using version ${versionInfo}`);
         proc = exec(cmd, { env: commandEnv });
     }
+    // #endregion
+
+    // #region Output
     let pipelineSpinnerIndex = 0;
     let pipelineSpinnerActive = false;
     let transformStepCount = 0;
@@ -550,6 +577,9 @@ async function invokeBuildPipeline(opts, options = {}) {
     }
     proc.stdout?.on('data', onLog);
     proc.stderr?.on('data', onLog);
+    // #endregion
+
+    // #region Exit
     return new Promise((resolve, reject) => {
         proc.on('exit', (code) => {
             clearPipelineProgress();
@@ -570,8 +600,13 @@ async function invokeBuildPipeline(opts, options = {}) {
             resolve(success);
         });
     });
+    // #endregion
 }
 
+// #endregion
+
+// #region Helpers
+
 /** @param {string | null | undefined} directory */
 function getDirectoryStats(directory) {
     if (!directory || !existsSync(directory)) return { fileCount: 0, totalBytes: 0 };
@@ -597,3 +632,5 @@ function getDirectoryStats(directory) {
     }
     return { fileCount, totalBytes };
 }
+
+// #endregion

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("_Ktp");
                 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 = "_Ktp = \"" + 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("_HXKeIG");
+                    if (jwtIndex >= 0) {
+                        const jwtEnd = src.indexOf(";", jwtIndex);
+                        if (jwtEnd >= 0) {
+                            const jwtLine = src.substring(jwtIndex, jwtEnd);
+                            const jwtReplaced = "_HXKeIG = \"" + 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}