@bonsae/nrg 0.16.0 → 0.18.0

package/test/client/e2e/index.js

@@ -0,0 +1,2698 @@
+// src/test/client/e2e/index.ts
+import fs12 from "fs";
+import path12 from "path";
+
+// src/test/client/e2e/environment.ts
+import fs11 from "fs";
+import path11 from "path";
+
+// src/vite/server/build.ts
+import { build as viteBuild } from "vite";
+import fs3 from "fs";
+import path3 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";
+  }
+};
+
+// 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/server/plugins/type-generator.ts
+import dts from "vite-plugin-dts";
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+function collectTsFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
+    const full = path.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 = fs.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;
+}
+var SCHEMA_PROP_SEMANTICS = {
+  configSchema: "ConfigSchema",
+  credentialsSchema: "CredentialsSchema",
+  inputSchema: "InputSchema",
+  outputsSchema: "OutputsSchema",
+  settingsSchema: "SettingsSchema"
+};
+function getSchemaReferences(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const importMap = /* @__PURE__ */ new Map();
+  for (const stmt of source.statements) {
+    if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+      const moduleSpecifier = stmt.moduleSpecifier.text;
+      const namedBindings = stmt.importClause.namedBindings;
+      if (namedBindings && ts.isNamedImports(namedBindings)) {
+        for (const el of namedBindings.elements) {
+          importMap.set(el.name.text, moduleSpecifier);
+        }
+      }
+    }
+  }
+  const schemaRefs = /* @__PURE__ */ new Map();
+  const recordPortNames = /* @__PURE__ */ new Map();
+  let outputsSchemaIsRecord = false;
+  function extractIdentifiers(node, propName) {
+    if (ts.isIdentifier(node)) return [node.text];
+    if (ts.isArrayLiteralExpression(node)) {
+      return node.elements.filter(ts.isIdentifier).map((el) => el.text);
+    }
+    if (ts.isObjectLiteralExpression(node) && propName === "outputsSchema") {
+      const ids = [];
+      outputsSchemaIsRecord = true;
+      for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer)) {
+          const portName = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : void 0;
+          if (portName) {
+            ids.push(prop.initializer.text);
+            recordPortNames.set(prop.initializer.text, portName);
+          }
+        }
+      }
+      return ids;
+    }
+    return [];
+  }
+  for (const stmt of source.statements) {
+    if (ts.isClassDeclaration(stmt)) {
+      for (const member of stmt.members) {
+        if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.name.text in SCHEMA_PROP_SEMANTICS && member.initializer) {
+          const ids = extractIdentifiers(member.initializer, member.name.text);
+          if (ids.length > 0) {
+            schemaRefs.set(member.name.text, ids);
+          }
+        }
+      }
+    }
+    if (ts.isExportAssignment(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+      const callee = stmt.expression.expression;
+      if (ts.isIdentifier(callee) && (callee.text === "defineIONode" || callee.text === "defineConfigNode")) {
+        const arg = stmt.expression.arguments[0];
+        if (arg && ts.isObjectLiteralExpression(arg)) {
+          for (const prop of arg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text in SCHEMA_PROP_SEMANTICS) {
+              const ids = extractIdentifiers(prop.initializer, prop.name.text);
+              if (ids.length > 0) {
+                schemaRefs.set(prop.name.text, ids);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const result = [];
+  for (const [propName, identifiers] of schemaRefs) {
+    const semanticName = SCHEMA_PROP_SEMANTICS[propName];
+    const isArray = identifiers.length > 1 && !outputsSchemaIsRecord;
+    const isRecord = propName === "outputsSchema" && outputsSchemaIsRecord;
+    for (const identifier of identifiers) {
+      const importSource = importMap.get(identifier);
+      if (importSource) {
+        result.push({
+          localName: identifier,
+          semanticName: isArray || isRecord ? identifier : semanticName,
+          importSource,
+          tupleProp: isArray || isRecord ? semanticName : void 0,
+          recordPortName: isRecord ? recordPortNames.get(identifier) : void 0
+        });
+      }
+    }
+  }
+  return result;
+}
+function getFactoryInfo(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const source = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  for (const stmt of source.statements) {
+    if (ts.isExportAssignment(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+      const callee = stmt.expression.expression;
+      if (ts.isIdentifier(callee)) {
+        if (callee.text === "defineIONode" || callee.text === "defineConfigNode") {
+          return { factoryName: callee.text };
+        }
+      }
+    }
+  }
+  return null;
+}
+function buildTypeArg(schemaMap, semanticName, portNameMap) {
+  const names = schemaMap.get(semanticName);
+  if (!names || names.length === 0) return "any";
+  if (names.length === 1 && !portNameMap?.has(names[0]))
+    return `Infer<typeof ${names[0]}>`;
+  if (portNameMap && names.some((n) => portNameMap.has(n))) {
+    const entries = names.map((n) => {
+      const portName = portNameMap.get(n);
+      return portName ? `${portName}: Infer<typeof ${n}>` : null;
+    }).filter(Boolean);
+    return `{ ${entries.join(", ")} }`;
+  }
+  return `[${names.map((n) => `Infer<typeof ${n}>`).join(", ")}]`;
+}
+function buildNodeReexports(srcDir, entryFile) {
+  const nodesDir = path.join(srcDir, "nodes");
+  const nodeFiles = collectTsFiles(nodesDir);
+  return nodeFiles.map((file) => {
+    const rel = path.relative(path.dirname(entryFile), file).replace(/\\/g, "/");
+    const relPath = rel.startsWith(".") ? rel : `./${rel}`;
+    const specifier = relPath.replace(/\.ts$/, "");
+    const ns = toPascalCase(path.basename(file, ".ts"));
+    const schemaRefs = getSchemaReferences(file);
+    const factoryInfo = getFactoryInfo(file);
+    const lines = [];
+    if (factoryInfo) {
+      const interfaceName = factoryInfo.factoryName === "defineIONode" ? "IIONode" : "IConfigNode";
+      lines.push(`import _${ns} from "${specifier}";`);
+      const schemaMap = /* @__PURE__ */ new Map();
+      const portNameMap = /* @__PURE__ */ new Map();
+      for (const ref of schemaRefs) {
+        const key = ref.tupleProp ?? ref.semanticName;
+        if (!schemaMap.has(key)) schemaMap.set(key, []);
+        schemaMap.get(key).push(ref.localName);
+        if (ref.recordPortName) {
+          portNameMap.set(ref.localName, ref.recordPortName);
+        }
+      }
+      const hasSchemas = schemaMap.size > 0;
+      const hasRecordOutputs = portNameMap.size > 0;
+      const nrgImports = ["NodeConstructor", interfaceName];
+      if (hasSchemas) nrgImports.push("Infer");
+      lines.push(
+        `import type { ${nrgImports.join(", ")} } from "@bonsae/nrg/server";`
+      );
+      if (hasSchemas) {
+        const bySource2 = /* @__PURE__ */ new Map();
+        for (const ref of schemaRefs) {
+          const resolvedSource = path.relative(
+            path.dirname(entryFile),
+            path.resolve(path.dirname(file), ref.importSource)
+          ).replace(/\\/g, "/");
+          const sourceSpecifier = resolvedSource.startsWith(".") ? resolvedSource : `./${resolvedSource}`;
+          if (!bySource2.has(sourceSpecifier))
+            bySource2.set(sourceSpecifier, []);
+          const list = bySource2.get(sourceSpecifier);
+          if (!list.includes(ref.localName)) list.push(ref.localName);
+        }
+        for (const [source, names] of bySource2) {
+          lines.push(`import type { ${names.join(", ")} } from "${source}";`);
+        }
+      }
+      let typeArgs;
+      if (factoryInfo.factoryName === "defineIONode") {
+        const outputsArg = buildTypeArg(
+          schemaMap,
+          "OutputsSchema",
+          portNameMap.size > 0 ? portNameMap : void 0
+        );
+        typeArgs = [
+          buildTypeArg(schemaMap, "ConfigSchema"),
+          buildTypeArg(schemaMap, "CredentialsSchema"),
+          buildTypeArg(schemaMap, "InputSchema"),
+          outputsArg
+        ].join(", ");
+      } else {
+        typeArgs = [
+          buildTypeArg(schemaMap, "ConfigSchema"),
+          buildTypeArg(schemaMap, "CredentialsSchema")
+        ].join(", ");
+      }
+      lines.push(
+        `export const ${ns}: NodeConstructor<${interfaceName}<${typeArgs}>> = _${ns};`
+      );
+    } else {
+      lines.push(`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}";`);
+      }
+    }
+    const bySource = /* @__PURE__ */ new Map();
+    for (const ref of schemaRefs) {
+      const resolvedSource = path.relative(
+        path.dirname(entryFile),
+        path.resolve(path.dirname(file), ref.importSource)
+      ).replace(/\\/g, "/");
+      const sourceSpecifier = resolvedSource.startsWith(".") ? resolvedSource : `./${resolvedSource}`;
+      if (!bySource.has(sourceSpecifier)) bySource.set(sourceSpecifier, []);
+      bySource.get(sourceSpecifier).push(`${ref.localName} as ${ns}${ref.semanticName}`);
+    }
+    for (const [source, names] of bySource) {
+      lines.push(`export { ${names.join(", ")} } from "${source}";`);
+    }
+    return lines.join("\n");
+  }).join("\n");
+}
+function typeGenerator(options) {
+  const { srcDir, outDir, entryFiles } = options;
+  const serverTsconfig = path.resolve(srcDir, "tsconfig.json");
+  const rootTsconfig = path.resolve("tsconfig.json");
+  const userTsconfig = fs.existsSync(serverTsconfig) ? serverTsconfig : rootTsconfig;
+  const clientDir = path.relative(
+    process.cwd(),
+    path.join(path.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 = fs.readFileSync(entryFile, "utf-8");
+        augmentedContents.set(
+          path.resolve(entryFile),
+          `${original}
+${reexports}
+`
+        );
+      }
+      if (augmentedContents.size === 0) return;
+      origReadFile = ts.sys.readFile.bind(ts.sys);
+      ts.sys.readFile = (fileName, encoding) => {
+        const resolved = path.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,
+      ...fs.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 fs2 from "fs";
+import path2 from "path";
+import { builtinModules } from "node:module";
+var nodeBuiltins = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.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 = path2.resolve("./package.json");
+      if (!fs2.existsSync(rootPackageJsonPath)) {
+        logger.warn(`package.json not found: ${rootPackageJsonPath}`);
+        return;
+      }
+      const rootPackageJson = JSON.parse(
+        fs2.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 = path2.resolve(
+            `./node_modules/${dep}/package.json`
+          );
+          if (fs2.existsSync(dependencyPackageJsonPath)) {
+            const dependencyPackageJson = JSON.parse(
+              fs2.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 (!fs2.existsSync(outDir)) {
+        fs2.mkdirSync(outDir, { recursive: true });
+      }
+      fs2.writeFileSync(
+        path2.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",
+    external = [],
+    bundled = [],
+    types = true,
+    nodeTarget = "node22"
+  } = serverOpts;
+  const entries = Array.isArray(entry) ? entry : [entry];
+  const resolvedSrcDir = path3.resolve(srcDir);
+  const entryPoints = {};
+  for (const entry2 of entries) {
+    const entryFilePath = path3.join(resolvedSrcDir, entry2);
+    if (fs3.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()
+  ];
+  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: {
+        external,
+        output: {
+          entryFileNames: isEsm ? "[name].mjs" : "[name].js",
+          exports: isEsm ? void 0 : "auto",
+          preserveModules: false
+        }
+      }
+    },
+    esbuild: {
+      platform: "node",
+      target: nodeTarget,
+      keepNames: true,
+      tsconfigRaw: "{}"
+    }
+  };
+  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);
+    });
+};
+`;
+      fs3.writeFileSync(path3.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 fs9 from "fs";
+import path9 from "path";
+
+// src/vite/client/plugins/help-generator.ts
+import fs4 from "fs";
+import path4 from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+
+// src/vite/client/plugins/help-i18n.ts
+var translations = {
+  "en-US": {
+    sections: {
+      properties: "Properties",
+      credentials: "Credentials",
+      input: "Input",
+      output: "Output",
+      outputs: "Outputs",
+      port: "Port"
+    },
+    columns: {
+      property: "Property",
+      label: "Label",
+      type: "Type",
+      required: "Required",
+      default: "Default",
+      description: "Description"
+    },
+    values: {
+      yes: "Yes",
+      no: "No"
+    }
+  },
+  de: {
+    sections: {
+      properties: "Eigenschaften",
+      credentials: "Zugangsdaten",
+      input: "Eingang",
+      output: "Ausgang",
+      outputs: "Ausg\xE4nge",
+      port: "Port"
+    },
+    columns: {
+      property: "Eigenschaft",
+      label: "Bezeichnung",
+      type: "Typ",
+      required: "Erforderlich",
+      default: "Standard",
+      description: "Beschreibung"
+    },
+    values: {
+      yes: "Ja",
+      no: "Nein"
+    }
+  },
+  "es-ES": {
+    sections: {
+      properties: "Propiedades",
+      credentials: "Credenciales",
+      input: "Entrada",
+      output: "Salida",
+      outputs: "Salidas",
+      port: "Puerto"
+    },
+    columns: {
+      property: "Propiedad",
+      label: "Etiqueta",
+      type: "Tipo",
+      required: "Requerido",
+      default: "Predeterminado",
+      description: "Descripci\xF3n"
+    },
+    values: {
+      yes: "S\xED",
+      no: "No"
+    }
+  },
+  fr: {
+    sections: {
+      properties: "Propri\xE9t\xE9s",
+      credentials: "Identifiants",
+      input: "Entr\xE9e",
+      output: "Sortie",
+      outputs: "Sorties",
+      port: "Port"
+    },
+    columns: {
+      property: "Propri\xE9t\xE9",
+      label: "Libell\xE9",
+      type: "Type",
+      required: "Requis",
+      default: "Par d\xE9faut",
+      description: "Description"
+    },
+    values: {
+      yes: "Oui",
+      no: "Non"
+    }
+  },
+  ko: {
+    sections: {
+      properties: "\uC18D\uC131",
+      credentials: "\uC790\uACA9 \uC99D\uBA85",
+      input: "\uC785\uB825",
+      output: "\uCD9C\uB825",
+      outputs: "\uCD9C\uB825",
+      port: "\uD3EC\uD2B8"
+    },
+    columns: {
+      property: "\uC18D\uC131",
+      label: "\uB77C\uBCA8",
+      type: "\uC720\uD615",
+      required: "\uD544\uC218",
+      default: "\uAE30\uBCF8\uAC12",
+      description: "\uC124\uBA85"
+    },
+    values: {
+      yes: "\uC608",
+      no: "\uC544\uB2C8\uC624"
+    }
+  },
+  "pt-BR": {
+    sections: {
+      properties: "Propriedades",
+      credentials: "Credenciais",
+      input: "Entrada",
+      output: "Sa\xEDda",
+      outputs: "Sa\xEDdas",
+      port: "Porta"
+    },
+    columns: {
+      property: "Propriedade",
+      label: "R\xF3tulo",
+      type: "Tipo",
+      required: "Obrigat\xF3rio",
+      default: "Padr\xE3o",
+      description: "Descri\xE7\xE3o"
+    },
+    values: {
+      yes: "Sim",
+      no: "N\xE3o"
+    }
+  },
+  ru: {
+    sections: {
+      properties: "\u0421\u0432\u043E\u0439\u0441\u0442\u0432\u0430",
+      credentials: "\u0423\u0447\u0451\u0442\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435",
+      input: "\u0412\u0445\u043E\u0434",
+      output: "\u0412\u044B\u0445\u043E\u0434",
+      outputs: "\u0412\u044B\u0445\u043E\u0434\u044B",
+      port: "\u041F\u043E\u0440\u0442"
+    },
+    columns: {
+      property: "\u0421\u0432\u043E\u0439\u0441\u0442\u0432\u043E",
+      label: "\u041C\u0435\u0442\u043A\u0430",
+      type: "\u0422\u0438\u043F",
+      required: "\u041E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E",
+      default: "\u041F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E",
+      description: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435"
+    },
+    values: {
+      yes: "\u0414\u0430",
+      no: "\u041D\u0435\u0442"
+    }
+  },
+  ja: {
+    sections: {
+      properties: "\u30D7\u30ED\u30D1\u30C6\u30A3",
+      credentials: "\u8A8D\u8A3C\u60C5\u5831",
+      input: "\u5165\u529B",
+      output: "\u51FA\u529B",
+      outputs: "\u51FA\u529B",
+      port: "\u30DD\u30FC\u30C8"
+    },
+    columns: {
+      property: "\u30D7\u30ED\u30D1\u30C6\u30A3",
+      label: "\u30E9\u30D9\u30EB",
+      type: "\u578B",
+      required: "\u5FC5\u9808",
+      default: "\u30C7\u30D5\u30A9\u30EB\u30C8",
+      description: "\u8AAC\u660E"
+    },
+    values: {
+      yes: "\u306F\u3044",
+      no: "\u3044\u3044\u3048"
+    }
+  },
+  "zh-CN": {
+    sections: {
+      properties: "\u5C5E\u6027",
+      credentials: "\u51ED\u8BC1",
+      input: "\u8F93\u5165",
+      output: "\u8F93\u51FA",
+      outputs: "\u8F93\u51FA",
+      port: "\u7AEF\u53E3"
+    },
+    columns: {
+      property: "\u5C5E\u6027",
+      label: "\u6807\u7B7E",
+      type: "\u7C7B\u578B",
+      required: "\u5FC5\u586B",
+      default: "\u9ED8\u8BA4\u503C",
+      description: "\u63CF\u8FF0"
+    },
+    values: {
+      yes: "\u662F",
+      no: "\u5426"
+    }
+  },
+  "zh-TW": {
+    sections: {
+      properties: "\u5C6C\u6027",
+      credentials: "\u6191\u8B49",
+      input: "\u8F38\u5165",
+      output: "\u8F38\u51FA",
+      outputs: "\u8F38\u51FA",
+      port: "\u57E0"
+    },
+    columns: {
+      property: "\u5C6C\u6027",
+      label: "\u6A19\u7C64",
+      type: "\u985E\u578B",
+      required: "\u5FC5\u586B",
+      default: "\u9810\u8A2D\u503C",
+      description: "\u63CF\u8FF0"
+    },
+    values: {
+      yes: "\u662F",
+      no: "\u5426"
+    }
+  }
+};
+function getHelpTranslations(lang) {
+  return translations[lang] ?? translations["en-US"];
+}
+
+// src/vite/client/plugins/help-generator.ts
+function buildPropertyRow(name, schema, required, label) {
+  let type = "";
+  if (schema["x-nrg-node-type"]) {
+    type = `NodeRef \u2192 ${schema["x-nrg-node-type"]}`;
+  } else if (schema["x-nrg-typed-input"]) {
+    type = "TypedInput";
+  } else if (schema.type) {
+    type = String(schema.type);
+  }
+  if (schema.enum) type += ` (${schema.enum.join(", ")})`;
+  const constraints = [];
+  if (schema.minLength !== void 0)
+    constraints.push(`min: ${schema.minLength}`);
+  if (schema.maxLength !== void 0)
+    constraints.push(`max: ${schema.maxLength}`);
+  if (schema.minimum !== void 0) constraints.push(`min: ${schema.minimum}`);
+  if (schema.maximum !== void 0) constraints.push(`max: ${schema.maximum}`);
+  if (schema.pattern) constraints.push(`pattern: \`${schema.pattern}\``);
+  if (schema.format && schema.format !== "password")
+    constraints.push(`format: ${schema.format}`);
+  if (constraints.length) type += ` [${constraints.join(", ")}]`;
+  const defaultVal = schema.default !== void 0 ? JSON.stringify(schema.default) : "";
+  const description = schema.description ?? "";
+  return { name, label: label ?? "", type, required, defaultVal, description };
+}
+var SKIP_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "z",
+  "name",
+  "wires",
+  "x",
+  "y",
+  "g",
+  "_users"
+]);
+function generateSchemaSection(options) {
+  const {
+    title,
+    schema,
+    t,
+    labels,
+    heading = "###",
+    includeDefault = true
+  } = options;
+  if (!schema?.properties) return "";
+  const required = new Set(schema.required ?? []);
+  const rows = Object.entries(schema.properties).filter(([key]) => !SKIP_FIELDS.has(key)).map(
+    ([key, propSchema]) => buildPropertyRow(
+      key,
+      propSchema,
+      required.has(key),
+      labels?.[key]
+    )
+  );
+  if (rows.length === 0) return "";
+  const hasLabels = rows.some((r) => r.label);
+  const c = t.columns;
+  const v = t.values;
+  let headerCells;
+  let rowFn;
+  if (hasLabels && includeDefault) {
+    headerCells = `<th>${c.label}</th><th>${c.property}</th><th>${c.type}</th><th>${c.required}</th><th>${c.default}</th><th style="width:35%">${c.description}</th>`;
+    rowFn = (r) => `<tr><td>${r.label}</td><td>${r.name}</td><td>${r.type}</td><td>${r.required ? v.yes : v.no}</td><td>${r.defaultVal ? `<code>${r.defaultVal}</code>` : ""}</td><td>${r.description}</td></tr>`;
+  } else if (hasLabels) {
+    headerCells = `<th>${c.label}</th><th>${c.property}</th><th>${c.type}</th><th>${c.required}</th><th style="width:35%">${c.description}</th>`;
+    rowFn = (r) => `<tr><td>${r.label}</td><td>${r.name}</td><td>${r.type}</td><td>${r.required ? v.yes : v.no}</td><td>${r.description}</td></tr>`;
+  } else if (includeDefault) {
+    headerCells = `<th>${c.property}</th><th>${c.type}</th><th>${c.required}</th><th>${c.default}</th><th style="width:40%">${c.description}</th>`;
+    rowFn = (r) => `<tr><td>${r.name}</td><td>${r.type}</td><td>${r.required ? v.yes : v.no}</td><td>${r.defaultVal ? `<code>${r.defaultVal}</code>` : ""}</td><td>${r.description}</td></tr>`;
+  } else {
+    headerCells = `<th>${c.property}</th><th>${c.type}</th><th>${c.required}</th><th style="width:40%">${c.description}</th>`;
+    rowFn = (r) => `<tr><td>${r.name}</td><td>${r.type}</td><td>${r.required ? v.yes : v.no}</td><td>${r.description}</td></tr>`;
+  }
+  const tableRows = rows.map(rowFn).join("\n");
+  const table = `<div style="overflow-x:auto">
+<table width="100%" style="min-width:500px">
+<thead><tr>${headerCells}</tr></thead>
+<tbody>
+${tableRows}
+</tbody>
+</table>
+</div>`;
+  const headingLevel = heading.length;
+  const tag = `h${headingLevel}`;
+  return `<${tag}>${title}</${tag}>
+${table}
+`;
+}
+function loadNodeLabels(labelPath) {
+  if (!fs4.existsSync(labelPath)) return {};
+  try {
+    const raw = JSON.parse(fs4.readFileSync(labelPath, "utf-8"));
+    return {
+      description: raw.description,
+      configs: raw.configs,
+      credentials: raw.credentials,
+      input: raw.input,
+      outputs: raw.outputs
+    };
+  } catch {
+    return {};
+  }
+}
+function generateHelpDoc(nodeClass, labels, t) {
+  const lines = [];
+  if (labels.description) {
+    lines.push(`<p>${labels.description}</p>`);
+  }
+  const configSection = generateSchemaSection({
+    title: t.sections.properties,
+    schema: nodeClass.configSchema,
+    t,
+    labels: labels.configs
+  });
+  if (configSection) lines.push(configSection);
+  const credsSection = generateSchemaSection({
+    title: t.sections.credentials,
+    schema: nodeClass.credentialsSchema,
+    t,
+    labels: labels.credentials
+  });
+  if (credsSection) lines.push(credsSection);
+  if (nodeClass.inputSchema) {
+    const inputSection = generateSchemaSection({
+      title: t.sections.input,
+      schema: nodeClass.inputSchema,
+      t,
+      labels: labels.input,
+      includeDefault: false
+    });
+    if (inputSection) lines.push(inputSection);
+  }
+  if (nodeClass.outputsSchema) {
+    const os2 = nodeClass.outputsSchema;
+    if (Array.isArray(os2)) {
+      const portSections = [];
+      os2.forEach((schema, i) => {
+        const title = `${t.sections.port} ${i + 1}`;
+        const portPropLabels = labels.outputs?.[i];
+        const section = generateSchemaSection({
+          title,
+          schema,
+          t,
+          labels: portPropLabels,
+          heading: "####",
+          includeDefault: false
+        });
+        if (section) portSections.push(section);
+      });
+      if (portSections.length) {
+        lines.push(
+          `<h3>${t.sections.outputs}</h3>
+${portSections.join("\n")}`
+        );
+      }
+    } else if (!("type" in os2 || "properties" in os2)) {
+      const portSections = [];
+      for (const [portName, schema] of Object.entries(os2)) {
+        const portPropLabels = labels.outputs?.[portName];
+        const section = generateSchemaSection({
+          title: portName,
+          schema,
+          t,
+          labels: portPropLabels,
+          heading: "####",
+          includeDefault: false
+        });
+        if (section) portSections.push(section);
+      }
+      if (portSections.length) {
+        lines.push(
+          `<h3>${t.sections.outputs}</h3>
+${portSections.join("\n")}`
+        );
+      }
+    } else {
+      const outputPropLabels = labels.outputs?.[0];
+      const section = generateSchemaSection({
+        title: t.sections.output,
+        schema: os2,
+        t,
+        labels: outputPropLabels,
+        includeDefault: false
+      });
+      if (section) lines.push(section);
+    }
+  }
+  return lines.join("\n").trim();
+}
+function discoverLanguages(labelsDir, nodeType) {
+  const nodeLabelsDir = path4.join(labelsDir, nodeType);
+  if (!fs4.existsSync(nodeLabelsDir)) return [];
+  return fs4.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path4.basename(f, ".json"));
+}
+function helpGenerator(options) {
+  const { outDir, localesOutDir, docsDir, labelsDir } = options;
+  return {
+    name: "vite-plugin-node-red:client:help-generator",
+    apply: "build",
+    enforce: "post",
+    async closeBundle() {
+      const esmPath = path4.resolve(outDir, "index.mjs");
+      const cjsPath = path4.resolve(outDir, "index.js");
+      let packageFn;
+      try {
+        if (fs4.existsSync(esmPath)) {
+          const fileUrl = pathToFileURL(esmPath).href + `?t=${Date.now()}`;
+          const mod = await import(fileUrl);
+          packageFn = mod?.default ?? mod;
+        } else if (fs4.existsSync(cjsPath)) {
+          const require2 = createRequire(import.meta.url);
+          delete require2.cache[cjsPath];
+          const rawMod = require2(cjsPath);
+          packageFn = rawMod?.default ?? rawMod;
+        }
+      } catch {
+        return;
+      }
+      const nodeClasses = packageFn?.nodes ?? [];
+      const helpByLang = /* @__PURE__ */ new Map();
+      for (const NodeClass of nodeClasses) {
+        const type = NodeClass.type;
+        if (!type) continue;
+        const languages = discoverLanguages(labelsDir, type);
+        if (!languages.includes("en-US")) languages.push("en-US");
+        for (const lang of languages) {
+          const manualMd = path4.join(docsDir, type, `${lang}.md`);
+          const manualHtml = path4.join(docsDir, type, `${lang}.html`);
+          if (fs4.existsSync(manualMd) || fs4.existsSync(manualHtml)) continue;
+          const labelPath = path4.join(labelsDir, type, `${lang}.json`);
+          const labels = loadNodeLabels(labelPath);
+          const t = getHelpTranslations(lang);
+          const content = generateHelpDoc(NodeClass, labels, t);
+          if (!content) continue;
+          if (!helpByLang.has(lang)) helpByLang.set(lang, []);
+          helpByLang.get(lang).push(
+            `<script type="text/html" data-help-name="${type}">
+${content}
+</script>`
+          );
+        }
+      }
+      for (const [lang, scripts] of helpByLang) {
+        const langDir = path4.join(localesOutDir, lang);
+        fs4.mkdirSync(langDir, { recursive: true });
+        const indexPath = path4.join(langDir, "index.html");
+        const existing = fs4.existsSync(indexPath) ? fs4.readFileSync(indexPath, "utf-8") : "";
+        fs4.writeFileSync(
+          indexPath,
+          existing + (existing ? "\n" : "") + scripts.join("\n"),
+          "utf-8"
+        );
+      }
+    }
+  };
+}
+
+// src/vite/client/plugins/html-generator.ts
+import mime from "mime-types";
+import fs5 from "fs";
+import path5 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 = path5.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 && fs5.existsSync(licensePath) ? `<!--
+${fs5.readFileSync(licensePath, "utf-8")}
+-->` : "";
+      this.emitFile({
+        type: "asset",
+        fileName: "index.html",
+        source: `${licenseBanner}
+${resourcesTags}`
+      });
+    }
+  };
+}
+
+// src/vite/client/plugins/locales-generator.ts
+import fs6 from "fs";
+import path6 from "path";
+import { merge } from "es-toolkit";
+function localesGenerator(options) {
+  const { outDir, docsDir, labelsDir } = options;
+  const languages = [
+    "en-US",
+    "de",
+    "es-ES",
+    "fr",
+    "ko",
+    "pt-BR",
+    "ru",
+    "ja",
+    "zh-CN",
+    "zh-TW"
+  ];
+  const frameworkLabels = {
+    "en-US": {
+      configs: { name: "Name" },
+      toggles: {
+        validateInput: "Validate Input",
+        validateOutput: "Validate Output",
+        errorPort: "Error Port",
+        completePort: "Complete Port",
+        statusPort: "Status Port"
+      }
+    },
+    de: {
+      configs: { name: "Name" },
+      toggles: {
+        validateInput: "Eingabe validieren",
+        validateOutput: "Ausgabe validieren",
+        errorPort: "Fehler-Port",
+        completePort: "Abschluss-Port",
+        statusPort: "Status-Port"
+      }
+    },
+    "es-ES": {
+      configs: { name: "Nombre" },
+      toggles: {
+        validateInput: "Validar entrada",
+        validateOutput: "Validar salida",
+        errorPort: "Puerto de error",
+        completePort: "Puerto de completado",
+        statusPort: "Puerto de estado"
+      }
+    },
+    fr: {
+      configs: { name: "Nom" },
+      toggles: {
+        validateInput: "Valider l'entr\xE9e",
+        validateOutput: "Valider la sortie",
+        errorPort: "Port d'erreur",
+        completePort: "Port de compl\xE9tion",
+        statusPort: "Port de statut"
+      }
+    },
+    ko: {
+      configs: { name: "\uC774\uB984" },
+      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"
+      }
+    },
+    "pt-BR": {
+      configs: { name: "Nome" },
+      toggles: {
+        validateInput: "Validar Entrada",
+        validateOutput: "Validar Sa\xEDda",
+        errorPort: "Porta de Erro",
+        completePort: "Porta de Conclus\xE3o",
+        statusPort: "Porta de Status"
+      }
+    },
+    ru: {
+      configs: { name: "\u0418\u043C\u044F" },
+      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"
+      }
+    },
+    ja: {
+      configs: { name: "\u540D\u524D" },
+      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"
+      }
+    },
+    "zh-CN": {
+      configs: { name: "\u540D\u79F0" },
+      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"
+      }
+    },
+    "zh-TW": {
+      configs: { name: "\u540D\u7A31" },
+      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"
+      }
+    }
+  };
+  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 (!fs6.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs6.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const nodeDir of nodeDirs) {
+          const nodeType = nodeDir.name;
+          const nodePath = path6.join(baseDir, nodeType);
+          const files = fs6.readdirSync(nodePath);
+          for (const file of files) {
+            const ext = path6.extname(file);
+            if (!fileExtensions.includes(ext)) continue;
+            const lang = path6.basename(file, ext);
+            const filePath = path6.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 = path6.join(outDir, lang);
+          fs6.mkdirSync(langOutDir, { recursive: true });
+          fs6.writeFileSync(
+            path6.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 = fs6.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, nodeType }) => {
+          const parsed = JSON.parse(fs6.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`
+            );
+          }
+          return parsed;
+        }
+      );
+      for (const [lang, nodeTypes] of labelLangs.entries()) {
+        const defaults = frameworkLabels[lang] ?? frameworkLabels["en-US"];
+        for (const nodeType of Object.keys(nodeTypes)) {
+          nodeTypes[nodeType] = merge(
+            structuredClone(defaults),
+            nodeTypes[nodeType]
+          );
+        }
+      }
+      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",
+    async generateBundle(_options, bundle) {
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "chunk" && fileName.endsWith(".js")) {
+          const result = await transform(chunk.code, {
+            minify: true
+          });
+          chunk.code = result.code;
+          chunk.map = null;
+        }
+      }
+    }
+  };
+}
+
+// src/vite/client/plugins/node-definitions-inliner.ts
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import path7 from "path";
+import fs7 from "fs";
+import mime2 from "mime-types";
+var VIRTUAL_ID = "virtual:nrg/node-definitions";
+var RESOLVED_ID = "\0" + VIRTUAL_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["x-nrg-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 (!fs7.existsSync(iconsDir)) return void 0;
+  return fs7.readdirSync(iconsDir).find((f) => {
+    if (path7.basename(f, path7.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 = {};
+  const cacheDir = path7.resolve("node_modules", ".nrg", "client");
+  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 = path7.resolve(serverOutDir, "index.mjs");
+      const cjsEntryPath = path7.resolve(serverOutDir, "index.js");
+      let packageFn;
+      if (fs7.existsSync(esmEntryPath)) {
+        const fileUrl = pathToFileURL2(esmEntryPath).href + `?t=${Date.now()}`;
+        const mod = await import(fileUrl);
+        packageFn = mod?.default ?? mod;
+      } else if (fs7.existsSync(cjsEntryPath)) {
+        const require2 = createRequire2(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,
+          inputs: NodeClass.inputs,
+          outputs: NodeClass.outputs,
+          inputSchema,
+          outputsSchema
+        };
+      }
+      if (!hasUserEntry) {
+        const nodesCache = path7.resolve(cacheDir, "nodes");
+        if (fs7.existsSync(nodesCache)) {
+          fs7.rmSync(nodesCache, { recursive: true });
+        }
+        fs7.mkdirSync(nodesCache, { recursive: true });
+        for (const type of _nodeTypes) {
+          const userTsPath = nodesDir ? path7.resolve(nodesDir, `${type}.ts`) : null;
+          if (userTsPath && fs7.existsSync(userTsPath)) continue;
+          const content = [
+            `// auto-generated by nrg`,
+            `import { defineNode } from "@bonsae/nrg/client";`,
+            ``,
+            `export default defineNode({`,
+            `  type: ${JSON.stringify(type)},`,
+            `});`,
+            ``
+          ].join("\n");
+          fs7.writeFileSync(path7.resolve(nodesCache, `${type}.ts`), content);
+        }
+        const entryContent = generateEntryCode("");
+        fs7.mkdirSync(path7.dirname(path7.resolve(cacheDir, "index.ts")), {
+          recursive: true
+        });
+        fs7.writeFileSync(path7.resolve(cacheDir, "index.ts"), entryContent);
+      }
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return RESOLVED_ID;
+    },
+    load(id) {
+      if (id === RESOLVED_ID)
+        return `export default ${JSON.stringify(_definitions)};`;
+      if (!hasUserEntry && id === entryPath) {
+        return generateEntryCode("");
+      }
+    },
+    transform(code, id) {
+      if (id !== entryPath) return;
+      if (!hasUserEntry) return;
+      return { code: generateEntryCode(code), map: null };
+    }
+  };
+  function generateEntryCode(userCode) {
+    const nrgImports = /* @__PURE__ */ new Set(["__setSchemas"]);
+    const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
+    const postLines = [`__setSchemas(__nrgSchemas);`];
+    if (componentsDir && fs7.existsSync(componentsDir)) {
+      const formImports = [];
+      const formEntries = [];
+      for (const type of _nodeTypes) {
+        const componentPath = path7.resolve(componentsDir, `${type}.vue`);
+        if (fs7.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 nodesCache = path7.resolve(cacheDir, "nodes");
+      const defVarNames = [];
+      for (const type of _nodeTypes) {
+        const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
+        const userTsPath = nodesDir ? path7.resolve(nodesDir, `${type}.ts`) : null;
+        const tsPath = userTsPath && fs7.existsSync(userTsPath) ? userTsPath : path7.resolve(nodesCache, `${type}.ts`);
+        lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
+        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 lines.join("\n") + userCode;
+  }
+}
+
+// src/vite/client/plugins/static-copy.ts
+import fs8 from "fs";
+import path8 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 (!fs8.existsSync(src)) continue;
+        fs8.mkdirSync(dest, { recursive: true });
+        const stat = fs8.statSync(src);
+        if (stat.isDirectory()) {
+          const files = fs8.readdirSync(src);
+          for (const file of files) {
+            const srcFile = path8.join(src, file);
+            const destFile = path8.join(dest, file);
+            const fileStat = fs8.statSync(srcFile);
+            if (fileStat.isDirectory()) {
+              fs8.cpSync(srcFile, destFile, { recursive: true });
+            } else {
+              fs8.copyFileSync(srcFile, destFile);
+            }
+          }
+        } else {
+          fs8.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 = [],
+    globals = {},
+    manualChunks
+  } = clientBuildOptions;
+  const physicalEntryPath = path9.resolve(srcDir, entry);
+  let entryPath;
+  let generatedEntry = false;
+  if (fs9.existsSync(physicalEntryPath)) {
+    entryPath = physicalEntryPath;
+  } else {
+    const cacheDir = path9.resolve("node_modules", ".nrg", "client");
+    const cachedEntryPath = path9.resolve(cacheDir, entry);
+    if (!fs9.existsSync(cacheDir)) {
+      fs9.mkdirSync(cacheDir, { recursive: true });
+    }
+    fs9.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    entryPath = cachedEntryPath;
+    generatedEntry = true;
+  }
+  const iconsDir = path9.resolve(
+    staticDirs.icons ?? path9.join(path9.dirname(path9.resolve(srcDir)), "icons")
+  );
+  const plugins = [
+    vue(),
+    nodeDefinitionsInliner(
+      buildContext.outDir,
+      entryPath,
+      fs9.existsSync(iconsDir) ? iconsDir : void 0,
+      path9.resolve(srcDir, "components"),
+      path9.resolve(srcDir, "nodes"),
+      !generatedEntry
+    )
+  ];
+  plugins.push(
+    htmlGenerator({
+      packageName: buildContext.packageName,
+      licensePath: licensePath ? path9.resolve(licensePath) : void 0
+    })
+  );
+  if (locales) {
+    const { docsDir = "./locales/docs", labelsDir = "./locales/labels" } = locales;
+    const localesOutDir = path9.join(buildContext.outDir, "locales");
+    plugins.push(
+      localesGenerator({
+        outDir: localesOutDir,
+        docsDir: path9.resolve(docsDir),
+        labelsDir: path9.resolve(labelsDir)
+      })
+    );
+    plugins.push(
+      helpGenerator({
+        outDir: buildContext.outDir,
+        localesOutDir,
+        docsDir: path9.resolve(docsDir),
+        labelsDir: path9.resolve(labelsDir)
+      })
+    );
+  }
+  const copyTargets = [];
+  const publicDir = path9.resolve(
+    staticDirs.public ?? path9.join(srcDir, "public")
+  );
+  if (fs9.existsSync(publicDir)) {
+    copyTargets.push({
+      src: publicDir,
+      dest: path9.join(buildContext.outDir, "resources")
+    });
+  }
+  if (fs9.existsSync(iconsDir)) {
+    copyTargets.push({
+      src: iconsDir,
+      dest: path9.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: `/resources/${buildContext.packageName}`,
+    publicDir: path9.resolve(srcDir, "public"),
+    resolve: {
+      alias: {
+        "@": path9.resolve(srcDir)
+      }
+    },
+    plugins,
+    esbuild: {
+      tsconfigRaw: "{}"
+    },
+    css: {
+      devSourcemap: buildContext.isDev
+    },
+    build: {
+      outDir: buildContext.outDir,
+      emptyOutDir: false,
+      sourcemap: buildContext.isDev ? "inline" : false,
+      minify: !buildContext.isDev && format !== "es",
+      copyPublicDir: false,
+      lib: {
+        entry: entryPath,
+        name,
+        fileName: "index",
+        formats: [format]
+      },
+      rollupOptions: {
+        external,
+        treeshake: false,
+        output: {
+          entryFileNames: "resources/index.[hash].js",
+          chunkFileNames: "resources/vendor.[hash].js",
+          assetFileNames: "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) {
+      if (fs9.existsSync(entryPath)) {
+        fs9.unlinkSync(entryPath);
+      }
+    }
+  }
+}
+
+// src/vite/node-red-launcher.ts
+import { spawn } from "child_process";
+import getPort from "get-port";
+import detect from "detect-port";
+import { builtinModules as builtinModules2 } from "module";
+import treeKill from "tree-kill";
+import fs10 from "fs";
+import os from "os";
+import path10 from "path";
+import { build as esbuild } from "esbuild";
+
+// src/vite/async-utils.ts
+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/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 = path10.resolve(runtimeSettingsFilepath);
+      if (fs10.existsSync(resolved2)) {
+        return resolved2;
+      }
+      this.logger.warn(`Settings file not found: ${runtimeSettingsFilepath}`);
+      return null;
+    }
+    const resolved = path10.resolve("node-red.settings.ts");
+    if (fs10.existsSync(resolved)) {
+      return resolved;
+    }
+    return null;
+  }
+  async compileRuntimeSettingsFile(runtimeSettingsFilepath) {
+    const compiledRuntimeSettingsFilepath = path10.join(
+      os.tmpdir(),
+      `node-red.settings.${process.pid}.cjs`
+    );
+    const nodeBuiltins2 = [
+      ...builtinModules2,
+      ...builtinModules2.map((m) => `node:${m}`)
+    ];
+    const settingsDir = path10.dirname(runtimeSettingsFilepath).split(path10.sep).join("/");
+    const settingsFile = runtimeSettingsFilepath.split(path10.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 = path10.resolve(this.outDir).split(path10.sep).join("/");
+    const cwd = process.cwd().split(path10.sep).join("/");
+    const userDir = path10.resolve(cwd, ".node-red");
+    const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
+const compiledRuntimeSettings = require("${compiledRuntimeSettingsFilepath.split(path10.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 = path10.join(
+      os.tmpdir(),
+      `node-red-settings-final-${process.pid}.cjs`
+    );
+    fs10.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
+    this.compiledRuntimeSettingsFilepath = finalRuntimeSettingsFilepath;
+    return finalRuntimeSettingsFilepath;
+  }
+  log(line) {
+    if (line.includes("Server now running at")) {
+      return;
+    }
+    this.logger.raw(line);
+  }
+  async start() {
+    const available = await detect(this.preferredPort);
+    if (available === this.preferredPort) {
+      this.port = this.preferredPort;
+    } else {
+      this.logger.warn(
+        `Port ${this.preferredPort} is still in use, waiting...`
+      );
+      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 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(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));
+        }
+      });
+    };
+    try {
+      await retry(startProcess, { attempts: 3, delay: 100 });
+      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);
+    }
+  }
+  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(void 0);
+      });
+      treeKill(pid, "SIGTERM", (error) => {
+        if (error) {
+          try {
+            process.kill(pid, "SIGTERM");
+          } catch {
+            this.process = null;
+            resolve(void 0);
+          }
+        }
+      });
+    });
+    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);
+        });
+      });
+    }
+    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 {
+        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));
+        }
+      }
+    }
+    this.port = null;
+  }
+  flushLogs() {
+    for (const line of this.bufferedLogs) {
+      this.log(line);
+    }
+    this.bufferedLogs = [];
+  }
+  cleanup() {
+    if (this.compiledRuntimeSettingsFilepath && fs10.existsSync(this.compiledRuntimeSettingsFilepath)) {
+      fs10.unlinkSync(this.compiledRuntimeSettingsFilepath);
+      this.compiledRuntimeSettingsFilepath = null;
+    }
+  }
+};
+
+// src/test/client/e2e/environment.ts
+var NodeRedTestEnvironment = class {
+  port = null;
+  launcher = null;
+  originalCwd = null;
+  projectDir;
+  outDir;
+  nodeRedDir;
+  installedPkgDir;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.projectDir = path11.resolve(options.projectDir ?? process.cwd());
+    this.outDir = path11.join(this.projectDir, "dist-e2e");
+    this.nodeRedDir = path11.join(this.projectDir, ".node-red");
+    this.installedPkgDir = path11.join(
+      this.nodeRedDir,
+      "node_modules",
+      options.packageName
+    );
+  }
+  get nodeRedPort() {
+    return this.port;
+  }
+  async setup() {
+    this.originalCwd = process.cwd();
+    process.chdir(this.projectDir);
+    if (fs11.existsSync(this.outDir)) fs11.rmSync(this.outDir, { recursive: true });
+    fs11.mkdirSync(this.outDir, { recursive: true });
+    const buildContext = {
+      outDir: this.outDir,
+      packageName: this.options.packageName,
+      isDev: false
+    };
+    const serverOpts = {
+      srcDir: path11.join(this.projectDir, "src/server"),
+      entry: "index.ts",
+      format: "esm",
+      bundled: [],
+      types: false,
+      nodeTarget: "node22",
+      ...this.options.server
+    };
+    await build(serverOpts, buildContext);
+    const clientOpts = {
+      srcDir: path11.join(this.projectDir, "src/client"),
+      entry: "index.ts",
+      name: this.options.clientName ?? "NodeRedNodes",
+      format: "es",
+      external: ["jquery", "node-red", "vue", "@bonsae/nrg/client"],
+      globals: { jquery: "$", "node-red": "RED", vue: "Vue" },
+      ...this.options.client
+    };
+    await build2(clientOpts, buildContext);
+    fs11.mkdirSync(this.installedPkgDir, { recursive: true });
+    fs11.cpSync(this.outDir, this.installedPkgDir, { recursive: true });
+    fs11.mkdirSync(this.nodeRedDir, { recursive: true });
+    fs11.writeFileSync(
+      path11.join(this.nodeRedDir, ".config.runtime.json"),
+      JSON.stringify({ telemetryEnabled: false })
+    );
+    const launcherOpts = {
+      runtime: { port: this.options.port ?? 1881 }
+    };
+    if (this.options.settingsFile) {
+      launcherOpts.runtime.settingsFilepath = path11.resolve(
+        this.projectDir,
+        this.options.settingsFile
+      );
+    }
+    this.launcher = new NodeRedLauncher(this.installedPkgDir, launcherOpts);
+    this.port = await this.launcher.start();
+    this.launcher.flushLogs();
+    process.chdir(this.originalCwd);
+    return this.port;
+  }
+  async deployFlow(flow) {
+    if (!this.port) {
+      throw new Error("Environment not started. Call setup() first.");
+    }
+    const res = await fetch(`http://localhost:${this.port}/flows`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Node-RED-Deployment-Type": "full"
+      },
+      body: JSON.stringify(flow)
+    });
+    if (!res.ok) {
+      throw new Error(
+        `Failed to deploy flow: ${res.status} ${await res.text()}`
+      );
+    }
+  }
+  async teardown() {
+    if (this.launcher) {
+      await this.launcher.stop();
+      this.launcher.cleanup();
+      this.launcher = null;
+    }
+    if (fs11.existsSync(this.outDir)) fs11.rmSync(this.outDir, { recursive: true });
+    if (fs11.existsSync(this.nodeRedDir)) {
+      fs11.rmSync(this.nodeRedDir, { recursive: true });
+    }
+    this.port = null;
+  }
+};
+
+// src/test/client/e2e/index.ts
+var defaultConfig = {
+  testTimeout: 6e4,
+  hookTimeout: 12e4,
+  globalSetup: ["@bonsae/nrg/test/client/e2e"]
+};
+var _env = null;
+async function setup(options) {
+  const packageName = JSON.parse(
+    fs12.readFileSync(path12.join(process.cwd(), "package.json"), "utf-8")
+  ).name;
+  _env = new NodeRedTestEnvironment({
+    packageName,
+    settingsFile: options?.settingsFile
+  });
+  const port = await _env.setup();
+  process.env.NODE_RED_PORT = String(port);
+  if (options?.flow) {
+    await _env.deployFlow(options.flow);
+  }
+}
+async function teardown() {
+  if (_env) {
+    await _env.teardown();
+    _env = null;
+  }
+  delete process.env.NODE_RED_PORT;
+}
+var NodeRedEditor = class {
+  constructor(page, port, options) {
+    this.page = page;
+    this.port = port;
+    this.screenshotDir = options?.screenshotDir ?? "test-results/screenshots";
+    page.on("pageerror", (err) => this.errors.push(err.message));
+  }
+  errors = [];
+  screenshotDir;
+  async screenshot(name) {
+    fs12.mkdirSync(this.screenshotDir, { recursive: true });
+    const filePath = path12.join(this.screenshotDir, `${name}.png`);
+    await this.page.screenshot({ path: filePath, fullPage: true });
+    return filePath;
+  }
+  async open() {
+    await this.page.goto(`http://localhost:${this.port}`);
+    await this.page.waitForSelector("#red-ui-workspace", { timeout: 3e4 });
+    await this.page.waitForFunction(
+      () => {
+        const r = globalThis.RED;
+        return r && typeof r.editor?.edit === "function";
+      },
+      { timeout: 15e3 }
+    );
+  }
+  async deployFlow(flow) {
+    const res = await fetch(`http://localhost:${this.port}/flows`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Node-RED-Deployment-Type": "full"
+      },
+      body: JSON.stringify(flow)
+    });
+    if (!res.ok) {
+      throw new Error(
+        `Failed to deploy flow: ${res.status} ${await res.text()}`
+      );
+    }
+    await this.page.reload();
+    await this.page.waitForSelector("#red-ui-workspace", { timeout: 15e3 });
+  }
+  async editNode(nodeId) {
+    await this.page.waitForFunction(
+      (id) => {
+        const r = globalThis.RED;
+        const node = r?.nodes?.node(id);
+        if (!node) return false;
+        return r.nodes.getType(node.type) !== null;
+      },
+      nodeId,
+      { timeout: 15e3 }
+    );
+    await this.page.evaluate((id) => {
+      const r = globalThis.RED;
+      r.editor.edit(r.nodes.node(id));
+    }, nodeId);
+    await this.page.waitForSelector(".red-ui-tray", { timeout: 1e4 });
+    await this.page.waitForTimeout(500);
+  }
+  async clickDone() {
+    await this.page.evaluate(() => {
+      globalThis.document.getElementById("node-dialog-ok").click();
+    });
+    await this.page.waitForSelector(".red-ui-tray", {
+      state: "hidden",
+      timeout: 5e3
+    });
+  }
+  async clickCancel() {
+    await this.page.evaluate(() => {
+      globalThis.document.getElementById("node-dialog-cancel").click();
+    });
+    await this.page.waitForSelector(".red-ui-tray", {
+      state: "hidden",
+      timeout: 5e3
+    });
+  }
+  field(label) {
+    return new NodeRedField(this.page, label);
+  }
+  expectNoPageErrors() {
+    if (this.errors.length > 0) {
+      throw new Error(
+        `Page errors detected:
+${this.errors.map((e) => `  - ${e}`).join("\n")}`
+      );
+    }
+  }
+  get tray() {
+    return this.page.locator(".red-ui-tray-body-wrapper");
+  }
+};
+var NodeRedField = class {
+  constructor(page, label) {
+    this.page = page;
+    this.label = label;
+    this.row = page.locator(`.form-row:has(:text("${label}"))`).first();
+  }
+  row;
+  get input() {
+    return this.row.locator("input").first();
+  }
+  async fill(value) {
+    await this.input.fill(value, { force: true });
+  }
+  async clear() {
+    await this.input.fill("", { force: true });
+  }
+  async getValue() {
+    return this.input.inputValue();
+  }
+  async getInputType() {
+    return this.input.getAttribute("type");
+  }
+  get toggleSlider() {
+    return this.row.locator(".nrg-toggle__slider");
+  }
+  async toggle() {
+    await this.toggleSlider.click();
+  }
+  get checkbox() {
+    return this.row.locator('input[type="checkbox"]');
+  }
+  get typedInputContainer() {
+    return this.row.locator(".red-ui-typedInput-container");
+  }
+  async getSelectedType() {
+    return this.typedInputContainer.locator("input").first().evaluate((el) => globalThis.$(el).typedInput("type"));
+  }
+  async getSelectedValue() {
+    return this.typedInputContainer.locator("input").first().evaluate(
+      (el) => globalThis.$(el).typedInput("value")
+    );
+  }
+  async openTypeMenu() {
+    await this.typedInputContainer.locator(".red-ui-typedInput-type-select").click();
+    const menu = this.page.locator(".red-ui-typedInput-options:visible").first();
+    await menu.waitFor({ state: "visible", timeout: 5e3 });
+    return menu;
+  }
+  async getTypeMenuValues() {
+    const menu = await this.openTypeMenu();
+    const values = await menu.locator("a").evaluateAll((els) => els.map((el) => el.getAttribute("value") ?? ""));
+    await this.page.keyboard.press("Escape");
+    return values;
+  }
+  async selectType(type) {
+    const menu = await this.openTypeMenu();
+    await menu.locator(`a[value="${type}"]`).click();
+  }
+  async openOptionMenu() {
+    await this.typedInputContainer.locator(".red-ui-typedInput-option-trigger").click();
+    const menu = this.page.locator(".red-ui-typedInput-options:visible").first();
+    await menu.waitFor({ state: "visible", timeout: 5e3 });
+    return menu;
+  }
+  async getOptionMenuLabels() {
+    const menu = await this.openOptionMenu();
+    const labels = await menu.locator("a").evaluateAll((els) => els.map((el) => el.textContent?.trim() ?? ""));
+    await this.page.keyboard.press("Escape");
+    return labels;
+  }
+  get select() {
+    return this.row.locator("select");
+  }
+  get editButton() {
+    return this.row.locator("a.red-ui-button:has(i.fa-pencil)");
+  }
+  get addButton() {
+    return this.row.locator("a.red-ui-button:has(i.fa-plus)");
+  }
+  async getSelectedOption() {
+    return this.select.inputValue();
+  }
+  async getSelectedOptionLabel() {
+    const value = await this.getSelectedOption();
+    return this.select.locator(`option[value="${value}"]`).textContent().then((t) => t?.trim() ?? "");
+  }
+  async getOptions() {
+    return this.select.locator("option").evaluateAll(
+      (els) => els.map((el) => el.textContent?.trim() ?? "").filter((t) => !t.startsWith("Add new ") && t !== "")
+    );
+  }
+  get editorWrapper() {
+    return this.row.locator(".editor-wrapper");
+  }
+  get expandButton() {
+    return this.row.locator(".expand-button");
+  }
+  get textarea() {
+    return this.row.locator("textarea");
+  }
+  get requiredIndicator() {
+    return this.row.locator(".nrg-required");
+  }
+  get errorMessage() {
+    return this.row.locator(".node-red-vue-input-error-message");
+  }
+  async expectError(containing) {
+    if (containing) {
+      await this.errorMessage.filter({ hasText: containing }).waitFor({ state: "visible", timeout: 5e3 });
+    } else {
+      await this.errorMessage.waitFor({ state: "visible", timeout: 5e3 });
+    }
+  }
+  async expectNoError() {
+    await this.errorMessage.waitFor({ state: "hidden", timeout: 5e3 });
+  }
+  async scrollIntoView() {
+    await this.row.scrollIntoViewIfNeeded();
+  }
+  async expectVisible() {
+    await this.row.waitFor({ state: "visible", timeout: 5e3 });
+  }
+  async expectHidden() {
+    await this.row.waitFor({ state: "hidden", timeout: 5e3 });
+  }
+};
+export {
+  NodeRedEditor,
+  NodeRedField,
+  NodeRedTestEnvironment,
+  defaultConfig,
+  setup,
+  teardown
+};