@bonsae/nrg 0.18.4 → 0.19.0

package/vite/index.js

@@ -1,5 +1,5 @@
 // src/vite/plugin.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/vite/defaults.ts
 var DEFAULT_OUTPUT_DIR = "./dist";
@@ -52,6 +52,40 @@ var DEFAULT_EXTRA_FILES_COPY_TARGETS = [
 // src/vite/utils.ts
 import fs from "fs";
 import path from "path";
+
+// src/vite/errors.ts
+var PluginError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "PluginError";
+  }
+};
+var NodeRedStartError = class extends PluginError {
+  constructor(cause) {
+    super("Failed to start Node-RED", "NODE_RED_START_FAILED", cause);
+    this.name = "NodeRedStartError";
+  }
+};
+var BuildError = class extends PluginError {
+  constructor(phase, cause) {
+    super(
+      `Failed to build ${phase}`,
+      `BUILD_${phase.toUpperCase()}_FAILED`,
+      cause
+    );
+    this.name = "BuildError";
+  }
+};
+var ConfigError = class extends PluginError {
+  constructor(message) {
+    super(message, "CONFIG_INVALID");
+    this.name = "ConfigError";
+  }
+};
+
+// src/vite/utils.ts
 function cleanDir(dir) {
   if (fs.existsSync(dir)) {
     fs.rmSync(dir, { recursive: true });
@@ -86,6 +120,23 @@ function getPackageName() {
   }
   return "node-red-nodes";
 }
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function slugify(input) {
+  return input.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveSlug(userSlug) {
+  if (userSlug !== void 0) {
+    const trimmed = userSlug.trim();
+    if (!SLUG_PATTERN.test(trimmed)) {
+      const suggestion = slugify(trimmed);
+      throw new ConfigError(
+        `Invalid dev server slug ${JSON.stringify(userSlug)}. A slug must be URL-safe: lowercase letters, digits and single hyphens (matching ${String(SLUG_PATTERN)}).` + (suggestion ? ` Did you mean ${JSON.stringify(suggestion)}?` : "")
+      );
+    }
+    return trimmed;
+  }
+  return slugify(path.basename(process.cwd())) || "app";
+}
 function mergeOptions(defaults, overrides) {
   if (!overrides) return { ...defaults };
   const result = { ...defaults };
@@ -106,17 +157,8 @@ function mergeOptions(defaults, overrides) {
   return result;
 }
 
-// src/vite/node-red-launcher.ts
-import { spawn, execSync } from "child_process";
-import getPort from "get-port";
-import detect from "detect-port";
-import { builtinModules, createRequire } from "module";
-import treeKill from "tree-kill";
-import fs2 from "fs";
-import os from "os";
-import path2 from "path";
-import { pathToFileURL } from "url";
-import { build as esbuild } from "esbuild";
+// src/vite/node-red-launcher/index.ts
+import fs4 from "fs";
 
 // src/vite/async-utils.ts
 function debounce(fn, delay) {
@@ -160,32 +202,6 @@ async function retry(fn, options = {}) {
   throw lastError;
 }
 
-// src/vite/errors.ts
-var PluginError = class extends Error {
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "PluginError";
-  }
-};
-var NodeRedStartError = class extends PluginError {
-  constructor(cause) {
-    super("Failed to start Node-RED", "NODE_RED_START_FAILED", cause);
-    this.name = "NodeRedStartError";
-  }
-};
-var BuildError = class extends PluginError {
-  constructor(phase, cause) {
-    super(
-      `Failed to build ${phase}`,
-      `BUILD_${phase.toUpperCase()}_FAILED`,
-      cause
-    );
-    this.name = "BuildError";
-  }
-};
-
 // src/vite/logger.ts
 import * as clackLogger from "@clack/prompts";
 var color = {
@@ -259,200 +275,388 @@ var Logger = class _Logger {
 };
 var logger = new Logger({ name: "vite-plugin-node-red" });
 
-// src/vite/node-red-launcher.ts
-var NodeRedLauncher = class {
-  compiledRuntimeSettingsFilepath = null;
-  process = null;
-  bufferedLogs = [];
-  isReady = false;
-  port = null;
-  outDir;
-  options;
-  logger;
-  constructor(outDir, options) {
-    this.outDir = outDir;
-    this.options = options;
-    this.logger = new Logger({
-      name: "vite-plugin-node-red",
-      prefix: "node-red"
-    });
+// src/vite/node-red-launcher/entry-point.ts
+import { exec } from "child_process";
+import { randomUUID } from "crypto";
+import { createRequire } from "module";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+function getNodeRedCommand(version) {
+  return version ? `node-red@${version}` : "node-red";
+}
+function resolveNodeRedFromLocalNodeModules() {
+  try {
+    const require_ = createRequire(path2.join(process.cwd(), "package.json"));
+    const pkgJsonPath = require_.resolve("node-red/package.json");
+    const pkgDir = path2.dirname(pkgJsonPath);
+    const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["node-red"];
+    if (!bin) return null;
+    const entry = path2.resolve(pkgDir, bin);
+    return fs2.existsSync(entry) ? entry : null;
+  } catch {
+    return null;
   }
-  get preferredPort() {
-    return this.options.runtime?.port ?? 1880;
+}
+async function resolveNodeRed(options) {
+  const { version, npxTimeoutMs = 3e5, logger: logger2 } = options;
+  if (version && !/^[\w.^~<>=*-]+$/.test(version)) {
+    throw new NodeRedStartError(
+      new Error(`Invalid node-red version "${version}"`)
+    );
   }
-  get restartDelay() {
-    return this.options.restartDelay ?? 1e3;
+  const nodeRedCommand = getNodeRedCommand(version);
+  logger2.info(`Resolving ${nodeRedCommand} entry point...`);
+  const hasExplicitVersion = version !== void 0 && version !== "latest";
+  if (!hasExplicitVersion) {
+    const localEntry = resolveNodeRedFromLocalNodeModules();
+    if (localEntry) {
+      logger2.info(`Resolved from local node_modules: ${localEntry}`);
+      return localEntry;
+    }
   }
-  get pid() {
-    return this.process?.pid ?? null;
+  logger2.info(
+    hasExplicitVersion ? `Using configured version (${version}), downloading via npx...` : `Not found locally, downloading via npx (this may take a while)...`
+  );
+  const resolverScript = path2.join(
+    os.tmpdir(),
+    `nrg-resolve-node-red-${process.pid}-${randomUUID()}.cjs`
+  );
+  fs2.writeFileSync(
+    resolverScript,
+    `const fs = require("fs");
+const path = require("path");
+const isWin = process.platform === "win32";
+const binName = isWin ? "node-red.cmd" : "node-red";
+const dirs = process.env.PATH.split(path.delimiter);
+for (const d of dirs) {
+  const f = path.join(d, binName);
+  if (fs.existsSync(f)) {
+    if (isWin) {
+      const nodeRedDir = path.resolve(d, "..", "node-red");
+      const pkg = JSON.parse(fs.readFileSync(path.join(nodeRedDir, "package.json"), "utf-8"));
+      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin["node-red"];
+      process.stdout.write(path.resolve(nodeRedDir, bin));
+    } else {
+      process.stdout.write(fs.realpathSync(f));
+    }
+    break;
   }
-  get nodeRedCommand() {
-    const version = this.options.runtime?.version;
-    if (version === "latest") {
-      return "node-red@latest";
+}`
+  );
+  try {
+    const stdout = await new Promise((resolve, reject) => {
+      exec(
+        `npx --yes -p ${nodeRedCommand} node "${resolverScript}"`,
+        { timeout: npxTimeoutMs },
+        (error, stdout2) => {
+          if (error) reject(error);
+          else resolve(stdout2);
+        }
+      );
+    });
+    const entryPoint = stdout.trim();
+    if (!entryPoint || !fs2.existsSync(entryPoint)) {
+      throw new NodeRedStartError(
+        new Error(
+          `Could not resolve node-red entry point: ${entryPoint || "(empty)"}`
+        )
+      );
     }
-    if (version) {
-      return `node-red@${version}`;
+    logger2.info(`Resolved via npx: ${entryPoint}`);
+    return entryPoint;
+  } finally {
+    try {
+      fs2.unlinkSync(resolverScript);
+    } catch {
     }
-    return "node-red";
   }
-  findRuntimeSettingsFilepath() {
-    const runtimeSettingsFilepath = this.options.runtime?.settingsFilepath;
-    if (runtimeSettingsFilepath) {
-      const resolved2 = path2.resolve(runtimeSettingsFilepath);
-      if (fs2.existsSync(resolved2)) {
-        return resolved2;
-      }
-      this.logger.warn(`Settings file not found: ${runtimeSettingsFilepath}`);
-      return null;
-    }
-    const resolved = path2.resolve("node-red.settings.ts");
-    if (fs2.existsSync(resolved)) {
-      return resolved;
+}
+
+// src/vite/node-red-launcher/settings.ts
+import { builtinModules } from "module";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import { build as esbuild } from "esbuild";
+function findUserRuntimeSettingsFilepath(settingsFilepath, logger2) {
+  if (settingsFilepath) {
+    const resolved2 = path3.resolve(settingsFilepath);
+    if (fs3.existsSync(resolved2)) {
+      return resolved2;
     }
+    logger2.warn(`Settings file not found: ${settingsFilepath}`);
     return null;
   }
-  async compileRuntimeSettingsFile(runtimeSettingsFilepath) {
-    const compiledRuntimeSettingsFilepath = path2.join(
-      os.tmpdir(),
-      `node-red.settings.${process.pid}.cjs`
+  const resolved = path3.resolve("node-red.settings.ts");
+  if (fs3.existsSync(resolved)) {
+    return resolved;
+  }
+  return null;
+}
+async function compileRuntimeSettingsFile(runtimeSettingsFilepath, port) {
+  const compiledRuntimeSettingsFilepath = path3.join(
+    os2.tmpdir(),
+    `node-red.settings.${process.pid}-${port}.cjs`
+  );
+  const nodeBuiltins2 = [
+    ...builtinModules,
+    ...builtinModules.map((m) => `node:${m}`)
+  ];
+  const settingsDir = path3.dirname(runtimeSettingsFilepath).split(path3.sep).join("/");
+  const settingsFile = runtimeSettingsFilepath.split(path3.sep).join("/");
+  await esbuild({
+    entryPoints: [runtimeSettingsFilepath],
+    outfile: compiledRuntimeSettingsFilepath,
+    format: "cjs",
+    platform: "node",
+    target: "node18",
+    bundle: true,
+    define: {
+      "import.meta.dirname": JSON.stringify(settingsDir),
+      "import.meta.filename": JSON.stringify(settingsFile),
+      "import.meta.url": JSON.stringify(pathToFileURL(settingsFile).href)
+    },
+    external: [...nodeBuiltins2, "node-red", "@node-red/*"]
+  });
+  return compiledRuntimeSettingsFilepath;
+}
+async function generateRuntimeSettings(options) {
+  const { outDir, port, settingsFilepath, httpAdminRoot, logger: logger2 } = options;
+  const tempFiles = [];
+  const userRuntimeSettingsFilepath = findUserRuntimeSettingsFilepath(
+    settingsFilepath,
+    logger2
+  );
+  let compiledRuntimeSettingsFilepath = null;
+  if (userRuntimeSettingsFilepath) {
+    compiledRuntimeSettingsFilepath = await compileRuntimeSettingsFile(
+      userRuntimeSettingsFilepath,
+      port
     );
-    const nodeBuiltins2 = [
-      ...builtinModules,
-      ...builtinModules.map((m) => `node:${m}`)
-    ];
-    const settingsDir = path2.dirname(runtimeSettingsFilepath).split(path2.sep).join("/");
-    const settingsFile = runtimeSettingsFilepath.split(path2.sep).join("/");
-    await esbuild({
-      entryPoints: [runtimeSettingsFilepath],
-      outfile: compiledRuntimeSettingsFilepath,
-      format: "cjs",
-      platform: "node",
-      target: "node18",
-      bundle: true,
-      define: {
-        "import.meta.dirname": JSON.stringify(settingsDir),
-        "import.meta.filename": JSON.stringify(settingsFile),
-        "import.meta.url": JSON.stringify(pathToFileURL(settingsFile).href)
-      },
-      external: [...nodeBuiltins2, "node-red", "@node-red/*"]
-    });
-    this.compiledRuntimeSettingsFilepath = compiledRuntimeSettingsFilepath;
-    return compiledRuntimeSettingsFilepath;
-  }
-  async generateRuntimeSettingsFile() {
-    const userRuntimeSettingsFilepath = this.findRuntimeSettingsFilepath();
-    let compiledRuntimeSettingsFilepath = null;
-    if (userRuntimeSettingsFilepath) {
-      compiledRuntimeSettingsFilepath = await this.compileRuntimeSettingsFile(
-        userRuntimeSettingsFilepath
-      );
-    }
-    const outDir = path2.resolve(this.outDir).split(path2.sep).join("/");
-    const cwd = process.cwd().split(path2.sep).join("/");
-    const userDir = path2.resolve(cwd, ".node-red").split(path2.sep).join("/");
-    const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
-const compiledRuntimeSettings = require("${compiledRuntimeSettingsFilepath.split(path2.sep).join("/")}");
+    tempFiles.push(compiledRuntimeSettingsFilepath);
+  }
+  const normalizedOutDir = path3.resolve(outDir).split(path3.sep).join("/");
+  const cwd = process.cwd().split(path3.sep).join("/");
+  const userDir = path3.resolve(cwd, ".node-red").split(path3.sep).join("/");
+  const userDirLiteral = JSON.stringify(userDir);
+  const outDirLiteral = JSON.stringify(normalizedOutDir);
+  const httpAdminRootAssignment = httpAdminRoot ? `settings.httpAdminRoot = ${JSON.stringify(httpAdminRoot)};
+` : "";
+  const httpAdminRootEntry = httpAdminRoot ? `
+  httpAdminRoot: ${JSON.stringify(httpAdminRoot)},` : "";
+  const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
+const compiledRuntimeSettings = require(${JSON.stringify(
+    compiledRuntimeSettingsFilepath.split(path3.sep).join("/")
+  )});
 const settings = compiledRuntimeSettings.default || compiledRuntimeSettings;
-settings.uiPort = ${this.port};
-if(!settings.userDir){
-    settings.userDir = "${userDir}";
+settings.uiPort = ${port};
+${httpAdminRootAssignment}if(!settings.userDir){
+    settings.userDir = ${userDirLiteral};
 }
 settings.nodesDir = settings.nodesDir || [];
-if (!settings.nodesDir.includes("${outDir}")) {
-  settings.nodesDir.push("${outDir}");
+if (!settings.nodesDir.includes(${outDirLiteral})) {
+  settings.nodesDir.push(${outDirLiteral});
 }
 if(!settings.flowFile){
   settings.flowFile = "flows.json";
 }
+// the welcome tour overlay intercepts pointer events \u2014 fatal for e2e and
+// noise for dev; explicit user settings still win
+settings.editorTheme = settings.editorTheme || {};
+if (settings.editorTheme.tours === undefined) {
+  settings.editorTheme.tours = false;
+}
 module.exports = settings;
 ` : `
 const settings = {
-  uiPort: ${this.port},
-  userDir: "${userDir}",
+  uiPort: ${port},
+  userDir: ${userDirLiteral},
   flowFile: "flows.json",
-  nodesDir: ["${outDir}"],
+  nodesDir: [${outDirLiteral}],${httpAdminRootEntry}
+  // the welcome tour overlay intercepts pointer events \u2014 fatal for e2e
+  editorTheme: { tours: false },
 };
 module.exports = settings;
 `;
-    const finalRuntimeSettingsFilepath = path2.join(
-      os.tmpdir(),
-      `node-red-settings-final-${process.pid}.cjs`
-    );
-    fs2.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
-    this.compiledRuntimeSettingsFilepath = finalRuntimeSettingsFilepath;
-    return finalRuntimeSettingsFilepath;
-  }
-  resolveFromLocalNodeModules() {
-    try {
-      const require_ = createRequire(path2.join(process.cwd(), "package.json"));
-      const pkgJsonPath = require_.resolve("node-red/package.json");
-      const pkgDir = path2.dirname(pkgJsonPath);
-      const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
-      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["node-red"];
-      if (!bin) return null;
-      const entry = path2.resolve(pkgDir, bin);
-      return fs2.existsSync(entry) ? entry : null;
-    } catch {
-      return null;
+  const finalRuntimeSettingsFilepath = path3.join(
+    os2.tmpdir(),
+    `node-red-settings-final-${process.pid}-${port}.cjs`
+  );
+  fs3.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
+  tempFiles.push(finalRuntimeSettingsFilepath);
+  return { filepath: finalRuntimeSettingsFilepath, tempFiles };
+}
+
+// src/vite/node-red-launcher/process.ts
+import { spawn } from "child_process";
+import detect from "detect-port";
+import getPort from "get-port";
+import treeKill from "tree-kill";
+var READY_MARKERS = ["Started flows", "Server now running"];
+function start(options) {
+  const { entryPoint, settingsPath, args, onLine } = options;
+  const child = spawn(
+    process.execPath,
+    [entryPoint, "-s", settingsPath, ...args],
+    {
+      stdio: ["ignore", "pipe", "pipe"]
     }
-  }
-  resolveNodeRedEntryPoint() {
-    this.logger.info(`Resolving ${this.nodeRedCommand} entry point...`);
-    const localEntry = this.resolveFromLocalNodeModules();
-    if (localEntry) {
-      this.logger.info(`Resolved from local node_modules: ${localEntry}`);
-      return localEntry;
+  );
+  let isReady = false;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+  const emitLine = (rawLine, source) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (!line) return;
+    onLine(line, source, isReady);
+    if (source === "stdout" && READY_MARKERS.some((marker) => line.includes(marker))) {
+      isReady = true;
+      resolveReady();
     }
-    this.logger.info(
-      `Not found locally, downloading via npx (this may take a while)...`
-    );
-    const resolverScript = path2.join(
-      os.tmpdir(),
-      `nrg-resolve-node-red-${process.pid}.cjs`
-    );
-    fs2.writeFileSync(
-      resolverScript,
-      `const fs = require("fs");
-const path = require("path");
-const isWin = process.platform === "win32";
-const binName = isWin ? "node-red.cmd" : "node-red";
-const dirs = process.env.PATH.split(path.delimiter);
-for (const d of dirs) {
-  const f = path.join(d, binName);
-  if (fs.existsSync(f)) {
-    if (isWin) {
-      const nodeRedDir = path.resolve(d, "..", "node-red");
-      const pkg = JSON.parse(fs.readFileSync(path.join(nodeRedDir, "package.json"), "utf-8"));
-      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin["node-red"];
-      process.stdout.write(path.resolve(nodeRedDir, bin));
-    } else {
-      process.stdout.write(fs.realpathSync(f));
+  };
+  const remainders = { stdout: "", stderr: "" };
+  const handleData = (data, source) => {
+    const lines = (remainders[source] + data.toString()).split("\n");
+    remainders[source] = lines.pop() ?? "";
+    for (const line of lines) {
+      emitLine(line, source);
     }
-    break;
-  }
-}`
-    );
-    try {
-      const entryPoint = execSync(
-        `npx --yes -p ${this.nodeRedCommand} -c "node ${resolverScript}"`,
-        { encoding: "utf-8", timeout: 3e5 }
-      ).trim();
-      if (!entryPoint || !fs2.existsSync(entryPoint)) {
-        throw new NodeRedStartError(
-          new Error(
-            `Could not resolve node-red entry point: ${entryPoint || "(empty)"}`
-          )
-        );
+  };
+  const flushRemainders = () => {
+    for (const source of ["stdout", "stderr"]) {
+      const rest = remainders[source];
+      remainders[source] = "";
+      if (rest) {
+        emitLine(rest, source);
       }
-      this.logger.info(`Resolved via npx: ${entryPoint}`);
-      return entryPoint;
-    } finally {
-      try {
-        fs2.unlinkSync(resolverScript);
-      } catch {
+    }
+  };
+  child.stdout?.on("data", (data) => handleData(data, "stdout"));
+  child.stderr?.on("data", (data) => handleData(data, "stderr"));
+  child.on("error", (error) => {
+    rejectReady(new NodeRedStartError(error));
+  });
+  child.on("exit", (code) => {
+    flushRemainders();
+    if (!isReady && code !== 0 && code !== null) {
+      rejectReady(
+        new NodeRedStartError(new Error(`Process exited with code ${code}`))
+      );
+      return;
+    }
+    resolveReady();
+  });
+  return { child, ready };
+}
+function kill(pid) {
+  return new Promise((resolve) => {
+    treeKill(pid, "SIGKILL", () => resolve());
+  });
+}
+async function stop(options) {
+  const { child, pid, gracefulTimeoutMs = 1e4, logger: logger2 } = options;
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return;
+  }
+  const exited = new Promise((resolve) => {
+    child.once("exit", () => resolve());
+    treeKill(pid, "SIGTERM", (error) => {
+      if (error) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+          resolve();
+        }
       }
+    });
+  });
+  try {
+    await withTimeout(exited, gracefulTimeoutMs);
+  } catch {
+    logger2.warn("Graceful shutdown timed out, force killing...");
+    await kill(pid);
+  }
+}
+async function acquirePort(options) {
+  const { preferredPort, retryDelay = 2e3, logger: logger2 } = options;
+  const available = await detect(preferredPort);
+  if (available === preferredPort) {
+    return preferredPort;
+  }
+  logger2.warn(`Port ${preferredPort} is still in use, waiting...`);
+  await new Promise((resolve) => setTimeout(resolve, retryDelay));
+  const retryAvailable = await detect(preferredPort);
+  if (retryAvailable === preferredPort) {
+    return preferredPort;
+  }
+  const fallbackPort = await getPort({ port: preferredPort });
+  logger2.warn(
+    `Port ${preferredPort} still occupied, using port ${fallbackPort}`
+  );
+  return fallbackPort;
+}
+async function waitForPortRelease(port, options = {}) {
+  const { attempts = 10, delay = 300 } = options;
+  const checkPortUsage = async () => {
+    const availablePort = await detect(port);
+    if (availablePort !== port) {
+      throw new Error("Port still in use");
     }
+  };
+  try {
+    await retry(checkPortUsage, { attempts, delay });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/vite/node-red-launcher/index.ts
+var NodeRedLauncher = class {
+  operationQueue = Promise.resolve();
+  process = null;
+  unwatchExit = null;
+  nodeRedEntryPoint = null;
+  tempFiles = [];
+  bufferedLogs = [];
+  port = null;
+  outDir;
+  options;
+  _slug;
+  logger;
+  constructor(outDir, options, slug = "") {
+    this.outDir = outDir;
+    this.options = options;
+    this._slug = slug;
+    this.logger = new Logger({
+      name: "vite-plugin-node-red",
+      prefix: "node-red"
+    });
+  }
+  get preferredPort() {
+    return this.options.runtime?.port ?? 1880;
+  }
+  get slug() {
+    return this._slug;
+  }
+  get basePath() {
+    return this._slug ? `/${this._slug}/` : "/";
+  }
+  get restartDelay() {
+    return this.options.restartDelay ?? 1e3;
+  }
+  get pid() {
+    return this.process?.child.pid ?? null;
+  }
+  get nodeRedCommand() {
+    return getNodeRedCommand(this.options.runtime?.version);
   }
   log(line) {
     if (line.includes("Server now running at")) {
@@ -460,150 +664,122 @@ for (const d of dirs) {
     }
     this.logger.raw(line);
   }
-  async start() {
-    const available = await detect(this.preferredPort);
-    if (available === this.preferredPort) {
-      this.port = this.preferredPort;
+  handleProcessLine(line, source, ready) {
+    if (!ready) {
+      this.bufferedLogs.push(line);
+    } else if (source === "stderr") {
+      this.logger.error(line);
     } else {
+      this.log(line);
+    }
+  }
+  async killProcess() {
+    if (!this.process) return;
+    this.stopWatchingExit();
+    const pid = this.process.child.pid;
+    if (pid) {
+      await kill(pid);
+    }
+    this.process = null;
+  }
+  watchForUnexpectedExit(managed) {
+    const onExit = (code, signal) => {
+      this.unwatchExit = null;
+      this.process = null;
       this.logger.warn(
-        `Port ${this.preferredPort} is still in use, waiting...`
+        `Node-RED exited unexpectedly (${signal ?? `code ${code}`})`
       );
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const retryAvailable = await detect(this.preferredPort);
-      if (retryAvailable === this.preferredPort) {
-        this.port = this.preferredPort;
-      } else {
-        this.logger.warn(
-          `Port ${this.preferredPort} still occupied, using port ${retryAvailable}`
-        );
-        this.port = await getPort({ port: this.preferredPort });
-      }
-    }
-    const nodeRedEntryPoint = this.resolveNodeRedEntryPoint();
-    const startProcess = () => {
-      return new Promise(async (resolve, reject) => {
-        try {
-          const settingsPath = await this.generateRuntimeSettingsFile();
-          const args = this.options.args ?? [];
-          this.bufferedLogs = [];
-          this.isReady = false;
-          this.process = spawn(
-            process.execPath,
-            [nodeRedEntryPoint, "-s", settingsPath, ...args],
-            {
-              stdio: ["ignore", "pipe", "pipe"]
-            }
-          );
-          this.process.stdout?.on("data", (data) => {
-            const lines = data.toString().split("\n").filter(Boolean);
-            for (const line of lines) {
-              if (this.isReady) {
-                this.log(line);
-              } else {
-                this.bufferedLogs.push(line);
-              }
-              if (line.includes("Started flows") || line.includes("Server now running")) {
-                this.isReady = true;
-                resolve(void 0);
-              }
-            }
-          });
-          this.process.stderr?.on("data", (data) => {
-            const lines = data.toString().split("\n").filter(Boolean);
-            for (const line of lines) {
-              if (this.isReady) {
-                this.logger.error(`${line}`);
-              } else {
-                this.bufferedLogs.push(line);
-              }
-            }
-          });
-          this.process.on("error", (error) => {
-            reject(new NodeRedStartError(error));
-          });
-          this.process.on("exit", (code) => {
-            if (!this.isReady && code !== 0 && code !== null) {
-              reject(
-                new NodeRedStartError(
-                  new Error(`Process exited with code ${code}`)
-                )
-              );
-            }
-            resolve(void 0);
-          });
-        } catch (error) {
-          reject(new NodeRedStartError(error));
-        }
-      });
     };
+    managed.child.once("exit", onExit);
+    this.unwatchExit = () => managed.child.off("exit", onExit);
+  }
+  stopWatchingExit() {
+    this.unwatchExit?.();
+    this.unwatchExit = null;
+  }
+  // start/stop interleaving (e.g. SIGINT while Node-RED is booting) would
+  // race on process/port state and could leak a spawned process, so all
+  // lifecycle operations run strictly one at a time
+  enqueue(operation) {
+    const result = this.operationQueue.then(operation, operation);
+    this.operationQueue = result.catch(() => {
+    });
+    return result;
+  }
+  async start() {
+    return this.enqueue(() => this.doStart());
+  }
+  async stop(skipPortUsageCheck = false) {
+    return this.enqueue(() => this.doStop(skipPortUsageCheck));
+  }
+  async doStart() {
     try {
+      this.port = await acquirePort({
+        preferredPort: this.preferredPort,
+        logger: this.logger
+      });
+      if (!this.nodeRedEntryPoint || !fs4.existsSync(this.nodeRedEntryPoint)) {
+        this.nodeRedEntryPoint = await resolveNodeRed({
+          version: this.options.runtime?.version,
+          logger: this.logger
+        });
+      }
+      const nodeRedEntryPoint = this.nodeRedEntryPoint;
+      const settings = await generateRuntimeSettings({
+        outDir: this.outDir,
+        port: this.port,
+        settingsFilepath: this.options.runtime?.settingsFilepath,
+        httpAdminRoot: this._slug ? this.basePath : void 0,
+        logger: this.logger
+      });
+      for (const file of settings.tempFiles) {
+        if (!this.tempFiles.includes(file)) {
+          this.tempFiles.push(file);
+        }
+      }
+      const startProcess = async () => {
+        await this.killProcess();
+        this.bufferedLogs = [];
+        this.process = start({
+          entryPoint: nodeRedEntryPoint,
+          settingsPath: settings.filepath,
+          args: this.options.args ?? [],
+          onLine: (line, source, ready) => this.handleProcessLine(line, source, ready)
+        });
+        await this.process.ready;
+      };
       await retry(startProcess, { attempts: 3, delay: 100 });
+      this.watchForUnexpectedExit(this.process);
       return this.port;
     } catch (error) {
-      if (this.process) {
-        const pid = this.process.pid;
-        if (pid) {
-          treeKill(pid, "SIGKILL");
-        }
-        this.process = null;
-      }
-      throw new NodeRedStartError(error);
+      await this.killProcess();
+      throw error instanceof NodeRedStartError ? error : new NodeRedStartError(error);
     }
   }
-  async stop(skipPortUsageCheck = false) {
+  async doStop(skipPortUsageCheck) {
     if (!this.process) return;
-    const pid = this.process.pid;
+    this.stopWatchingExit();
+    const pid = this.process.child.pid;
     const currentPort = this.port;
     if (!pid) {
       this.process = null;
+      this.port = null;
       return;
     }
-    const stopProcess = new Promise((resolve) => {
-      this.process.once("exit", () => {
-        this.process = null;
-        resolve(void 0);
-      });
-      treeKill(pid, "SIGTERM", (error) => {
-        if (error) {
-          try {
-            process.kill(pid, "SIGTERM");
-          } catch {
-            this.process = null;
-            resolve(void 0);
-          }
-        }
-      });
+    await stop({
+      child: this.process.child,
+      pid,
+      logger: this.logger
     });
-    try {
-      await withTimeout(stopProcess, 1e4);
-    } catch {
-      this.logger.warn("Graceful shutdown timed out, force killing...");
-      await new Promise((resolve) => {
-        treeKill(pid, "SIGKILL", () => {
-          this.process = null;
-          resolve(void 0);
-        });
-      });
-    }
+    this.process = null;
     if (!skipPortUsageCheck && currentPort) {
-      const checkPortUsage = async () => {
-        const availablePort = await detect(currentPort);
-        if (availablePort !== currentPort) {
-          throw new Error("Port still in use");
-        }
-      };
-      try {
-        await retry(checkPortUsage, { attempts: 10, delay: 300 });
-      } catch {
+      const released = await waitForPortRelease(currentPort);
+      if (!released) {
         this.logger.warn(
           `Port ${currentPort} still in use after stop. Force killing...`
         );
-        if (pid) {
-          await new Promise((resolve) => {
-            treeKill(pid, "SIGKILL", () => resolve());
-          });
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-        }
+        await kill(pid);
+        await waitForPortRelease(currentPort);
       }
     }
     this.port = null;
@@ -615,32 +791,35 @@ for (const d of dirs) {
     this.bufferedLogs = [];
   }
   cleanup() {
-    if (this.compiledRuntimeSettingsFilepath && fs2.existsSync(this.compiledRuntimeSettingsFilepath)) {
-      fs2.unlinkSync(this.compiledRuntimeSettingsFilepath);
-      this.compiledRuntimeSettingsFilepath = null;
+    for (const file of this.tempFiles) {
+      try {
+        fs4.unlinkSync(file);
+      } catch {
+      }
     }
+    this.tempFiles = [];
   }
 };
 
 // src/vite/plugins/server.ts
 import chokidar from "chokidar";
 import treeKill2 from "tree-kill";
-import path12 from "path";
+import path13 from "path";
 
 // src/vite/server/build.ts
 import { build as viteBuild } from "vite";
-import fs5 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 
 // src/vite/server/plugins/type-generator.ts
 import dts from "vite-plugin-dts";
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 import ts from "typescript";
 function collectTsFiles(dir) {
-  if (!fs3.existsSync(dir)) return [];
-  return fs3.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const full = path3.join(dir, dirent.name);
+  if (!fs5.existsSync(dir)) return [];
+  return fs5.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
+    const full = path4.join(dir, dirent.name);
     if (dirent.isDirectory()) return collectTsFiles(full);
     if (dirent.isFile() && dirent.name.endsWith(".ts") && !dirent.name.endsWith(".d.ts"))
       return [full];
@@ -655,7 +834,7 @@ var BASE_CLASS_SLOTS = {
   ConfigNode: ["Config", "Credentials", "Settings"]
 };
 function getNodeTypeExports(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs5.readFileSync(filePath, "utf-8");
   const source = ts.createSourceFile(
     filePath,
     content,
@@ -717,7 +896,7 @@ var SCHEMA_PROP_SEMANTICS = {
   settingsSchema: "SettingsSchema"
 };
 function getSchemaReferences(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs5.readFileSync(filePath, "utf-8");
   const source = ts.createSourceFile(
     filePath,
     content,
@@ -809,7 +988,7 @@ function getSchemaReferences(filePath) {
   return result;
 }
 function getFactoryInfo(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs5.readFileSync(filePath, "utf-8");
   const source = ts.createSourceFile(
     filePath,
     content,
@@ -843,13 +1022,13 @@ function buildTypeArg(schemaMap, semanticName, portNameMap) {
   return `[${names.map((n) => `Infer<typeof ${n}>`).join(", ")}]`;
 }
 function buildNodeReexports(srcDir, entryFile) {
-  const nodesDir = path3.join(srcDir, "nodes");
+  const nodesDir = path4.join(srcDir, "nodes");
   const nodeFiles = collectTsFiles(nodesDir);
   return nodeFiles.map((file) => {
-    const rel = path3.relative(path3.dirname(entryFile), file).replace(/\\/g, "/");
+    const rel = path4.relative(path4.dirname(entryFile), file).replace(/\\/g, "/");
     const relPath = rel.startsWith(".") ? rel : `./${rel}`;
     const specifier = relPath.replace(/\.ts$/, "");
-    const ns = toPascalCase(path3.basename(file, ".ts"));
+    const ns = toPascalCase(path4.basename(file, ".ts"));
     const schemaRefs = getSchemaReferences(file);
     const factoryInfo = getFactoryInfo(file);
     const lines = [];
@@ -876,9 +1055,9 @@ function buildNodeReexports(srcDir, entryFile) {
       if (hasSchemas) {
         const bySource2 = /* @__PURE__ */ new Map();
         for (const ref of schemaRefs) {
-          const resolvedSource = path3.relative(
-            path3.dirname(entryFile),
-            path3.resolve(path3.dirname(file), ref.importSource)
+          const resolvedSource = path4.relative(
+            path4.dirname(entryFile),
+            path4.resolve(path4.dirname(file), ref.importSource)
           ).replace(/\\/g, "/");
           const sourceSpecifier = resolvedSource.startsWith(".") ? resolvedSource : `./${resolvedSource}`;
           if (!bySource2.has(sourceSpecifier))
@@ -924,9 +1103,9 @@ function buildNodeReexports(srcDir, entryFile) {
     }
     const bySource = /* @__PURE__ */ new Map();
     for (const ref of schemaRefs) {
-      const resolvedSource = path3.relative(
-        path3.dirname(entryFile),
-        path3.resolve(path3.dirname(file), ref.importSource)
+      const resolvedSource = path4.relative(
+        path4.dirname(entryFile),
+        path4.resolve(path4.dirname(file), ref.importSource)
       ).replace(/\\/g, "/");
       const sourceSpecifier = resolvedSource.startsWith(".") ? resolvedSource : `./${resolvedSource}`;
       if (!bySource.has(sourceSpecifier)) bySource.set(sourceSpecifier, []);
@@ -940,12 +1119,12 @@ function buildNodeReexports(srcDir, entryFile) {
 }
 function typeGenerator(options) {
   const { srcDir, outDir, entryFiles } = options;
-  const serverTsconfig = path3.resolve(srcDir, "tsconfig.json");
-  const rootTsconfig = path3.resolve("tsconfig.json");
-  const userTsconfig = fs3.existsSync(serverTsconfig) ? serverTsconfig : rootTsconfig;
-  const clientDir = path3.relative(
+  const serverTsconfig = path4.resolve(srcDir, "tsconfig.json");
+  const rootTsconfig = path4.resolve("tsconfig.json");
+  const userTsconfig = fs5.existsSync(serverTsconfig) ? serverTsconfig : rootTsconfig;
+  const clientDir = path4.relative(
     process.cwd(),
-    path3.join(path3.dirname(srcDir), "client")
+    path4.join(path4.dirname(srcDir), "client")
   );
   const augmentedContents = /* @__PURE__ */ new Map();
   let origReadFile = null;
@@ -957,9 +1136,9 @@ function typeGenerator(options) {
       for (const entryFile of entryFiles) {
         const reexports = buildNodeReexports(srcDir, entryFile);
         if (!reexports) continue;
-        const original = fs3.readFileSync(entryFile, "utf-8");
+        const original = fs5.readFileSync(entryFile, "utf-8");
         augmentedContents.set(
-          path3.resolve(entryFile),
+          path4.resolve(entryFile),
           `${original}
 ${reexports}
 `
@@ -968,7 +1147,7 @@ ${reexports}
       if (augmentedContents.size === 0) return;
       origReadFile = ts.sys.readFile.bind(ts.sys);
       ts.sys.readFile = (fileName, encoding) => {
-        const resolved = path3.resolve(fileName);
+        const resolved = path4.resolve(fileName);
         return augmentedContents.get(resolved) ?? origReadFile(fileName, encoding);
       };
     },
@@ -992,7 +1171,7 @@ ${reexports}
         }
       },
       outDir,
-      ...fs3.existsSync(userTsconfig) && { tsconfigPath: userTsconfig },
+      ...fs5.existsSync(userTsconfig) && { tsconfigPath: userTsconfig },
       compilerOptions: {
         noEmit: false,
         declaration: true,
@@ -1065,8 +1244,8 @@ function esmWrapper() {
 }
 
 // src/vite/server/plugins/package-json-generator.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 import { builtinModules as builtinModules2 } from "node:module";
 var nodeBuiltins = /* @__PURE__ */ new Set([
   ...builtinModules2,
@@ -1155,13 +1334,13 @@ function packageJsonGenerator(options) {
       }
     },
     closeBundle() {
-      const rootPackageJsonPath = path4.resolve("./package.json");
-      if (!fs4.existsSync(rootPackageJsonPath)) {
+      const rootPackageJsonPath = path5.resolve("./package.json");
+      if (!fs6.existsSync(rootPackageJsonPath)) {
         logger.warn(`package.json not found: ${rootPackageJsonPath}`);
         return;
       }
       const rootPackageJson = JSON.parse(
-        fs4.readFileSync(rootPackageJsonPath, "utf-8")
+        fs6.readFileSync(rootPackageJsonPath, "utf-8")
       );
       const sourceDeps = rootPackageJson.dependencies ?? {};
       const peerDeps = rootPackageJson.peerDependencies ?? {};
@@ -1173,12 +1352,12 @@ function packageJsonGenerator(options) {
         if (sourceDeps[dep]) {
           distDependencies[dep] = sourceDeps[dep];
         } else {
-          const dependencyPackageJsonPath = path4.resolve(
+          const dependencyPackageJsonPath = path5.resolve(
             `./node_modules/${dep}/package.json`
           );
-          if (fs4.existsSync(dependencyPackageJsonPath)) {
+          if (fs6.existsSync(dependencyPackageJsonPath)) {
             const dependencyPackageJson = JSON.parse(
-              fs4.readFileSync(dependencyPackageJsonPath, "utf-8")
+              fs6.readFileSync(dependencyPackageJsonPath, "utf-8")
             );
             distDependencies[dep] = `^${dependencyPackageJson.version}`;
           }
@@ -1215,11 +1394,11 @@ function packageJsonGenerator(options) {
           }
         }
       }
-      if (!fs4.existsSync(outDir)) {
-        fs4.mkdirSync(outDir, { recursive: true });
+      if (!fs6.existsSync(outDir)) {
+        fs6.mkdirSync(outDir, { recursive: true });
       }
-      fs4.writeFileSync(
-        path4.join(outDir, "package.json"),
+      fs6.writeFileSync(
+        path5.join(outDir, "package.json"),
         JSON.stringify(distPackageJson, null, 2)
       );
     }
@@ -1238,11 +1417,11 @@ async function build(serverOpts, buildContext) {
     nodeTarget = "node22"
   } = serverOpts;
   const entries = Array.isArray(entry) ? entry : [entry];
-  const resolvedSrcDir = path5.resolve(srcDir);
+  const resolvedSrcDir = path6.resolve(srcDir);
   const entryPoints = {};
   for (const entry2 of entries) {
-    const entryFilePath = path5.join(resolvedSrcDir, entry2);
-    if (fs5.existsSync(entryFilePath)) {
+    const entryFilePath = path6.join(resolvedSrcDir, entry2);
+    if (fs7.existsSync(entryFilePath)) {
       const fileName = entry2.replace(/\.ts$/, "");
       entryPoints[fileName] = entryFilePath;
     }
@@ -1318,7 +1497,7 @@ module.exports = function (RED) {
     });
 };
 `;
-      fs5.writeFileSync(path5.join(buildContext.outDir, "index.js"), bridgeCode);
+      fs7.writeFileSync(path6.join(buildContext.outDir, "index.js"), bridgeCode);
     }
   } catch (error) {
     throw new BuildError("server", error);
@@ -1328,12 +1507,12 @@ module.exports = function (RED) {
 // src/vite/client/build.ts
 import { build as viteBuild2 } from "vite";
 import vue from "@vitejs/plugin-vue";
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 
 // src/vite/client/plugins/help-generator.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { createRequire as createRequire2 } from "module";
 
@@ -1655,9 +1834,9 @@ ${table}
 `;
 }
 function loadNodeLabels(labelPath) {
-  if (!fs6.existsSync(labelPath)) return {};
+  if (!fs8.existsSync(labelPath)) return {};
   try {
-    const raw = JSON.parse(fs6.readFileSync(labelPath, "utf-8"));
+    const raw = JSON.parse(fs8.readFileSync(labelPath, "utf-8"));
     return {
       description: raw.description,
       configs: raw.configs,
@@ -1699,10 +1878,10 @@ function generateHelpDoc(nodeClass, labels, t) {
     if (inputSection) lines.push(inputSection);
   }
   if (nodeClass.outputsSchema) {
-    const os2 = nodeClass.outputsSchema;
-    if (Array.isArray(os2)) {
+    const os3 = nodeClass.outputsSchema;
+    if (Array.isArray(os3)) {
       const portSections = [];
-      os2.forEach((schema, i) => {
+      os3.forEach((schema, i) => {
         const title = `${t.sections.port} ${i + 1}`;
         const portPropLabels = labels.outputs?.[i];
         const section = generateSchemaSection({
@@ -1721,9 +1900,9 @@ function generateHelpDoc(nodeClass, labels, t) {
 ${portSections.join("\n")}`
         );
       }
-    } else if (!("type" in os2 || "properties" in os2)) {
+    } else if (!("type" in os3 || "properties" in os3)) {
       const portSections = [];
-      for (const [portName, schema] of Object.entries(os2)) {
+      for (const [portName, schema] of Object.entries(os3)) {
         const portPropLabels = labels.outputs?.[portName];
         const section = generateSchemaSection({
           title: portName,
@@ -1745,7 +1924,7 @@ ${portSections.join("\n")}`
       const outputPropLabels = labels.outputs?.[0];
       const section = generateSchemaSection({
         title: t.sections.output,
-        schema: os2,
+        schema: os3,
         t,
         labels: outputPropLabels,
         includeDefault: false
@@ -1756,9 +1935,9 @@ ${portSections.join("\n")}`
   return lines.join("\n").trim();
 }
 function discoverLanguages(labelsDir, nodeType) {
-  const nodeLabelsDir = path6.join(labelsDir, nodeType);
-  if (!fs6.existsSync(nodeLabelsDir)) return [];
-  return fs6.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path6.basename(f, ".json"));
+  const nodeLabelsDir = path7.join(labelsDir, nodeType);
+  if (!fs8.existsSync(nodeLabelsDir)) return [];
+  return fs8.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path7.basename(f, ".json"));
 }
 function helpGenerator(options) {
   const { outDir, localesOutDir, docsDir, labelsDir } = options;
@@ -1767,15 +1946,15 @@ function helpGenerator(options) {
     apply: "build",
     enforce: "post",
     async closeBundle() {
-      const esmPath = path6.resolve(outDir, "index.mjs");
-      const cjsPath = path6.resolve(outDir, "index.js");
+      const esmPath = path7.resolve(outDir, "index.mjs");
+      const cjsPath = path7.resolve(outDir, "index.js");
       let packageFn;
       try {
-        if (fs6.existsSync(esmPath)) {
+        if (fs8.existsSync(esmPath)) {
           const fileUrl = pathToFileURL2(esmPath).href + `?t=${Date.now()}`;
           const mod = await import(fileUrl);
           packageFn = mod?.default ?? mod;
-        } else if (fs6.existsSync(cjsPath)) {
+        } else if (fs8.existsSync(cjsPath)) {
           const require2 = createRequire2(import.meta.url);
           delete require2.cache[cjsPath];
           const rawMod = require2(cjsPath);
@@ -1792,10 +1971,10 @@ function helpGenerator(options) {
         const languages = discoverLanguages(labelsDir, type);
         if (!languages.includes("en-US")) languages.push("en-US");
         for (const lang of languages) {
-          const manualMd = path6.join(docsDir, type, `${lang}.md`);
-          const manualHtml = path6.join(docsDir, type, `${lang}.html`);
-          if (fs6.existsSync(manualMd) || fs6.existsSync(manualHtml)) continue;
-          const labelPath = path6.join(labelsDir, type, `${lang}.json`);
+          const manualMd = path7.join(docsDir, type, `${lang}.md`);
+          const manualHtml = path7.join(docsDir, type, `${lang}.html`);
+          if (fs8.existsSync(manualMd) || fs8.existsSync(manualHtml)) continue;
+          const labelPath = path7.join(labelsDir, type, `${lang}.json`);
           const labels = loadNodeLabels(labelPath);
           const t = getHelpTranslations(lang);
           const content = generateHelpDoc(NodeClass, labels, t);
@@ -1809,11 +1988,11 @@ ${content}
         }
       }
       for (const [lang, scripts] of helpByLang) {
-        const langDir = path6.join(localesOutDir, lang);
-        fs6.mkdirSync(langDir, { recursive: true });
-        const indexPath = path6.join(langDir, "index.html");
-        const existing = fs6.existsSync(indexPath) ? fs6.readFileSync(indexPath, "utf-8") : "";
-        fs6.writeFileSync(
+        const langDir = path7.join(localesOutDir, lang);
+        fs8.mkdirSync(langDir, { recursive: true });
+        const indexPath = path7.join(langDir, "index.html");
+        const existing = fs8.existsSync(indexPath) ? fs8.readFileSync(indexPath, "utf-8") : "";
+        fs8.writeFileSync(
           indexPath,
           existing + (existing ? "\n" : "") + scripts.join("\n"),
           "utf-8"
@@ -1825,8 +2004,8 @@ ${content}
 
 // src/vite/client/plugins/html-generator.ts
 import mime from "mime-types";
-import fs7 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function htmlGenerator(options) {
   const { packageName, licensePath } = options;
   return {
@@ -1836,7 +2015,7 @@ function htmlGenerator(options) {
     generateBundle(_, bundle) {
       const resourcesTags = Object.keys(bundle).map((fileName) => {
         const asset = bundle[fileName];
-        const srcPath = path7.join(
+        const srcPath = path8.join(
           "resources",
           packageName,
           fileName.replace(/^resources\/?/, "")
@@ -1864,8 +2043,8 @@ function htmlGenerator(options) {
             return null;
         }
       }).filter(Boolean).join("\n");
-      const licenseBanner = licensePath && fs7.existsSync(licensePath) ? `<!--
-${fs7.readFileSync(licensePath, "utf-8")}
+      const licenseBanner = licensePath && fs9.existsSync(licensePath) ? `<!--
+${fs9.readFileSync(licensePath, "utf-8")}
 -->` : "";
       this.emitFile({
         type: "asset",
@@ -1878,8 +2057,8 @@ ${resourcesTags}`
 }
 
 // src/vite/client/plugins/locales-generator.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 import { merge } from "es-toolkit";
 function localesGenerator(options) {
   const { outDir, docsDir, labelsDir } = options;
@@ -1897,103 +2076,113 @@ function localesGenerator(options) {
   ];
   const frameworkLabels = {
     "en-US": {
-      configs: { name: "Name" },
+      configs: { name: "Name", returnProperty: "Return key" },
       toggles: {
         validateInput: "Validate Input",
         validateOutput: "Validate Output",
         errorPort: "Error Port",
         completePort: "Complete Port",
-        statusPort: "Status Port"
+        statusPort: "Status Port",
+        returnPropertyOverride: "Override return prop key"
       }
     },
     de: {
-      configs: { name: "Name" },
+      configs: { name: "Name", returnProperty: "R\xFCckgabe-Schl\xFCssel" },
       toggles: {
         validateInput: "Eingabe validieren",
         validateOutput: "Ausgabe validieren",
         errorPort: "Fehler-Port",
         completePort: "Abschluss-Port",
-        statusPort: "Status-Port"
+        statusPort: "Status-Port",
+        returnPropertyOverride: "R\xFCckgabe-Schl\xFCssel \xFCberschreiben"
       }
     },
     "es-ES": {
-      configs: { name: "Nombre" },
+      configs: { name: "Nombre", returnProperty: "Clave de retorno" },
       toggles: {
         validateInput: "Validar entrada",
         validateOutput: "Validar salida",
         errorPort: "Puerto de error",
         completePort: "Puerto de completado",
-        statusPort: "Puerto de estado"
+        statusPort: "Puerto de estado",
+        returnPropertyOverride: "Sobrescribir clave de retorno"
       }
     },
     fr: {
-      configs: { name: "Nom" },
+      configs: { name: "Nom", returnProperty: "Cl\xE9 de retour" },
       toggles: {
         validateInput: "Valider l'entr\xE9e",
         validateOutput: "Valider la sortie",
         errorPort: "Port d'erreur",
         completePort: "Port de compl\xE9tion",
-        statusPort: "Port de statut"
+        statusPort: "Port de statut",
+        returnPropertyOverride: "Remplacer la cl\xE9 de retour"
       }
     },
     ko: {
-      configs: { name: "\uC774\uB984" },
+      configs: { name: "\uC774\uB984", returnProperty: "\uBC18\uD658 \uD0A4" },
       toggles: {
         validateInput: "\uC785\uB825 \uAC80\uC99D",
         validateOutput: "\uCD9C\uB825 \uAC80\uC99D",
         errorPort: "\uC624\uB958 \uD3EC\uD2B8",
         completePort: "\uC644\uB8CC \uD3EC\uD2B8",
-        statusPort: "\uC0C1\uD0DC \uD3EC\uD2B8"
+        statusPort: "\uC0C1\uD0DC \uD3EC\uD2B8",
+        returnPropertyOverride: "\uBC18\uD658 \uD0A4 \uC7AC\uC815\uC758"
       }
     },
     "pt-BR": {
-      configs: { name: "Nome" },
+      configs: { name: "Nome", returnProperty: "Chave de retorno" },
       toggles: {
         validateInput: "Validar Entrada",
         validateOutput: "Validar Sa\xEDda",
         errorPort: "Porta de Erro",
         completePort: "Porta de Conclus\xE3o",
-        statusPort: "Porta de Status"
+        statusPort: "Porta de Status",
+        returnPropertyOverride: "Sobrescrever chave de retorno"
       }
     },
     ru: {
-      configs: { name: "\u0418\u043C\u044F" },
+      configs: { name: "\u0418\u043C\u044F", returnProperty: "\u041A\u043B\u044E\u0447 \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430" },
       toggles: {
         validateInput: "\u041F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0432\u0445\u043E\u0434",
         validateOutput: "\u041F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0432\u044B\u0445\u043E\u0434",
         errorPort: "\u041F\u043E\u0440\u0442 \u043E\u0448\u0438\u0431\u043A\u0438",
         completePort: "\u041F\u043E\u0440\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u0438\u044F",
-        statusPort: "\u041F\u043E\u0440\u0442 \u0441\u0442\u0430\u0442\u0443\u0441\u0430"
+        statusPort: "\u041F\u043E\u0440\u0442 \u0441\u0442\u0430\u0442\u0443\u0441\u0430",
+        returnPropertyOverride: "\u041F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u043B\u044E\u0447 \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430"
       }
     },
     ja: {
-      configs: { name: "\u540D\u524D" },
+      configs: { name: "\u540D\u524D", returnProperty: "\u623B\u308A\u30AD\u30FC" },
       toggles: {
         validateInput: "\u5165\u529B\u691C\u8A3C",
         validateOutput: "\u51FA\u529B\u691C\u8A3C",
         errorPort: "\u30A8\u30E9\u30FC\u30DD\u30FC\u30C8",
         completePort: "\u5B8C\u4E86\u30DD\u30FC\u30C8",
-        statusPort: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30DD\u30FC\u30C8"
+        statusPort: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30DD\u30FC\u30C8",
+        returnPropertyOverride: "\u623B\u308A\u30AD\u30FC\u3092\u4E0A\u66F8\u304D"
       }
     },
     "zh-CN": {
-      configs: { name: "\u540D\u79F0" },
+      configs: { name: "\u540D\u79F0", returnProperty: "\u8FD4\u56DE\u952E" },
       toggles: {
         validateInput: "\u9A8C\u8BC1\u8F93\u5165",
         validateOutput: "\u9A8C\u8BC1\u8F93\u51FA",
         errorPort: "\u9519\u8BEF\u7AEF\u53E3",
         completePort: "\u5B8C\u6210\u7AEF\u53E3",
-        statusPort: "\u72B6\u6001\u7AEF\u53E3"
+        statusPort: "\u72B6\u6001\u7AEF\u53E3",
+        returnPropertyOverride: "\u8986\u76D6\u8FD4\u56DE\u952E"
       }
     },
     "zh-TW": {
-      configs: { name: "\u540D\u7A31" },
+      configs: { name: "\u540D\u7A31", returnProperty: "\u8FD4\u56DE\u9375" },
       toggles: {
         validateInput: "\u9A57\u8B49\u8F38\u5165",
         validateOutput: "\u9A57\u8B49\u8F38\u51FA",
         errorPort: "\u932F\u8AA4\u7AEF\u53E3",
         completePort: "\u5B8C\u6210\u7AEF\u53E3",
-        statusPort: "\u72C0\u614B\u7AEF\u53E3"
+        statusPort: "\u72C0\u614B\u7AEF\u53E3",
+        returnPropertyOverride: "\u8986\u84CB\u8FD4\u56DE\u9375"
       }
     }
   };
@@ -2012,17 +2201,17 @@ Supported: ${languages.join(", ")}`
       }
       function forEachFile(baseDir, fileExtensions, processFile) {
         const langMap = /* @__PURE__ */ new Map();
-        if (!fs8.existsSync(baseDir)) return langMap;
-        const nodeDirs = fs8.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+        if (!fs10.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs10.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
         for (const nodeDir of nodeDirs) {
           const nodeType = nodeDir.name;
-          const nodePath = path8.join(baseDir, nodeType);
-          const files = fs8.readdirSync(nodePath);
+          const nodePath = path9.join(baseDir, nodeType);
+          const files = fs10.readdirSync(nodePath);
           for (const file of files) {
-            const ext = path8.extname(file);
+            const ext = path9.extname(file);
             if (!fileExtensions.includes(ext)) continue;
-            const lang = path8.basename(file, ext);
-            const filePath = path8.join(nodePath, file);
+            const lang = path9.basename(file, ext);
+            const filePath = path9.join(nodePath, file);
             validateLanguage(lang, filePath);
             const value = processFile({ ext, filePath, nodeType });
             if (value == null) continue;
@@ -2040,10 +2229,10 @@ Supported: ${languages.join(", ")}`
       }
       function writeOutput(langMap, fileName, serialize) {
         for (const [lang, data] of langMap.entries()) {
-          const langOutDir = path8.join(outDir, lang);
-          fs8.mkdirSync(langOutDir, { recursive: true });
-          fs8.writeFileSync(
-            path8.join(langOutDir, fileName),
+          const langOutDir = path9.join(outDir, lang);
+          fs10.mkdirSync(langOutDir, { recursive: true });
+          fs10.writeFileSync(
+            path9.join(langOutDir, fileName),
             serialize(data),
             "utf-8"
           );
@@ -2055,7 +2244,7 @@ Supported: ${languages.join(", ")}`
         ({ ext, filePath, nodeType }) => {
           const type = ext === ".html" ? "text/html" : ext === ".md" ? "text/markdown" : null;
           if (!type) return null;
-          const content = fs8.readFileSync(filePath, "utf-8");
+          const content = fs10.readFileSync(filePath, "utf-8");
           return [
             `<script type="${type}" data-help-name="${nodeType}">
 ${content}
@@ -2072,7 +2261,7 @@ ${content}
         labelsDir,
         [".json"],
         ({ filePath, nodeType }) => {
-          const parsed = JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+          const parsed = JSON.parse(fs10.readFileSync(filePath, "utf-8"));
           if (parsed[nodeType] && typeof parsed[nodeType] === "object") {
             console.warn(
               `[locales] Warning: "${filePath}" uses nested format (root key "${nodeType}"). Label files should be flat \u2014 the node type is added automatically. See https://bonsaedev.github.io/nrg/guide/building-and-running`
@@ -2122,8 +2311,8 @@ function minifier() {
 // src/vite/client/plugins/node-definitions-inliner.ts
 import { createRequire as createRequire3 } from "module";
 import { pathToFileURL as pathToFileURL3 } from "url";
-import path9 from "path";
-import fs9 from "fs";
+import path10 from "path";
+import fs11 from "fs";
 import mime2 from "mime-types";
 var VIRTUAL_ID = "virtual:nrg/node-definitions";
 var RESOLVED_ID = "\0" + VIRTUAL_ID;
@@ -2154,9 +2343,9 @@ function getCredentialsFromSchema(schema) {
   return result;
 }
 function resolveIcon(iconsDir, type) {
-  if (!fs9.existsSync(iconsDir)) return void 0;
-  return fs9.readdirSync(iconsDir).find((f) => {
-    if (path9.basename(f, path9.extname(f)) !== type) return false;
+  if (!fs11.existsSync(iconsDir)) return void 0;
+  return fs11.readdirSync(iconsDir).find((f) => {
+    if (path10.basename(f, path10.extname(f)) !== type) return false;
     const mimeType = mime2.lookup(f);
     return mimeType !== false && mimeType.startsWith("image/");
   });
@@ -2164,7 +2353,7 @@ function resolveIcon(iconsDir, type) {
 function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true) {
   let _nodeTypes = [];
   let _definitions = {};
-  const cacheDir = path9.resolve("node_modules", ".nrg", "client");
+  const cacheDir = path10.resolve("node_modules", ".nrg", "client");
   return {
     name: "vite-plugin-node-red:client:node-definitions-inliner",
     enforce: "pre",
@@ -2173,14 +2362,14 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     async buildStart() {
       _nodeTypes = [];
       _definitions = {};
-      const esmEntryPath = path9.resolve(serverOutDir, "index.mjs");
-      const cjsEntryPath = path9.resolve(serverOutDir, "index.js");
+      const esmEntryPath = path10.resolve(serverOutDir, "index.mjs");
+      const cjsEntryPath = path10.resolve(serverOutDir, "index.js");
       let packageFn;
-      if (fs9.existsSync(esmEntryPath)) {
+      if (fs11.existsSync(esmEntryPath)) {
         const fileUrl = pathToFileURL3(esmEntryPath).href + `?t=${Date.now()}`;
         const mod = await import(fileUrl);
         packageFn = mod?.default ?? mod;
-      } else if (fs9.existsSync(cjsEntryPath)) {
+      } else if (fs11.existsSync(cjsEntryPath)) {
         const require2 = createRequire3(import.meta.url);
         delete require2.cache[cjsEntryPath];
         const rawMod = require2(cjsEntryPath);
@@ -2221,14 +2410,14 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
         };
       }
       if (!hasUserEntry) {
-        const nodesCache = path9.resolve(cacheDir, "nodes");
-        if (fs9.existsSync(nodesCache)) {
-          fs9.rmSync(nodesCache, { recursive: true });
+        const nodesCache = path10.resolve(cacheDir, "nodes");
+        if (fs11.existsSync(nodesCache)) {
+          fs11.rmSync(nodesCache, { recursive: true });
         }
-        fs9.mkdirSync(nodesCache, { recursive: true });
+        fs11.mkdirSync(nodesCache, { recursive: true });
         for (const type of _nodeTypes) {
-          const userTsPath = nodesDir ? path9.resolve(nodesDir, `${type}.ts`) : null;
-          if (userTsPath && fs9.existsSync(userTsPath)) continue;
+          const userTsPath = nodesDir ? path10.resolve(nodesDir, `${type}.ts`) : null;
+          if (userTsPath && fs11.existsSync(userTsPath)) continue;
           const content = [
             `// auto-generated by nrg`,
             `import { defineNode } from "@bonsae/nrg/client";`,
@@ -2238,13 +2427,13 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
             `});`,
             ``
           ].join("\n");
-          fs9.writeFileSync(path9.resolve(nodesCache, `${type}.ts`), content);
+          fs11.writeFileSync(path10.resolve(nodesCache, `${type}.ts`), content);
         }
         const entryContent = generateEntryCode("");
-        fs9.mkdirSync(path9.dirname(path9.resolve(cacheDir, "index.ts")), {
+        fs11.mkdirSync(path10.dirname(path10.resolve(cacheDir, "index.ts")), {
           recursive: true
         });
-        fs9.writeFileSync(path9.resolve(cacheDir, "index.ts"), entryContent);
+        fs11.writeFileSync(path10.resolve(cacheDir, "index.ts"), entryContent);
       }
     },
     resolveId(id) {
@@ -2267,12 +2456,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     const nrgImports = /* @__PURE__ */ new Set(["__setSchemas"]);
     const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
     const postLines = [`__setSchemas(__nrgSchemas);`];
-    if (componentsDir && fs9.existsSync(componentsDir)) {
+    if (componentsDir && fs11.existsSync(componentsDir)) {
       const formImports = [];
       const formEntries = [];
       for (const type of _nodeTypes) {
-        const componentPath = path9.resolve(componentsDir, `${type}.vue`);
-        if (fs9.existsSync(componentPath)) {
+        const componentPath = path10.resolve(componentsDir, `${type}.vue`);
+        if (fs11.existsSync(componentPath)) {
           const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
           formImports.push(
             `import ${varName} from ${JSON.stringify(componentPath)};`
@@ -2287,12 +2476,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
       }
     }
     if (!hasUserEntry) {
-      const nodesCache = path9.resolve(cacheDir, "nodes");
+      const nodesCache = path10.resolve(cacheDir, "nodes");
       const defVarNames = [];
       for (const type of _nodeTypes) {
         const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
-        const userTsPath = nodesDir ? path9.resolve(nodesDir, `${type}.ts`) : null;
-        const tsPath = userTsPath && fs9.existsSync(userTsPath) ? userTsPath : path9.resolve(nodesCache, `${type}.ts`);
+        const userTsPath = nodesDir ? path10.resolve(nodesDir, `${type}.ts`) : null;
+        const tsPath = userTsPath && fs11.existsSync(userTsPath) ? userTsPath : path10.resolve(nodesCache, `${type}.ts`);
         lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
         defVarNames.push(varName);
       }
@@ -2310,8 +2499,8 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
 }
 
 // src/vite/client/plugins/static-copy.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 function staticCopy(options) {
   const { targets } = options;
   return {
@@ -2320,23 +2509,23 @@ function staticCopy(options) {
     enforce: "post",
     closeBundle() {
       for (const { src, dest } of targets) {
-        if (!fs10.existsSync(src)) continue;
-        fs10.mkdirSync(dest, { recursive: true });
-        const stat = fs10.statSync(src);
+        if (!fs12.existsSync(src)) continue;
+        fs12.mkdirSync(dest, { recursive: true });
+        const stat = fs12.statSync(src);
         if (stat.isDirectory()) {
-          const files = fs10.readdirSync(src);
+          const files = fs12.readdirSync(src);
           for (const file of files) {
-            const srcFile = path10.join(src, file);
-            const destFile = path10.join(dest, file);
-            const fileStat = fs10.statSync(srcFile);
+            const srcFile = path11.join(src, file);
+            const destFile = path11.join(dest, file);
+            const fileStat = fs12.statSync(srcFile);
             if (fileStat.isDirectory()) {
-              fs10.cpSync(srcFile, destFile, { recursive: true });
+              fs12.cpSync(srcFile, destFile, { recursive: true });
             } else {
-              fs10.copyFileSync(srcFile, destFile);
+              fs12.copyFileSync(srcFile, destFile);
             }
           }
         } else {
-          fs10.copyFileSync(src, dest);
+          fs12.copyFileSync(src, dest);
         }
       }
     }
@@ -2357,74 +2546,74 @@ async function build2(clientBuildOptions, buildContext) {
     globals = {},
     manualChunks
   } = clientBuildOptions;
-  const physicalEntryPath = path11.resolve(srcDir, entry);
+  const physicalEntryPath = path12.resolve(srcDir, entry);
   let entryPath;
   let generatedEntry = false;
-  if (fs11.existsSync(physicalEntryPath)) {
+  if (fs13.existsSync(physicalEntryPath)) {
     entryPath = physicalEntryPath;
   } else {
-    const cacheDir = path11.resolve("node_modules", ".nrg", "client");
-    const cachedEntryPath = path11.resolve(cacheDir, entry);
-    if (!fs11.existsSync(cacheDir)) {
-      fs11.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path12.resolve("node_modules", ".nrg", "client");
+    const cachedEntryPath = path12.resolve(cacheDir, entry);
+    if (!fs13.existsSync(cacheDir)) {
+      fs13.mkdirSync(cacheDir, { recursive: true });
     }
-    fs11.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    fs13.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
     entryPath = cachedEntryPath;
     generatedEntry = true;
   }
-  const iconsDir = path11.resolve(
-    staticDirs.icons ?? path11.join(path11.dirname(path11.resolve(srcDir)), "icons")
+  const iconsDir = path12.resolve(
+    staticDirs.icons ?? path12.join(path12.dirname(path12.resolve(srcDir)), "icons")
   );
   const plugins = [
     vue(),
     nodeDefinitionsInliner(
       buildContext.outDir,
       entryPath,
-      fs11.existsSync(iconsDir) ? iconsDir : void 0,
-      path11.resolve(srcDir, "components"),
-      path11.resolve(srcDir, "nodes"),
+      fs13.existsSync(iconsDir) ? iconsDir : void 0,
+      path12.resolve(srcDir, "components"),
+      path12.resolve(srcDir, "nodes"),
       !generatedEntry
     )
   ];
   plugins.push(
     htmlGenerator({
       packageName: buildContext.packageName,
-      licensePath: licensePath ? path11.resolve(licensePath) : void 0
+      licensePath: licensePath ? path12.resolve(licensePath) : void 0
     })
   );
   if (locales) {
     const { docsDir = "./locales/docs", labelsDir = "./locales/labels" } = locales;
-    const localesOutDir = path11.join(buildContext.outDir, "locales");
+    const localesOutDir = path12.join(buildContext.outDir, "locales");
     plugins.push(
       localesGenerator({
         outDir: localesOutDir,
-        docsDir: path11.resolve(docsDir),
-        labelsDir: path11.resolve(labelsDir)
+        docsDir: path12.resolve(docsDir),
+        labelsDir: path12.resolve(labelsDir)
       })
     );
     plugins.push(
       helpGenerator({
         outDir: buildContext.outDir,
         localesOutDir,
-        docsDir: path11.resolve(docsDir),
-        labelsDir: path11.resolve(labelsDir)
+        docsDir: path12.resolve(docsDir),
+        labelsDir: path12.resolve(labelsDir)
       })
     );
   }
   const copyTargets = [];
-  const publicDir = path11.resolve(
-    staticDirs.public ?? path11.join(srcDir, "public")
+  const publicDir = path12.resolve(
+    staticDirs.public ?? path12.join(srcDir, "public")
   );
-  if (fs11.existsSync(publicDir)) {
+  if (fs13.existsSync(publicDir)) {
     copyTargets.push({
       src: publicDir,
-      dest: path11.join(buildContext.outDir, "resources")
+      dest: path12.join(buildContext.outDir, "resources")
     });
   }
-  if (fs11.existsSync(iconsDir)) {
+  if (fs13.existsSync(iconsDir)) {
     copyTargets.push({
       src: iconsDir,
-      dest: path11.join(buildContext.outDir, "icons")
+      dest: path12.join(buildContext.outDir, "icons")
     });
   }
   if (copyTargets.length > 0) {
@@ -2452,10 +2641,10 @@ async function build2(clientBuildOptions, buildContext) {
     configFile: false,
     logLevel: "warn",
     base: `/resources/${buildContext.packageName}`,
-    publicDir: path11.resolve(srcDir, "public"),
+    publicDir: path12.resolve(srcDir, "public"),
     resolve: {
       alias: {
-        "@": path11.resolve(srcDir)
+        "@": path12.resolve(srcDir)
       }
     },
     plugins,
@@ -2509,8 +2698,8 @@ async function build2(clientBuildOptions, buildContext) {
     throw new BuildError("client", error);
   } finally {
     if (generatedEntry) {
-      if (fs11.existsSync(entryPath)) {
-        fs11.unlinkSync(entryPath);
+      if (fs13.existsSync(entryPath)) {
+        fs13.unlinkSync(entryPath);
       }
     }
   }
@@ -2531,6 +2720,8 @@ function serverPlugin(options) {
     extraFilesCopyTargets,
     buildContext
   } = options;
+  const { slug, basePath } = nodeRedLauncher;
+  const proxyKey = slug ? `^/${slug}(?:/|\\?|$)` : "^/.*";
   let nodeRedPort;
   let initialStartDone = false;
   let isStarting = false;
@@ -2555,7 +2746,7 @@ function serverPlugin(options) {
       logger.stopSpinner("Copied extra files");
     }
   };
-  const start = async (clean = false) => {
+  const start2 = async (clean = false) => {
     if (isStarting) {
       pendingStart = true;
       return;
@@ -2570,7 +2761,7 @@ function serverPlugin(options) {
       logger.stopSpinner("Node-RED started");
       const proxyConfig = server.config.server.proxy;
       if (proxyConfig && typeof proxyConfig === "object") {
-        const rule = proxyConfig["^/.*"];
+        const rule = proxyConfig[proxyKey];
         if (rule && typeof rule === "object") {
           rule.target = `http://127.0.0.1:${nodeRedPort}`;
         }
@@ -2588,14 +2779,14 @@ function serverPlugin(options) {
     } finally {
       isStarting = false;
       if (pendingStart) {
-        start(false);
+        start2(false);
       }
     }
   };
   const printServerUrls = (vitePort, nodeRedPorts) => {
     console.log();
     console.log(
-      `  ${color2.cyan("Vite")}      ${color2.dim("\u279C")}  ${color2.cyan(`http://127.0.0.1:${vitePort}/`)}`
+      `  ${color2.cyan("Vite")}      ${color2.dim("\u279C")}  ${color2.cyan(`http://127.0.0.1:${vitePort}${basePath}`)}`
     );
     if (nodeRedPorts.actual != nodeRedPorts.preferred) {
       console.log(
@@ -2617,7 +2808,7 @@ function serverPlugin(options) {
         server: {
           host: "127.0.0.1",
           proxy: {
-            "^/.*": {
+            [proxyKey]: {
               target: `http://127.0.0.1:${nodeRedLauncher.preferredPort}`,
               changeOrigin: true,
               ws: true,
@@ -2660,8 +2851,19 @@ function serverPlugin(options) {
     },
     async configureServer(viteServer) {
       server = viteServer;
+      if (slug) {
+        server.middlewares.use((req, res, next) => {
+          if (req.url === "/" || req.url === "") {
+            res.statusCode = 302;
+            res.setHeader("Location", basePath);
+            res.end();
+            return;
+          }
+          next();
+        });
+      }
       logger.intro();
-      await start(true);
+      await start2(true);
       initialStartDone = true;
       printServerUrls(server.config.server.port ?? 5173, {
         actual: nodeRedPort,
@@ -2669,20 +2871,20 @@ function serverPlugin(options) {
       });
       logger.startGroup("Node-RED");
       nodeRedLauncher.flushLogs();
-      const serverSrcDir = path12.resolve(
+      const serverSrcDir = path13.resolve(
         serverBuildOptions.srcDir ?? "./server"
       );
-      const clientSrcDir = path12.resolve(
+      const clientSrcDir = path13.resolve(
         clientBuildOptions.srcDir ?? "./client"
       );
-      const localesDocsDir = path12.resolve(
+      const localesDocsDir = path13.resolve(
         clientBuildOptions.locales?.docsDir ?? "./locales/docs"
       );
-      const localesLabelsDir = path12.resolve(
+      const localesLabelsDir = path13.resolve(
         clientBuildOptions.locales?.labelsDir ?? "./locales/labels"
       );
-      const iconsDir = path12.resolve(
-        clientBuildOptions.staticDirs?.icons ?? path12.join(path12.dirname(clientSrcDir), "icons")
+      const iconsDir = path13.resolve(
+        clientBuildOptions.staticDirs?.icons ?? path13.join(path13.dirname(clientSrcDir), "icons")
       );
       const watchPaths = [
         serverSrcDir,
@@ -2697,12 +2899,12 @@ function serverPlugin(options) {
         ignored: ["**/node_modules/**", "**/dist/**", "**/.node-red/**"]
       });
       const debounceBeforeStart = debounce(
-        () => start(false),
+        () => start2(false),
         nodeRedLauncher.restartDelay ?? 1e3
       );
       const handleFileChange = (file, event) => {
         if (!initialStartDone) return;
-        logger.info(`${event}: ${path12.relative(process.cwd(), file)}`);
+        logger.info(`${event}: ${path13.relative(process.cwd(), file)}`);
         debounceBeforeStart();
       };
       watcher.on("change", (file) => handleFileChange(file, "Changed"));
@@ -2780,30 +2982,33 @@ function buildPlugin(options) {
 }
 
 // src/vite/plugin.ts
-function nodeRed(options = {}) {
-  const { outDir = DEFAULT_OUTPUT_DIR } = options;
+function nrg(options = {}) {
+  const { build: build3 = {}, server = {} } = options;
+  const { outDir = DEFAULT_OUTPUT_DIR } = build3;
   const clientBuildOptions = mergeOptions(
     DEFAULT_CLIENT_BUILD_OPTIONS,
-    options.clientBuildOptions
+    build3.client
   );
   const serverBuildOptions = mergeOptions(
     DEFAULT_SERVER_BUILD_OPTIONS,
-    options.serverBuildOptions
+    build3.server
   );
   const nodeRedLauncherOptions = mergeOptions(
     DEFAULT_NODE_RED_LAUNCHER_OPTIONS,
-    options.nodeRedLauncherOptions
+    server.nodeRed
   );
-  const extraFilesCopyTargets = options.extraFilesCopyTargets ?? DEFAULT_EXTRA_FILES_COPY_TARGETS;
-  const resolvedOutDir = path13.resolve(outDir);
+  const extraFilesCopyTargets = build3.extraFilesCopyTargets ?? DEFAULT_EXTRA_FILES_COPY_TARGETS;
+  const resolvedOutDir = path14.resolve(outDir);
   const buildContext = {
     outDir: resolvedOutDir,
     packageName: getPackageName(),
     isDev: process.env.NODE_ENV === "development"
   };
+  const slug = resolveSlug(server.slug);
   const nodeRedLauncher = new NodeRedLauncher(
     resolvedOutDir,
-    nodeRedLauncherOptions
+    nodeRedLauncherOptions,
+    slug
   );
   return [
     serverPlugin({
@@ -2822,5 +3027,5 @@ function nodeRed(options = {}) {
   ];
 }
 export {
-  nodeRed
+  nrg
 };