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

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.d.ts

@@ -1,10 +1,10 @@
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export function needleDependencyWatcher(command: "build" | "serve", _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
+export function needleDependencyWatcher(_command: "build" | "serve" | undefined, _config: unknown, userSettings: import("../types").userSettings): import("vite").Plugin | null;
 export type PackageJson = {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;

package/plugins/vite/dependency-watcher.js

@@ -12,14 +12,12 @@ function log(...msg) {
 }
 
 /**
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {unknown} _config
  * @param {import('../types').userSettings} userSettings
  * @returns {import('vite').Plugin | null}
  */
-export function needleDependencyWatcher(command, _config, userSettings) {
-    if (command === "build") return null;
-
+export function needleDependencyWatcher(_command, _config, userSettings) {
     if (userSettings?.noDependencyWatcher === true) return null;
 
     const dir = process.cwd();
@@ -28,6 +26,7 @@ export function needleDependencyWatcher(command, _config, userSettings) {
 
     return /** @type {import('vite').Plugin} */ ({
         name: 'needle-dependency-watcher',
+        apply: 'serve',
         /** @param {import('vite').ViteDevServer} server */
         configureServer(server) {
             manageClients(server);
@@ -99,7 +98,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
 
     setTimeout(() => {
         requireInstall = testIfInstallIsRequired(projectDir, packageJson);
-    }, 1000);
+    }, 1000).unref();
 
     setInterval(() => {
         if (!packageJson || lastEditTime === undefined) return;
@@ -150,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/drop.d.ts

@@ -1,7 +1,7 @@
 /** Experimental, allow dropping files from Unity into the running scene.
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
  * @returns {import('vite').Plugin | null | undefined}
  */
-export function needleDrop(command: "build" | "serve", config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null | undefined;
+export function needleDrop(_command: "build" | "serve" | undefined, config: import("../types/needleConfig").needleMeta | null | undefined, userSettings: import("../types/userconfig.js").userSettings): import("vite").Plugin | null | undefined;

package/plugins/vite/drop.js

@@ -7,18 +7,17 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 /** Experimental, allow dropping files from Unity into the running scene.
- * @param {"build" | "serve"} command
+ * @param {"build" | "serve" | undefined} _command
  * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
  * @returns {import('vite').Plugin | null | undefined}
  */
-export function needleDrop(command, config, userSettings) {
-    if (command === "build") return;
-    
+export function needleDrop(_command, config, userSettings) {
     if(userSettings.useDrop !== true) return null;
 
     return {
         name: "needle:drop",
+        apply: 'serve',
         config(/** @type {{ server?: { hmr?: { port?: number } } }} */ viteConfig) {
             if(userSettings)
             if (!viteConfig.server) viteConfig.server = {};

package/plugins/vite/dts-generator.d.ts

@@ -2,6 +2,6 @@
  * @param {"build" | "serve"} _command  Vite command (unused — runs in both modes)
  * @param {import('../types/needleConfig').needleMeta | null | undefined} _config
  * @param {import('../types').userSettings} [_userSettings]
- * @returns {import('vite').Plugin}
+ * @returns {import('vite').Plugin | null}
  */
-export function needleDtsGenerator(_command: "build" | "serve", _config: import("../types/needleConfig").needleMeta | null | undefined, _userSettings?: import("../types").userSettings): import("vite").Plugin;
+export function needleDtsGenerator(_command: "build" | "serve", _config: import("../types/needleConfig").needleMeta | null | undefined, _userSettings?: import("../types").userSettings): import("vite").Plugin | null;

package/plugins/vite/dts-generator.js

@@ -16,12 +16,24 @@
  *   needleDtsGenerator(command, needleConfig, userSettings)
  */
 
-import { join, resolve } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync } from 'fs';
 import { tryLoadProjectConfig } from './config.js';
 import { generateBindingsDts } from '../dts-generator/index.js';
 import { needleLog } from './logging.js';
 
+// Two dirs up from plugins/vite/ → package root.
+// Use fileURLToPath so %7E and other URL-encoded characters in the path are decoded correctly.
+// realpathSync follows symlinks so the path is stable even in npm link / monorepo setups.
+import { fileURLToPath } from 'url';
+let _packageRoot = /** @type {string | null} */ (null);
+try {
+    _packageRoot = realpathSync(join(dirname(fileURLToPath(import.meta.url)), '..', '..'));
+} catch (_e) {
+    // If we can't resolve the package root (e.g. unusual install layout), the plugin
+    // will silently skip generation rather than crashing the dev server.
+}
+
 /**
  * Ensure `.vscode/settings.json` references the generated `needle-html-data.json`
  * so VS Code provides `data-bind-needle` completions in HTML files automatically.
@@ -60,9 +72,14 @@ function ensureVscodeHtmlCustomData(projectRoot, htmlDataPath) {
  * @param {"build" | "serve"} _command  Vite command (unused — runs in both modes)
  * @param {import('../types/needleConfig').needleMeta | null | undefined} _config
  * @param {import('../types').userSettings} [_userSettings]
- * @returns {import('vite').Plugin}
+ * @returns {import('vite').Plugin | null}
  */
 export function needleDtsGenerator(_command, _config, _userSettings) {
+
+    if(_userSettings?.dts?.enabled === false) {
+        return null;
+    }
+
     let projectRoot = process.cwd();
 
     function resolveCodegenDir() {
@@ -73,7 +90,11 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
     }
 
     function resolveOutputPath() {
-        return join(resolveCodegenDir(), "needle-bindings.d.ts");
+        // Write to a .needle dotfolder at the package root.
+        // Not in the `files` allowlist → never npm-published.
+        // ../../.needle/ from plugins/types/ resolves correctly for both
+        // symlinked (js/package~/) and published (node_modules/@needle-tools/engine/) layouts.
+        return join(/** @type {string} */ (_packageRoot), ".needle", "generated", "needle-bindings.gen.d.ts");
     }
 
     function resolveAssetsDir() {
@@ -86,14 +107,24 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
     /** @type {import('vite').ViteDevServer | undefined} */
     let devServer;
 
-    async function run() {
+    /** @type {Promise<void> | null} */
+    let _runInFlight = null;
+
+    function run() {
+        if (_runInFlight) return _runInFlight;
+        _runInFlight = _doRun().finally(() => { _runInFlight = null; });
+        return _runInFlight;
+    }
+
+    async function _doRun() {
         try {
+            if (!_packageRoot) return;
             const assetsDir = resolveAssetsDir();
             const outputPath = resolveOutputPath();
             const codegenDir = resolveCodegenDir();
             const count = await generateBindingsDts({ assetsDir, outputPath, projectRoot, codegenDir });
-            // Always register HTML custom data — the file is written on every run
-            const htmlDataPath = join(codegenDir, "needle-html-data.json");
+            // HTML custom data sits next to the generated dts in .needle/generated/
+            const htmlDataPath = join(/** @type {string} */ (_packageRoot), ".needle", "generated", "needle-html-data.json");
             ensureVscodeHtmlCustomData(projectRoot, htmlDataPath);
             if (count !== false) {
                 needleLog("needle:dts-generator", `${count} binding(s) → ${outputPath.replace(process.cwd(), ".")}`);
@@ -102,7 +133,7 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
                     hot.send({ type: "full-reload", path: "*" });
                 }
             } else {
-                needleLog("needle:dts-generator", `up-to-date`);
+                needleLog("needle:dts-generator", `up-to-date → ${outputPath.replace(process.cwd(), ".")}`);
             }
         } catch (err) {
             needleLog("needle:dts-generator", "Failed: " + (/** @type {any} */ (err)?.message ?? err));
@@ -118,7 +149,10 @@ export function needleDtsGenerator(_command, _config, _userSettings) {
         },
 
         buildStart() {
-            return run();
+            // In serve mode, the configureServer post-hook runs instead.
+            // Only run here for actual builds (no devServer).
+            if (!devServer) return run();
+            return undefined;
         },
 
         /** @param {import('vite').ViteDevServer} server */

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/index.d.ts

@@ -19,12 +19,18 @@
  *        ],
  *    }
  * ```
- * @param {"build" | "serve"} command
- * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * When used without arguments (e.g. in a SvelteKit `defineConfig({})` plain object),
+ * the command is resolved automatically from Vite's `configResolved` hook.
+ * ```js
+ * // SvelteKit — no command needed:
+ * export default defineConfig({ plugins: [sveltekit(), needlePlugins()] });
+ * ```
+ * @param {"build" | "serve" | undefined} [command]
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} [config]
  * @param {import('../types/index.js').userSettings} [userSettings]
  * @returns {Promise<import('vite').Plugin[]>}
  */
-export function needlePlugins(command: "build" | "serve", config?: import("../types/needleConfig").needleMeta | null | undefined, userSettings?: import("../types/index.js").userSettings): Promise<import("vite").Plugin[]>;
+export function needlePlugins(command?: "build" | "serve" | undefined, config?: import("../types/needleConfig").needleMeta | null | undefined, userSettings?: import("../types/index.js").userSettings): Promise<import("vite").Plugin[]>;
 export { needleAI } from "./ai.js";
 export { needleDtsGenerator } from "./dts-generator.js";
 export { needleAsap } from "./asap.js";

package/plugins/vite/index.js

@@ -116,12 +116,18 @@ const defaultUserSettings = {
  *        ],
  *    }
  * ```
- * @param {"build" | "serve"} command
- * @param {import('../types/needleConfig').needleMeta | null | undefined} config
+ * When used without arguments (e.g. in a SvelteKit `defineConfig({})` plain object),
+ * the command is resolved automatically from Vite's `configResolved` hook.
+ * ```js
+ * // SvelteKit — no command needed:
+ * export default defineConfig({ plugins: [sveltekit(), needlePlugins()] });
+ * ```
+ * @param {"build" | "serve" | undefined} [command]
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} [config]
  * @param {import('../types/index.js').userSettings} [userSettings]
  * @returns {Promise<import('vite').Plugin[]>}
  */
-export async function needlePlugins(command, config = undefined, userSettings = {}) {
+export async function needlePlugins(command = undefined, config = undefined, userSettings = {}) {
 
     if (!config) config = {}
 
@@ -168,14 +174,21 @@ export async function needlePlugins(command, config = undefined, userSettings =
     array.push(await editorConnection(command, config, userSettings, array));
     array.push(needleDependencyWatcher(command, config, userSettings));
 
-    // Ensure the process exits on SIGINT (Ctrl+C) since plugin timers/sockets can keep the event loop alive
-    if (command === "serve") {
+    // Ensure the process exits on SIGINT (Ctrl+C) since plugin timers/sockets can keep the event loop alive.
+    // If command is unknown at call time (e.g. SvelteKit plain defineConfig), defer to configResolved.
+    const registerSigint = () => {
         process.on('SIGINT', () => {
-            // Wait a moment to allow plugins to clean up if needed, then exit
-            setTimeout(() => {
-                console.debug('\nGoodbye!');
-                process.exit();
-            }, 1000);
+            setTimeout(() => { console.debug('\nGoodbye!'); process.exit(); }, 1000);
+        });
+    };
+    if (command === "serve") {
+        registerSigint();
+    } else if (command === undefined) {
+        array.push({
+            name: "needle:sigint",
+            configResolved(config) {
+                if (config.command === "serve") registerSigint();
+            }
         });
     }
 

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!");
+                }
             }
         }
     }