@bonsae/nrg 0.1.0

package/build/vite/index.js

@@ -0,0 +1,1893 @@
+// src/vite/plugin.ts
+import path13 from "path";
+
+// src/vite/defaults.ts
+var DEFAULT_OUTPUT_DIR = "./dist";
+var DEFAULT_CLIENT_BUILD_OPTIONS = {
+  srcDir: "./src/client",
+  entry: "index.ts",
+  nodesSubdir: "nodes",
+  name: "NodeRedNodes",
+  format: "es",
+  licensePath: "./LICENSE",
+  external: ["jquery", "node-red", "vue", "@bonsae/nrg/client"],
+  globals: {
+    jquery: "$",
+    "node-red": "RED",
+    vue: "Vue"
+  },
+  locales: {
+    docsDir: "./src/locales/docs",
+    labelsDir: "./src/locales/labels",
+    languages: [
+      "en-US",
+      "de",
+      "es-ES",
+      "fr",
+      "ko",
+      "pt-BR",
+      "ru",
+      "ja",
+      "zh-CN",
+      "zh-TW"
+    ]
+  },
+  staticDirs: {
+    icons: "./src/icons",
+    public: "./src/client/public"
+  }
+};
+var DEFAULT_SERVER_BUILD_OPTIONS = {
+  srcDir: "./src/server",
+  entry: "index.ts",
+  format: "esm",
+  external: [],
+  bundled: [],
+  types: true,
+  nodeTarget: "node22"
+};
+var DEFAULT_NODE_RED_LAUNCHER_OPTIONS = {
+  runtime: {
+    port: 1880,
+    settingsFilepath: "./node-red.settings.ts",
+    version: "latest"
+  },
+  restartDelay: 1e3,
+  args: []
+};
+var DEFAULT_EXTRA_FILES_COPY_TARGETS = [
+  { src: "./LICENSE", dest: "LICENSE" },
+  { src: "./README.md", dest: "README.md" },
+  { src: "./src/examples", dest: "examples" }
+];
+
+// src/vite/utils.ts
+import fs from "fs";
+import path from "path";
+function cleanDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true });
+  }
+  fs.mkdirSync(dir, { recursive: true });
+}
+function copyFiles(targets, outDir) {
+  for (const { src, dest } of targets) {
+    const srcPath = path.resolve(src);
+    const destPath = path.join(outDir, dest);
+    if (!fs.existsSync(srcPath)) {
+      continue;
+    }
+    const stat = fs.statSync(srcPath);
+    if (stat.isDirectory()) {
+      fs.cpSync(srcPath, destPath, { recursive: true });
+    } else {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function getPackageName() {
+  const pkgPath = path.resolve("./package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    return pkg.name;
+  }
+  return "node-red-nodes";
+}
+function mergeOptions(defaults, overrides) {
+  if (!overrides) return { ...defaults };
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const overrideVal = overrides[key];
+    const defaultVal = defaults[key];
+    if (overrideVal !== void 0 && !Array.isArray(overrideVal) && !Array.isArray(defaultVal) && typeof overrideVal === "object" && typeof defaultVal === "object" && overrideVal !== null && defaultVal !== null) {
+      result[key] = mergeOptions(
+        defaultVal,
+        overrideVal
+      );
+    } else if (overrideVal !== void 0) {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function defineRuntimeSettings(settings) {
+  return settings;
+}
+
+// src/vite/node-red-launcher.ts
+import { spawn } from "child_process";
+import getPort from "get-port";
+import detect from "detect-port";
+import { builtinModules } from "module";
+import treeKill2 from "tree-kill";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { build as esbuild } from "esbuild";
+
+// src/vite/async-utils.ts
+function debounce(fn, delay) {
+  let timeout = null;
+  return (...args) => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+}
+function withTimeout(promise, ms, fallback) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      if (fallback !== void 0) {
+        resolve(fallback);
+      } else {
+        reject(new Error(`Timeout after ${ms}ms`));
+      }
+    }, ms);
+    promise.then((result) => {
+      clearTimeout(timeout);
+      resolve(result);
+    }).catch((error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+}
+async function retry(fn, options = {}) {
+  const { attempts = 3, delay = 1e3 } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (i < attempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  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 = {
+  dim: (s) => `\x1B[2m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`
+};
+var Logger = class _Logger {
+  name;
+  prefix;
+  spinner = clackLogger.spinner();
+  constructor(options) {
+    this.name = options.name;
+    this.prefix = options.prefix;
+  }
+  format(message) {
+    return this.prefix ? `[${this.prefix}] ${message}` : message;
+  }
+  intro(message) {
+    clackLogger.intro(message ?? this.name);
+  }
+  outro(message) {
+    clackLogger.outro(this.format(message));
+  }
+  step(message) {
+    clackLogger.log.step(this.format(message));
+  }
+  success(message) {
+    clackLogger.log.success(this.format(message));
+  }
+  warn(message) {
+    clackLogger.log.warn(this.format(message));
+  }
+  error(message, cause) {
+    clackLogger.log.error(this.format(message));
+    if (cause) {
+      console.error(cause);
+    }
+  }
+  info(message) {
+    clackLogger.log.info(this.format(message));
+  }
+  message(message) {
+    clackLogger.log.message(this.format(message));
+  }
+  raw(message) {
+    const prefix = this.prefix ? color.dim(`[${this.prefix}]`) : "";
+    console.log(`\u2502  ${prefix} ${message}`);
+  }
+  startGroup(title) {
+    if (title) {
+      console.log(`\u2502`);
+      console.log(`\u251C\u2500 ${color.cyan(title)}`);
+    }
+    console.log(`\u2502`);
+  }
+  endGroup(message) {
+    console.log(`\u2502`);
+    console.log(`\u2514\u2500 ${message ?? "Done"}`);
+    console.log();
+  }
+  startSpinner(message) {
+    this.spinner.start(this.format(message));
+  }
+  stopSpinner(message) {
+    this.spinner.stop(this.format(message));
+  }
+  child(prefix) {
+    const newPrefix = this.prefix ? `${this.prefix}:${prefix}` : prefix;
+    return new _Logger({ name: this.name, prefix: newPrefix });
+  }
+};
+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"
+    });
+  }
+  get preferredPort() {
+    return this.options.runtime?.port ?? 1880;
+  }
+  get restartDelay() {
+    return this.options.restartDelay ?? 1e3;
+  }
+  get pid() {
+    return this.process?.pid ?? null;
+  }
+  get nodeRedCommand() {
+    const version = this.options.runtime?.version;
+    if (version === "latest") {
+      return "node-red@latest";
+    }
+    if (version) {
+      return `node-red@${version}`;
+    }
+    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;
+    }
+    return null;
+  }
+  async compileRuntimeSettingsFile(runtimeSettingsFilepath) {
+    const compiledRuntimeSettingsFilepath = path2.join(
+      os.tmpdir(),
+      `node-red.settings.${process.pid}.cjs`
+    );
+    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(`file://${settingsFile}`)
+      },
+      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");
+    const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
+const compiledRuntimeSettings = require("${compiledRuntimeSettingsFilepath.split(path2.sep).join("/")}");
+const settings = compiledRuntimeSettings.default || compiledRuntimeSettings;
+settings.uiPort = ${this.port};
+if(!settings.userDir){
+    settings.userDir = "${userDir}";
+}
+settings.nodesDir = settings.nodesDir || [];
+if (!settings.nodesDir.includes("${outDir}")) {
+  settings.nodesDir.push("${outDir}");
+}
+if(!settings.flowFile){
+  settings.flowFile = "flows.json";
+}
+module.exports = settings;
+` : `
+const settings = {
+  uiPort: ${this.port},
+  userDir: "${userDir}",
+  flowFile: "flows.json",
+  nodesDir: ["${outDir}"],
+};
+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;
+  }
+  log(line) {
+    if (line.includes("Server now running at")) {
+      return;
+    }
+    this.logger.raw(line);
+  }
+  async start() {
+    this.port = await getPort({ port: this.preferredPort });
+    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(
+            "npx",
+            [this.nodeRedCommand, "-s", settingsPath, ...args],
+            {
+              stdio: ["ignore", "pipe", "pipe"],
+              shell: true
+            }
+          );
+          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();
+              }
+            }
+          });
+          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();
+          });
+        } catch (error) {
+          reject(new NodeRedStartError(error));
+        }
+      });
+    };
+    try {
+      await retry(startProcess, { attempts: 3, delay: 100 });
+      return this.port;
+    } catch (error) {
+      if (this.process) {
+        const pid = this.process.pid;
+        if (pid) {
+          treeKill2(pid, "SIGKILL");
+        }
+        this.process = null;
+      }
+      throw new NodeRedStartError(error);
+    }
+  }
+  async stop(skipPortUsageCheck = false) {
+    if (!this.process) return;
+    const pid = this.process.pid;
+    const currentPort = this.port;
+    if (!pid) {
+      this.process = null;
+      return;
+    }
+    const stopProcess = new Promise((resolve) => {
+      this.process.once("exit", () => {
+        this.process = null;
+        resolve();
+      });
+      treeKill2(pid, "SIGTERM", (error) => {
+        if (error) {
+          try {
+            process.kill(pid, "SIGTERM");
+          } catch {
+            this.process = null;
+            resolve();
+          }
+        }
+      });
+    });
+    try {
+      await withTimeout(stopProcess, 1e4);
+    } catch {
+      this.logger.warn("Graceful shutdown timed out, force killing...");
+      await new Promise((resolve) => {
+        treeKill2(pid, "SIGKILL", () => {
+          this.process = null;
+          resolve();
+        });
+      });
+    }
+    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: 5, delay: 100 });
+      } catch {
+        this.logger.warn(
+          `Port ${currentPort} may still be in use. If restart fails, try again in a few seconds.`
+        );
+      }
+    }
+    this.port = null;
+  }
+  flushLogs() {
+    for (const line of this.bufferedLogs) {
+      this.log(line);
+    }
+    this.bufferedLogs = [];
+  }
+  cleanup() {
+    if (this.compiledRuntimeSettingsFilepath && fs2.existsSync(this.compiledRuntimeSettingsFilepath)) {
+      fs2.unlinkSync(this.compiledRuntimeSettingsFilepath);
+      this.compiledRuntimeSettingsFilepath = null;
+    }
+  }
+};
+
+// src/vite/plugins/server.ts
+import chokidar from "chokidar";
+import path11 from "path";
+
+// src/vite/server/build.ts
+import { build as viteBuild } from "vite";
+import fs5 from "fs";
+import path5 from "path";
+
+// src/vite/server/plugins/type-generator.ts
+import dts from "vite-plugin-dts";
+import fs3 from "fs";
+import path3 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 (dirent.isDirectory()) return collectTsFiles(full);
+    if (dirent.isFile() && dirent.name.endsWith(".ts") && !dirent.name.endsWith(".d.ts"))
+      return [full];
+    return [];
+  });
+}
+function toPascalCase(name) {
+  return name.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+var BASE_CLASS_SLOTS = {
+  IONode: ["Config", "Credentials", "Input", "Output", "Settings"],
+  ConfigNode: ["Config", "Credentials", "Settings"]
+};
+function getNodeTypeExports(filePath) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    /* setParentNodes */
+    true
+  );
+  const hasModifier = (node, kind) => (node.modifiers ?? []).some((m) => m.kind === kind);
+  const exportedTypeNames = /* @__PURE__ */ new Set();
+  for (const stmt of source.statements) {
+    if (ts.isTypeAliasDeclaration(stmt) && hasModifier(stmt, ts.SyntaxKind.ExportKeyword)) {
+      exportedTypeNames.add(stmt.name.text);
+    }
+    if (ts.isInterfaceDeclaration(stmt) && hasModifier(stmt, ts.SyntaxKind.ExportKeyword)) {
+      exportedTypeNames.add(stmt.name.text);
+    }
+  }
+  if (exportedTypeNames.size === 0) return [];
+  let baseClassName = "";
+  const genericArgNames = [];
+  for (const stmt of source.statements) {
+    if (!ts.isClassDeclaration(stmt) || !hasModifier(stmt, ts.SyntaxKind.DefaultKeyword)) {
+      continue;
+    }
+    for (const clause of stmt.heritageClauses ?? []) {
+      if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+      for (const type of clause.types) {
+        if (ts.isIdentifier(type.expression)) {
+          baseClassName = type.expression.text;
+        }
+        for (const arg of type.typeArguments ?? []) {
+          if (ts.isTypeReferenceNode(arg) && ts.isIdentifier(arg.typeName)) {
+            genericArgNames.push(arg.typeName.text);
+          } else {
+            genericArgNames.push("");
+          }
+        }
+      }
+    }
+    break;
+  }
+  const slots = BASE_CLASS_SLOTS[baseClassName];
+  if (!slots) return [];
+  const result = [];
+  for (let i = 0; i < genericArgNames.length; i++) {
+    const localName = genericArgNames[i];
+    const semanticName = slots[i];
+    if (localName && semanticName && exportedTypeNames.has(localName)) {
+      result.push({ localName, semanticName });
+    }
+  }
+  return result;
+}
+function buildNodeReexports(srcDir, entryFile) {
+  const nodesDir = path3.join(srcDir, "nodes");
+  const nodeFiles = collectTsFiles(nodesDir);
+  return nodeFiles.map((file) => {
+    const rel = path3.relative(path3.dirname(entryFile), file).replace(/\\/g, "/");
+    const relPath = rel.startsWith(".") ? rel : `./${rel}`;
+    const specifier = relPath.replace(/\.ts$/, "");
+    const ns = toPascalCase(path3.basename(file, ".ts"));
+    const lines = [`export { default as ${ns} } from "${specifier}";`];
+    const typePairs = getNodeTypeExports(file);
+    if (typePairs.length > 0) {
+      const prefixed = typePairs.map(
+        ({ localName, semanticName }) => `${localName} as ${ns}${semanticName}`
+      ).join(", ");
+      lines.push(`export type { ${prefixed} } from "${specifier}";`);
+    }
+    return lines.join("\n");
+  }).join("\n");
+}
+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(
+    process.cwd(),
+    path3.join(path3.dirname(srcDir), "client")
+  );
+  const augmentedContents = /* @__PURE__ */ new Map();
+  let origReadFile = null;
+  const nodeTypeExporter = {
+    name: "vite-plugin-node-red:server:type-exporter",
+    enforce: "pre",
+    buildStart() {
+      augmentedContents.clear();
+      for (const entryFile of entryFiles) {
+        const reexports = buildNodeReexports(srcDir, entryFile);
+        if (!reexports) continue;
+        const original = fs3.readFileSync(entryFile, "utf-8");
+        augmentedContents.set(
+          path3.resolve(entryFile),
+          `${original}
+${reexports}
+`
+        );
+      }
+      if (augmentedContents.size === 0) return;
+      origReadFile = ts.sys.readFile.bind(ts.sys);
+      ts.sys.readFile = (fileName, encoding) => {
+        const resolved = path3.resolve(fileName);
+        return augmentedContents.get(resolved) ?? origReadFile(fileName, encoding);
+      };
+    },
+    closeBundle() {
+      if (origReadFile) {
+        ts.sys.readFile = origReadFile;
+        origReadFile = null;
+      }
+      augmentedContents.clear();
+    }
+  };
+  return [
+    nodeTypeExporter,
+    dts({
+      rollupTypes: true,
+      rollupOptions: {
+        messageCallback(message) {
+          if (message.messageId === "console-preamble") {
+            message.logLevel = "none";
+          }
+        }
+      },
+      outDir,
+      ...fs3.existsSync(userTsconfig) && { tsconfigPath: userTsconfig },
+      compilerOptions: {
+        noEmit: false,
+        declaration: true,
+        emitDeclarationOnly: true,
+        noCheck: true
+      },
+      exclude: [
+        `${clientDir}/**`,
+        "**/client/**",
+        "vite/**",
+        "node_modules/**",
+        "dist/**"
+      ]
+    })
+  ].flat();
+}
+
+// src/vite/server/plugins/output-wrapper.ts
+function cjsWrapper() {
+  return {
+    name: "vite-plugin-node-red:server:cjs-wrapper",
+    renderChunk(code, chunk, outputOptions) {
+      if (!chunk.isEntry || outputOptions.format !== "cjs") return null;
+      const footer = `(function(){var _exp=module.exports&&module.exports.__esModule?module.exports.default:module.exports;if(_exp&&typeof _exp==="object"&&Array.isArray(_exp.nodes)){var _nrg=require("@bonsae/nrg/server");module.exports=_nrg.registerTypes(_exp.nodes);}else if(typeof _exp==="function"&&Array.isArray(_exp.nodes)){module.exports=_exp;_exp.nodes.forEach(function(cls){if(cls&&cls.type){_exp[cls.type.replace(/(?:^|[-_])(\\w)/g,function(_,c){return c.toUpperCase();})] = cls;}});}})();`;
+      return { code: `${code}
+${footer}`, map: null };
+    }
+  };
+}
+function esmWrapper() {
+  return {
+    name: "vite-plugin-node-red:server:esm-wrapper",
+    renderChunk(code, chunk, outputOptions) {
+      if (!chunk.isEntry || outputOptions.format !== "es") return null;
+      const reNamed = /export\s*\{\s*(\w+)\s+as\s+default\s*\}\s*;?/;
+      const reDefault = /export\s+default\s+(\w+)\s*;?/;
+      let match = code.match(reNamed);
+      let varName;
+      let matchStr;
+      if (match) {
+        varName = match[1];
+        matchStr = match[0];
+      } else {
+        match = code.match(reDefault);
+        if (match) {
+          varName = match[1];
+          matchStr = match[0];
+        }
+      }
+      if (!varName || !matchStr) return null;
+      const header = [
+        `import { fileURLToPath as __nrgFileURLToPath } from "url";`,
+        `import { dirname as __nrgDirname } from "path";`,
+        `var __filename = __nrgFileURLToPath(import.meta.url);`,
+        `var __dirname = __nrgDirname(__filename);`,
+        `import { registerTypes as __nrgRegisterTypes } from "@bonsae/nrg/server";`,
+        ``
+      ].join("\n");
+      const replacement = [
+        `var __nrgExport = ${varName};`,
+        `if (__nrgExport && typeof __nrgExport === "object" && Array.isArray(__nrgExport.nodes)) {`,
+        `  __nrgExport = __nrgRegisterTypes(__nrgExport.nodes);`,
+        `}`,
+        `export { __nrgExport as default };`
+      ].join("\n");
+      const newCode = header + code.replace(matchStr, replacement);
+      return { code: newCode, map: null };
+    }
+  };
+}
+
+// src/vite/server/plugins/package-json-generator.ts
+import fs4 from "fs";
+import path4 from "path";
+import { builtinModules as builtinModules2 } from "node:module";
+var nodeBuiltins = /* @__PURE__ */ new Set([
+  ...builtinModules2,
+  ...builtinModules2.map((m) => `node:${m}`)
+]);
+function buildTypesPath(entryName) {
+  return `./${entryName}.d.ts`;
+}
+function buildOutputPath(entryName) {
+  return `./${entryName}.js`;
+}
+function buildExportKey(entryName) {
+  return entryName === "index" ? "." : `./${entryName}`;
+}
+function buildEsmOutputPath(entryName) {
+  return `./${entryName}.mjs`;
+}
+function generateExports(entryNames, format = "cjs") {
+  const exports = {};
+  for (const name of entryNames) {
+    const key = buildExportKey(name);
+    if (format === "esm") {
+      exports[key] = {
+        types: buildTypesPath(name),
+        import: buildEsmOutputPath(name),
+        require: buildOutputPath(name),
+        default: buildOutputPath(name)
+      };
+    } else {
+      exports[key] = {
+        types: buildTypesPath(name),
+        require: buildOutputPath(name),
+        default: buildOutputPath(name)
+      };
+    }
+  }
+  return exports;
+}
+function patchExportsWithTypes(existingExports, entryNames) {
+  const patched = { ...existingExports };
+  for (const [key, value] of Object.entries(patched)) {
+    const entryName = key === "." ? "index" : key.replace(/^\.\//, "");
+    if (!entryNames.includes(entryName)) continue;
+    const typesPath = buildTypesPath(entryName);
+    if (typeof value === "string") {
+      patched[key] = { types: typesPath, require: value, default: value };
+    } else if (typeof value === "object" && value !== null) {
+      const condition = value;
+      if (!condition.types) {
+        patched[key] = { types: typesPath, ...condition };
+      }
+    }
+  }
+  return patched;
+}
+function packageJsonGenerator(options) {
+  const {
+    outDir,
+    bundled = [],
+    types = false,
+    entryNames = [],
+    format = "cjs"
+  } = options;
+  const trackedDependencies = /* @__PURE__ */ new Set();
+  return {
+    name: "vite-plugin-node-red:server:package-json-generator",
+    enforce: "pre",
+    buildStart() {
+      trackedDependencies.clear();
+    },
+    resolveId: {
+      order: "pre",
+      handler(source, importer) {
+        if (!importer || source.startsWith(".") || source.startsWith("/")) {
+          return null;
+        }
+        if (nodeBuiltins.has(source)) {
+          return { id: source, external: true };
+        }
+        const packageName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+        if (bundled.includes(packageName)) {
+          return null;
+        }
+        trackedDependencies.add(packageName);
+        return { id: source, external: true };
+      }
+    },
+    closeBundle() {
+      const rootPackageJsonPath = path4.resolve("./package.json");
+      if (!fs4.existsSync(rootPackageJsonPath)) {
+        logger.warn(`package.json not found: ${rootPackageJsonPath}`);
+        return;
+      }
+      const rootPackageJson = JSON.parse(
+        fs4.readFileSync(rootPackageJsonPath, "utf-8")
+      );
+      const sourceDeps = rootPackageJson.dependencies ?? {};
+      const peerDeps = rootPackageJson.peerDependencies ?? {};
+      let distDependencies = {};
+      for (const dep of trackedDependencies) {
+        if (peerDeps[dep]) {
+          continue;
+        }
+        if (sourceDeps[dep]) {
+          distDependencies[dep] = sourceDeps[dep];
+        } else {
+          const dependencyPackageJsonPath = path4.resolve(
+            `./node_modules/${dep}/package.json`
+          );
+          if (fs4.existsSync(dependencyPackageJsonPath)) {
+            const dependencyPackageJson = JSON.parse(
+              fs4.readFileSync(dependencyPackageJsonPath, "utf-8")
+            );
+            distDependencies[dep] = `^${dependencyPackageJson.version}`;
+          }
+        }
+      }
+      if (Object.keys(distDependencies).length === 0) {
+        distDependencies = void 0;
+      }
+      const distPackageJson = {
+        ...rootPackageJson,
+        main: "index.js",
+        type: "commonjs",
+        devDependencies: void 0,
+        scripts: void 0,
+        dependencies: distDependencies,
+        keywords: [
+          .../* @__PURE__ */ new Set([...rootPackageJson.keywords ?? [], "node-red"])
+        ],
+        "node-red": {
+          nodes: { nodes: "index.js" }
+        }
+      };
+      if (types && entryNames.length > 0) {
+        const userExports = rootPackageJson.exports;
+        if (userExports && Object.keys(userExports).length > 0) {
+          distPackageJson.exports = patchExportsWithTypes(
+            userExports,
+            entryNames
+          );
+        } else {
+          distPackageJson.exports = generateExports(entryNames, format);
+          if (entryNames.includes("index")) {
+            distPackageJson.types = "index.d.ts";
+          }
+        }
+      }
+      if (!fs4.existsSync(outDir)) {
+        fs4.mkdirSync(outDir, { recursive: true });
+      }
+      fs4.writeFileSync(
+        path4.join(outDir, "package.json"),
+        JSON.stringify(distPackageJson, null, 2)
+      );
+    }
+  };
+}
+
+// src/vite/server/build.ts
+async function build(serverOpts, buildContext) {
+  const {
+    srcDir = "./server",
+    entry = "index.ts",
+    format = "esm",
+    bundled = [],
+    types = true,
+    nodeTarget = "node22",
+    plugins: userPlugins = []
+  } = serverOpts;
+  const entries = Array.isArray(entry) ? entry : [entry];
+  const resolvedSrcDir = path5.resolve(srcDir);
+  const entryPoints = {};
+  for (const entry2 of entries) {
+    const entryFilePath = path5.join(resolvedSrcDir, entry2);
+    if (fs5.existsSync(entryFilePath)) {
+      const fileName = entry2.replace(/\.ts$/, "");
+      entryPoints[fileName] = entryFilePath;
+    }
+  }
+  if (Object.keys(entryPoints).length === 0) {
+    logger.warn("No server entry points found");
+    return;
+  }
+  const isEsm = format === "esm";
+  const plugins = [
+    packageJsonGenerator({
+      outDir: buildContext.outDir,
+      bundled,
+      types: types && !buildContext.isDev,
+      entryNames: Object.keys(entryPoints),
+      format
+    }),
+    isEsm ? esmWrapper() : cjsWrapper(),
+    ...userPlugins
+  ];
+  if (types && !buildContext.isDev) {
+    plugins.push(
+      ...typeGenerator({
+        srcDir: resolvedSrcDir,
+        outDir: buildContext.outDir,
+        entryFiles: Object.values(entryPoints)
+      })
+    );
+  }
+  const config = {
+    configFile: false,
+    logLevel: "warn",
+    plugins,
+    build: {
+      outDir: buildContext.outDir,
+      emptyOutDir: false,
+      sourcemap: buildContext.isDev ? "inline" : true,
+      minify: !buildContext.isDev,
+      lib: {
+        entry: entryPoints,
+        formats: [isEsm ? "es" : "cjs"]
+      },
+      rollupOptions: {
+        output: {
+          entryFileNames: isEsm ? "[name].mjs" : "[name].js",
+          exports: isEsm ? void 0 : "auto",
+          preserveModules: false
+        }
+      }
+    },
+    esbuild: {
+      platform: "node",
+      target: nodeTarget,
+      keepNames: true
+    }
+  };
+  try {
+    await viteBuild(config);
+    if (isEsm) {
+      const bridgeCode = `'use strict';
+// CJS bridge \u2014 auto-generated by @bonsae/nrg/vite
+// Node-RED uses require() to load packages. This bridge delegates to the ESM bundle.
+module.exports = function (RED) {
+    (async () => {
+        const mod = await import("./index.mjs");
+        if (typeof mod.default !== 'function') {
+            throw new Error('ESM bundle must export a default function(RED)');
+        }
+        await mod.default(RED);
+    })().catch(function (err) {
+        RED.log.error('Failed to load ESM bundle: ' + err.message);
+    });
+};
+`;
+      fs5.writeFileSync(path5.join(buildContext.outDir, "index.js"), bridgeCode);
+    }
+  } catch (error) {
+    throw new BuildError("server", error);
+  }
+}
+
+// src/vite/client/build.ts
+import { build as viteBuild2 } from "vite";
+import vue from "@vitejs/plugin-vue";
+import fs10 from "fs";
+import path10 from "path";
+
+// src/vite/client/plugins/html-generator.ts
+import mime from "mime-types";
+import fs6 from "fs";
+import path6 from "path";
+function htmlGenerator(options) {
+  const { packageName, licensePath } = options;
+  return {
+    name: "vite-plugin-node-red:client:html-generator",
+    apply: "build",
+    enforce: "post",
+    generateBundle(_, bundle) {
+      const resourcesTags = Object.keys(bundle).map((fileName) => {
+        const asset = bundle[fileName];
+        const srcPath = path6.join(
+          "resources",
+          packageName,
+          fileName.replace(/^resources\/?/, "")
+        );
+        const content = asset.type === "asset" ? asset.source : asset.type === "chunk" ? asset.code : null;
+        if (typeof content !== "string" && !(content instanceof Uint8Array))
+          return null;
+        const mimeType = mime.lookup(fileName);
+        switch (mimeType) {
+          case "application/javascript":
+          case "text/javascript":
+            return `<script type="module" src="${srcPath}" defer></script>`;
+          case "text/css":
+            return `<link rel="stylesheet" href="${srcPath}">`;
+          case "font/woff":
+          case "font/woff2":
+          case "application/font-woff":
+          case "application/font-woff2":
+          case "application/x-font-ttf":
+          case "application/x-font-opentype":
+          case "font/ttf":
+          case "font/otf":
+            return `<link rel="preload" as="font" href="${srcPath}" type="${mimeType}">`;
+          default:
+            return null;
+        }
+      }).filter(Boolean).join("\n");
+      const licenseBanner = licensePath && fs6.existsSync(licensePath) ? `<!--
+${fs6.readFileSync(licensePath, "utf-8")}
+-->` : "";
+      this.emitFile({
+        type: "asset",
+        fileName: "index.html",
+        source: `${licenseBanner}
+${resourcesTags}`
+      });
+    }
+  };
+}
+
+// src/vite/client/plugins/locales-generator.ts
+import fs7 from "fs";
+import path7 from "path";
+function localesGenerator(options) {
+  const { outDir, docsDir, labelsDir, languages } = options;
+  return {
+    name: "vite-plugin-node-red:client:locales-generator",
+    apply: "build",
+    enforce: "post",
+    closeBundle() {
+      function validateLanguage(lang, filePath) {
+        if (!languages.includes(lang)) {
+          throw new Error(
+            `[locales] Invalid language "${lang}" in "${filePath}".
+Supported: ${languages.join(", ")}`
+          );
+        }
+      }
+      function forEachFile(baseDir, fileExtensions, processFile) {
+        const langMap = /* @__PURE__ */ new Map();
+        if (!fs7.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs7.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const nodeDir of nodeDirs) {
+          const nodeType = nodeDir.name;
+          const nodePath = path7.join(baseDir, nodeType);
+          const files = fs7.readdirSync(nodePath);
+          for (const file of files) {
+            const ext = path7.extname(file);
+            if (!fileExtensions.includes(ext)) continue;
+            const lang = path7.basename(file, ext);
+            const filePath = path7.join(nodePath, file);
+            validateLanguage(lang, filePath);
+            const value = processFile({ ext, filePath, nodeType });
+            if (value == null) continue;
+            if (!langMap.has(lang)) {
+              langMap.set(lang, Array.isArray(value) ? [] : {});
+            }
+            if (Array.isArray(value)) {
+              langMap.get(lang).push(...value);
+            } else {
+              langMap.get(lang)[nodeType] = value;
+            }
+          }
+        }
+        return langMap;
+      }
+      function writeOutput(langMap, fileName, serialize) {
+        for (const [lang, data] of langMap.entries()) {
+          const langOutDir = path7.join(outDir, lang);
+          fs7.mkdirSync(langOutDir, { recursive: true });
+          fs7.writeFileSync(
+            path7.join(langOutDir, fileName),
+            serialize(data),
+            "utf-8"
+          );
+        }
+      }
+      const docLangs = forEachFile(
+        docsDir,
+        [".html", ".md"],
+        ({ ext, filePath, nodeType }) => {
+          const type = ext === ".html" ? "text/html" : ext === ".md" ? "text/markdown" : null;
+          if (!type) return null;
+          const content = fs7.readFileSync(filePath, "utf-8");
+          return [
+            `<script type="${type}" data-help-name="${nodeType}">
+${content}
+</script>`
+          ];
+        }
+      );
+      writeOutput(
+        docLangs,
+        "index.html",
+        (value) => value.join("\n")
+      );
+      const labelLangs = forEachFile(
+        labelsDir,
+        [".json"],
+        ({ filePath }) => JSON.parse(fs7.readFileSync(filePath, "utf-8"))
+      );
+      writeOutput(
+        labelLangs,
+        "index.json",
+        (value) => JSON.stringify(value, null, 2)
+      );
+    }
+  };
+}
+
+// src/vite/client/plugins/minifier.ts
+import { transform } from "esbuild";
+function minifier() {
+  return {
+    name: "vite-plugin-node-red:client:minifier",
+    apply: "build",
+    renderChunk: {
+      order: "post",
+      async handler(code, chunk, outputOptions) {
+        if (outputOptions.format === "es" && chunk.fileName.endsWith(".js")) {
+          const result = await transform(code, { minify: true });
+          return result.code;
+        }
+        return code;
+      }
+    }
+  };
+}
+
+// src/vite/client/plugins/node-definitions-inliner.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import path8 from "path";
+import fs8 from "fs";
+import mime2 from "mime-types";
+var VIRTUAL_ID = "virtual:nrg/node-definitions";
+var RESOLVED_ID = "\0" + VIRTUAL_ID;
+var VIRTUAL_ENTRY_ID = "virtual:nrg/client-entry";
+var RESOLVED_ENTRY_ID = "\0" + VIRTUAL_ENTRY_ID;
+var SKIP_DEFAULTS = /* @__PURE__ */ new Set(["x", "y", "z", "g", "wires", "type", "id"]);
+function getDefaultsFromSchema(schema) {
+  if (!schema?.properties) return void 0;
+  const result = {};
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (SKIP_DEFAULTS.has(key)) continue;
+    result[key] = {
+      required: false,
+      value: prop.default ?? void 0,
+      type: prop["node-type"]
+    };
+  }
+  return result;
+}
+function getCredentialsFromSchema(schema) {
+  if (!schema?.properties) return void 0;
+  const result = {};
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    result[key] = {
+      required: false,
+      type: prop.format === "password" ? "password" : "text",
+      value: prop.default ?? void 0
+    };
+  }
+  return result;
+}
+function resolveIcon(iconsDir, type) {
+  if (!fs8.existsSync(iconsDir)) return void 0;
+  return fs8.readdirSync(iconsDir).find((f) => {
+    if (path8.basename(f, path8.extname(f)) !== type) return false;
+    const mimeType = mime2.lookup(f);
+    return mimeType !== false && mimeType.startsWith("image/");
+  });
+}
+function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true) {
+  let _nodeTypes = [];
+  let _definitions = {};
+  return {
+    name: "vite-plugin-node-red:client:node-definitions-inliner",
+    enforce: "pre",
+    // Load the server bundle in buildStart so _nodeTypes is populated
+    // before any load/transform hooks run.
+    async buildStart() {
+      _nodeTypes = [];
+      _definitions = {};
+      const esmEntryPath = path8.resolve(serverOutDir, "index.mjs");
+      const cjsEntryPath = path8.resolve(serverOutDir, "index.js");
+      let packageFn;
+      if (fs8.existsSync(esmEntryPath)) {
+        const fileUrl = pathToFileURL(esmEntryPath).href + `?t=${Date.now()}`;
+        const mod = await import(fileUrl);
+        packageFn = mod?.default ?? mod;
+      } else if (fs8.existsSync(cjsEntryPath)) {
+        const require2 = createRequire(import.meta.url);
+        delete require2.cache[cjsEntryPath];
+        const rawMod = require2(cjsEntryPath);
+        packageFn = rawMod?.default ?? rawMod;
+      }
+      const nodeClasses = packageFn?.nodes ?? [];
+      for (const NodeClass of nodeClasses) {
+        const type = NodeClass.type;
+        if (!type) continue;
+        _nodeTypes.push(type);
+        const configSchema = NodeClass.configSchema ?? null;
+        const credentialsSchema = NodeClass.credentialsSchema ?? null;
+        const inputSchema = NodeClass.inputSchema ?? null;
+        const outputsSchema = NodeClass.outputsSchema ?? null;
+        const defaults = getDefaultsFromSchema(configSchema);
+        if (defaults && inputSchema) {
+          defaults.validateInput = { required: false, value: false };
+        }
+        if (defaults && outputsSchema) {
+          defaults.validateOutput = { required: false, value: false };
+        }
+        const credentials = getCredentialsFromSchema(credentialsSchema);
+        _definitions[type] = {
+          type,
+          category: NodeClass.category,
+          configSchema,
+          credentialsSchema,
+          settingsSchema: NodeClass.settingsSchema ?? null,
+          defaults: defaults ?? void 0,
+          credentials: credentials ?? void 0,
+          align: NodeClass.align,
+          color: NodeClass.color,
+          icon: iconsDir ? resolveIcon(iconsDir, type) : void 0,
+          labelStyle: NodeClass.labelStyle,
+          paletteLabel: NodeClass.paletteLabel,
+          inputs: NodeClass.inputs,
+          outputs: NodeClass.outputs,
+          inputLabels: NodeClass.inputLabels,
+          outputLabels: NodeClass.outputLabels,
+          inputSchema,
+          outputsSchema
+        };
+      }
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return RESOLVED_ID;
+      if (id === VIRTUAL_ENTRY_ID) return RESOLVED_ENTRY_ID;
+    },
+    load(id) {
+      if (id === RESOLVED_ENTRY_ID) return "";
+      if (id !== RESOLVED_ID) return;
+      return `export default ${JSON.stringify(_definitions)};`;
+    },
+    transform(code, id) {
+      if (id !== entryPath && id !== RESOLVED_ENTRY_ID) return;
+      const nrgImports = /* @__PURE__ */ new Set(["__setSchemas"]);
+      const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
+      const postLines = [`__setSchemas(__nrgSchemas);`];
+      if (componentsDir && fs8.existsSync(componentsDir)) {
+        const formImports = [];
+        const formEntries = [];
+        for (const type of _nodeTypes) {
+          const componentPath = path8.resolve(componentsDir, `${type}.vue`);
+          if (fs8.existsSync(componentPath)) {
+            const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
+            formImports.push(
+              `import ${varName} from ${JSON.stringify(componentPath)};`
+            );
+            formEntries.push(`${JSON.stringify(type)}: ${varName}`);
+          }
+        }
+        if (formImports.length > 0) {
+          lines.push(...formImports);
+          nrgImports.add("__setForms");
+          postLines.push(`__setForms({ ${formEntries.join(", ")} });`);
+        }
+      }
+      if (!hasUserEntry) {
+        const defVarNames = [];
+        for (const type of _nodeTypes) {
+          const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
+          const tsPath = nodesDir ? path8.resolve(nodesDir, `${type}.ts`) : null;
+          if (tsPath && fs8.existsSync(tsPath)) {
+            lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
+          } else {
+            lines.push(`const ${varName} = { type: ${JSON.stringify(type)} };`);
+          }
+          defVarNames.push(varName);
+        }
+        if (defVarNames.length > 0) {
+          nrgImports.add("registerTypes");
+          postLines.push(`registerTypes([${defVarNames.join(", ")}]);`);
+        }
+      }
+      const importLine = `import { ${[...nrgImports].join(", ")} } from "@bonsae/nrg/client";`;
+      lines.splice(1, 0, importLine);
+      lines.push(...postLines);
+      lines.push("");
+      return { code: lines.join("\n") + code, map: null };
+    }
+  };
+}
+
+// src/vite/client/plugins/static-copy.ts
+import fs9 from "fs";
+import path9 from "path";
+function staticCopy(options) {
+  const { targets } = options;
+  return {
+    name: "vite-plugin-node-red:client:static-copy",
+    apply: "build",
+    enforce: "post",
+    closeBundle() {
+      for (const { src, dest } of targets) {
+        if (!fs9.existsSync(src)) continue;
+        fs9.mkdirSync(dest, { recursive: true });
+        const stat = fs9.statSync(src);
+        if (stat.isDirectory()) {
+          const files = fs9.readdirSync(src);
+          for (const file of files) {
+            const srcFile = path9.join(src, file);
+            const destFile = path9.join(dest, file);
+            const fileStat = fs9.statSync(srcFile);
+            if (fileStat.isDirectory()) {
+              fs9.cpSync(srcFile, destFile, { recursive: true });
+            } else {
+              fs9.copyFileSync(srcFile, destFile);
+            }
+          }
+        } else {
+          fs9.copyFileSync(src, dest);
+        }
+      }
+    }
+  };
+}
+
+// src/vite/client/build.ts
+async function build2(clientBuildOptions, buildContext) {
+  const {
+    srcDir = "./client",
+    entry = "index.ts",
+    name = "NodeRedNodes",
+    format = "es",
+    licensePath = "./LICENSE",
+    locales,
+    staticDirs = {},
+    external = ["jquery", "node-red", "vue"],
+    globals = { jquery: "$", "node-red": "RED", vue: "Vue" },
+    manualChunks,
+    plugins: userPlugins = []
+  } = clientBuildOptions;
+  const physicalEntryPath = path10.resolve(srcDir, entry);
+  let entryPath;
+  let generatedEntry = false;
+  if (fs10.existsSync(physicalEntryPath)) {
+    entryPath = physicalEntryPath;
+  } else {
+    if (!fs10.existsSync(path10.dirname(physicalEntryPath))) {
+      fs10.mkdirSync(path10.dirname(physicalEntryPath), { recursive: true });
+    }
+    fs10.writeFileSync(physicalEntryPath, "// auto-generated entry\n");
+    entryPath = physicalEntryPath;
+    generatedEntry = true;
+  }
+  const iconsDir = path10.resolve(
+    staticDirs.icons ?? path10.join(path10.dirname(path10.resolve(srcDir)), "icons")
+  );
+  const plugins = [
+    vue(),
+    nodeDefinitionsInliner(
+      buildContext.outDir,
+      entryPath,
+      fs10.existsSync(iconsDir) ? iconsDir : void 0,
+      path10.resolve(srcDir, "components"),
+      path10.resolve(srcDir, "nodes"),
+      !generatedEntry
+    ),
+    ...userPlugins
+  ];
+  plugins.push(
+    htmlGenerator({
+      packageName: buildContext.packageName,
+      licensePath: licensePath ? path10.resolve(licensePath) : void 0
+    })
+  );
+  if (locales) {
+    const {
+      docsDir = "./locales/docs",
+      labelsDir = "./locales/labels",
+      languages = [
+        "en-US",
+        "de",
+        "es-ES",
+        "fr",
+        "ko",
+        "pt-BR",
+        "ru",
+        "ja",
+        "zh-CN",
+        "zh-TW"
+      ]
+    } = locales;
+    plugins.push(
+      localesGenerator({
+        outDir: path10.join(buildContext.outDir, "locales"),
+        docsDir: path10.resolve(docsDir),
+        labelsDir: path10.resolve(labelsDir),
+        languages
+      })
+    );
+  }
+  const copyTargets = [];
+  const publicDir = path10.resolve(
+    staticDirs.public ?? path10.join(srcDir, "public")
+  );
+  if (fs10.existsSync(publicDir)) {
+    copyTargets.push({
+      src: publicDir,
+      dest: path10.join(buildContext.outDir, "resources")
+    });
+  }
+  if (fs10.existsSync(iconsDir)) {
+    copyTargets.push({
+      src: iconsDir,
+      dest: path10.join(buildContext.outDir, "icons")
+    });
+  }
+  if (copyTargets.length > 0) {
+    plugins.push(staticCopy({ targets: copyTargets }));
+  }
+  if (!buildContext.isDev && format === "es") {
+    plugins.push(minifier());
+  }
+  plugins.unshift({
+    name: "nrg-client-external",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "@bonsae/nrg/client")
+        return { id: "@bonsae/nrg/client", external: true };
+    }
+  });
+  const defaultManualChunks = (id) => {
+    if (!id.includes("node_modules")) return void 0;
+    const parts = id.substring(id.lastIndexOf("node_modules/") + "node_modules/".length).split("/");
+    const pkgName = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+    if (["jsonpointer", "es-toolkit"].includes(pkgName)) return "vendor-utils";
+    return "vendor";
+  };
+  const config = {
+    configFile: false,
+    logLevel: "warn",
+    base: `/${path10.join("resources", buildContext.packageName)}`,
+    publicDir: path10.resolve(srcDir, "public"),
+    resolve: {
+      alias: {
+        "@": path10.resolve(srcDir)
+      }
+    },
+    plugins,
+    css: {
+      devSourcemap: buildContext.isDev
+    },
+    build: {
+      outDir: buildContext.outDir,
+      emptyOutDir: false,
+      sourcemap: buildContext.isDev ? "inline" : true,
+      minify: !buildContext.isDev && format !== "es",
+      copyPublicDir: false,
+      lib: {
+        entry: entryPath,
+        name,
+        fileName: "index",
+        formats: [format]
+      },
+      rollupOptions: {
+        external,
+        treeshake: false,
+        output: {
+          entryFileNames: path10.join("resources", "index.[hash].js"),
+          chunkFileNames: path10.join("resources", "vendor.[hash].js"),
+          assetFileNames: path10.join("resources", "[name].[hash].[ext]"),
+          globals,
+          paths: {
+            vue: "/nrg/assets/vue.esm-browser.prod.js",
+            "@bonsae/nrg/client": "/nrg/assets/nrg-client.js"
+          },
+          sourcemapPathTransform: (relativeSourcePath) => {
+            return relativeSourcePath.replace(/\/client\//g, "/");
+          },
+          manualChunks: manualChunks ?? defaultManualChunks
+        }
+      }
+    },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(
+        buildContext.isDev ? "development" : "production"
+      ),
+      "process.env": {}
+    }
+  };
+  try {
+    await viteBuild2(config);
+  } catch (error) {
+    throw new BuildError("client", error);
+  } finally {
+    if (generatedEntry) {
+      fs10.unlinkSync(physicalEntryPath);
+    }
+  }
+}
+
+// src/vite/plugins/server.ts
+var color2 = {
+  dim: (s) => `\x1B[2m${s}\x1B[0m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`
+};
+function serverPlugin(options) {
+  const {
+    nodeRedLauncher,
+    serverBuildOptions,
+    clientBuildOptions,
+    extraFilesCopyTargets,
+    buildContext
+  } = options;
+  let nodeRedPort;
+  let initialStartDone = false;
+  let isStarting = false;
+  let isShuttingDown = false;
+  let shutdownStartTime = 0;
+  let pendingStart = false;
+  let server;
+  let watcher = null;
+  const build3 = async (clean = false) => {
+    if (clean) {
+      logger.startSpinner("Cleaning");
+      cleanDir(buildContext.outDir);
+      logger.stopSpinner("Cleaned");
+    }
+    logger.startSpinner("Building");
+    await build(serverBuildOptions, buildContext);
+    await build2(clientBuildOptions, buildContext);
+    logger.stopSpinner("Built");
+    if (extraFilesCopyTargets.length) {
+      logger.startSpinner("Copying extra files");
+      copyFiles(extraFilesCopyTargets, buildContext.outDir);
+      logger.stopSpinner("Copied extra files");
+    }
+  };
+  const start = async (clean = false) => {
+    if (isStarting) {
+      pendingStart = true;
+      return;
+    }
+    isStarting = true;
+    pendingStart = false;
+    try {
+      await nodeRedLauncher.stop();
+      await build3(clean);
+      logger.startSpinner("Starting Node-RED");
+      nodeRedPort = await nodeRedLauncher.start();
+      logger.stopSpinner("Node-RED started");
+      const proxyConfig = server.config.server.proxy;
+      if (proxyConfig && typeof proxyConfig === "object") {
+        const rule = proxyConfig["^/.*"];
+        if (rule && typeof rule === "object") {
+          rule.target = `http://127.0.0.1:${nodeRedPort}`;
+        }
+      }
+      logger.success("Ready");
+    } catch (error) {
+      if (error instanceof BuildError) {
+        logger.error(`Rebuild failed: ${error.message}`);
+      } else if (error instanceof NodeRedStartError) {
+        logger.error("Failed to restart Node-RED");
+      } else {
+        logger.error(`Unexpected error: ${error.message}`);
+      }
+      throw error;
+    } finally {
+      isStarting = false;
+      if (pendingStart) {
+        start(false);
+      }
+    }
+  };
+  const printServerUrls = (vitePort, nodeRedPorts) => {
+    console.log();
+    console.log(
+      `  ${color2.cyan("Vite")}      ${color2.dim("\u279C")}  ${color2.cyan(`http://127.0.0.1:${vitePort}/`)}`
+    );
+    if (nodeRedPorts.actual != nodeRedPorts.preferred) {
+      console.log(
+        `  ${color2.green("Node-RED")}  ${color2.dim("\u279C")}  ${color2.green(`http://127.0.0.1:${nodeRedPorts.actual}/`)} ${color2.yellow(`(port ${nodeRedPorts.preferred} was in use)`)}`
+      );
+    } else {
+      console.log(
+        `  ${color2.green("Node-RED")}  ${color2.dim("\u279C")}  ${color2.green(`http://127.0.0.1:${nodeRedPorts.actual}/`)}`
+      );
+    }
+    console.log();
+  };
+  return {
+    name: "vite-plugin-node-red:server",
+    apply: "serve",
+    config() {
+      return {
+        appType: "custom",
+        server: {
+          host: "127.0.0.1",
+          proxy: {
+            "^/.*": {
+              target: `http://127.0.0.1:${nodeRedLauncher.preferredPort}`,
+              changeOrigin: true,
+              ws: true,
+              configure: (proxy) => {
+                proxy.on("error", () => {
+                  if (nodeRedPort) {
+                    proxy.options.target = `http://127.0.0.1:${nodeRedPort}`;
+                  }
+                });
+              }
+            }
+          },
+          watch: {
+            // NOTE: this is necessary to avoid default hmr in .html files. Watcher is configured manually
+            ignored: ["**/*"]
+          }
+        },
+        customLogger: {
+          ...console,
+          info: () => {
+          },
+          warn: console.warn,
+          error: console.error,
+          warnOnce: () => {
+          },
+          hasWarned: false,
+          clearScreen: () => {
+          },
+          hasErrorLogged: () => false
+        }
+      };
+    },
+    async configureServer(viteServer) {
+      server = viteServer;
+      logger.intro();
+      await start(true);
+      initialStartDone = true;
+      printServerUrls(server.config.server.port ?? 5173, {
+        actual: nodeRedPort,
+        preferred: nodeRedLauncher.preferredPort
+      });
+      logger.startGroup("Node-RED");
+      nodeRedLauncher.flushLogs();
+      const serverSrcDir = path11.resolve(
+        serverBuildOptions.srcDir ?? "./server"
+      );
+      const clientSrcDir = path11.resolve(
+        clientBuildOptions.srcDir ?? "./client"
+      );
+      const localesDocsDir = path11.resolve(
+        clientBuildOptions.locales?.docsDir ?? "./locales/docs"
+      );
+      const localesLabelsDir = path11.resolve(
+        clientBuildOptions.locales?.labelsDir ?? "./locales/labels"
+      );
+      const iconsDir = path11.resolve(
+        clientBuildOptions.staticDirs?.icons ?? path11.join(path11.dirname(clientSrcDir), "icons")
+      );
+      const watchPaths = [
+        serverSrcDir,
+        clientSrcDir,
+        localesDocsDir,
+        localesLabelsDir,
+        iconsDir
+      ];
+      watcher = chokidar.watch(watchPaths, {
+        ignoreInitial: true,
+        persistent: true,
+        ignored: ["**/node_modules/**", "**/dist/**", "**/.node-red/**"]
+      });
+      const debounceBeforeStart = debounce(
+        () => start(false),
+        nodeRedLauncher.restartDelay ?? 1e3
+      );
+      const handleFileChange = (file, event) => {
+        if (!initialStartDone) return;
+        logger.info(`${event}: ${path11.relative(process.cwd(), file)}`);
+        debounceBeforeStart();
+      };
+      watcher.on("change", (file) => handleFileChange(file, "Changed"));
+      watcher.on("add", (file) => handleFileChange(file, "Added"));
+      watcher.on("unlink", (file) => handleFileChange(file, "Deleted"));
+      process.on("SIGINT", () => {
+        const now = Date.now();
+        if (isShuttingDown && now - shutdownStartTime > 1e3) {
+          const pid = nodeRedLauncher.pid;
+          if (pid) {
+            try {
+              treeKill(pid, "SIGKILL");
+            } catch {
+            }
+          }
+          logger.endGroup("Node-RED Stopped");
+          process.exit(1);
+        }
+        if (isShuttingDown) {
+          return;
+        }
+        isShuttingDown = true;
+        shutdownStartTime = now;
+        logger.warn("Shutting down gracefully... (Ctrl+C again to force)");
+        nodeRedLauncher.stop(true).then(() => {
+          nodeRedLauncher.cleanup();
+          logger.endGroup("Node-RED Stopped");
+          process.exit(0);
+        }).catch(() => {
+          process.exit(1);
+        });
+      });
+    }
+  };
+}
+
+// src/vite/plugins/build.ts
+import { execSync } from "child_process";
+import fs11 from "fs";
+import path12 from "path";
+function buildPlugin(options) {
+  const {
+    serverBuildOptions,
+    clientBuildOptions,
+    extraFilesCopyTargets,
+    buildContext
+  } = options;
+  return {
+    name: "vite-plugin-node-red:build",
+    apply: "build",
+    async buildStart() {
+      try {
+        logger.intro();
+        logger.startSpinner("Type checking");
+        const serverTsconfig = path12.resolve(
+          serverBuildOptions.srcDir ?? "./src/server",
+          "tsconfig.json"
+        );
+        const clientTsconfig = path12.resolve(
+          clientBuildOptions.srcDir ?? "./src/client",
+          "tsconfig.json"
+        );
+        const tsconfigsToCheck = [serverTsconfig, clientTsconfig].filter(
+          (p) => fs11.existsSync(p)
+        );
+        for (const tsconfig of tsconfigsToCheck) {
+          execSync(`npx tsc -p ${tsconfig} --noEmit`, { stdio: "inherit" });
+        }
+        logger.stopSpinner("Type checked");
+        logger.startSpinner("Cleaning");
+        cleanDir(buildContext.outDir);
+        logger.stopSpinner("Cleaned");
+        logger.startSpinner("Building");
+        await build(serverBuildOptions, buildContext);
+        await build2(clientBuildOptions, buildContext);
+        logger.stopSpinner("Built");
+        if (extraFilesCopyTargets.length) {
+          logger.startSpinner("Copying extra files");
+          copyFiles(extraFilesCopyTargets, buildContext.outDir);
+          logger.stopSpinner("Copied extra files");
+        }
+        logger.success("Success");
+        process.exit(0);
+      } catch (error) {
+        if (error instanceof BuildError) {
+          logger.error(`Build failed: ${error.message}`, error.cause);
+        } else {
+          logger.error("Unexpected error during build", error);
+        }
+        process.exit(1);
+      }
+    }
+  };
+}
+
+// src/vite/plugin.ts
+function nodeRed(options = {}) {
+  const { outDir = DEFAULT_OUTPUT_DIR } = options;
+  const clientBuildOptions = mergeOptions(
+    DEFAULT_CLIENT_BUILD_OPTIONS,
+    options.clientBuildOptions
+  );
+  const serverBuildOptions = mergeOptions(
+    DEFAULT_SERVER_BUILD_OPTIONS,
+    options.serverBuildOptions
+  );
+  const nodeRedLauncherOptions = mergeOptions(
+    DEFAULT_NODE_RED_LAUNCHER_OPTIONS,
+    options.nodeRedLauncherOptions
+  );
+  const extraFilesCopyTargets = options.extraFilesCopyTargets ?? DEFAULT_EXTRA_FILES_COPY_TARGETS;
+  const resolvedOutDir = path13.resolve(outDir);
+  const buildContext = {
+    outDir: resolvedOutDir,
+    packageName: getPackageName(),
+    isDev: process.env.NODE_ENV === "development"
+  };
+  const nodeRedLauncher = new NodeRedLauncher(
+    resolvedOutDir,
+    nodeRedLauncherOptions
+  );
+  return [
+    serverPlugin({
+      nodeRedLauncher,
+      serverBuildOptions,
+      clientBuildOptions,
+      extraFilesCopyTargets,
+      buildContext
+    }),
+    buildPlugin({
+      serverBuildOptions,
+      clientBuildOptions,
+      extraFilesCopyTargets,
+      buildContext
+    })
+  ];
+}
+export {
+  defineRuntimeSettings,
+  nodeRed
+};