@bonsae/nrg 0.18.5 → 0.19.1

package/test/client/e2e/index.js

@@ -1,10 +1,10 @@
 // src/test/client/e2e/index.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 
 // src/test/client/e2e/environment.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 
 // src/vite/server/build.ts
 import { build as viteBuild } from "vite";
@@ -1177,10 +1177,10 @@ function generateHelpDoc(nodeClass, labels, t) {
     if (inputSection) lines.push(inputSection);
   }
   if (nodeClass.outputsSchema) {
-    const os2 = nodeClass.outputsSchema;
-    if (Array.isArray(os2)) {
+    const os3 = nodeClass.outputsSchema;
+    if (Array.isArray(os3)) {
       const portSections = [];
-      os2.forEach((schema, i) => {
+      os3.forEach((schema, i) => {
         const title = `${t.sections.port} ${i + 1}`;
         const portPropLabels = labels.outputs?.[i];
         const section = generateSchemaSection({
@@ -1199,9 +1199,9 @@ function generateHelpDoc(nodeClass, labels, t) {
 ${portSections.join("\n")}`
         );
       }
-    } else if (!("type" in os2 || "properties" in os2)) {
+    } else if (!("type" in os3 || "properties" in os3)) {
       const portSections = [];
-      for (const [portName, schema] of Object.entries(os2)) {
+      for (const [portName, schema] of Object.entries(os3)) {
         const portPropLabels = labels.outputs?.[portName];
         const section = generateSchemaSection({
           title: portName,
@@ -1223,7 +1223,7 @@ ${portSections.join("\n")}`
       const outputPropLabels = labels.outputs?.[0];
       const section = generateSchemaSection({
         title: t.sections.output,
-        schema: os2,
+        schema: os3,
         t,
         labels: outputPropLabels,
         includeDefault: false
@@ -1375,103 +1375,113 @@ function localesGenerator(options) {
   ];
   const frameworkLabels = {
     "en-US": {
-      configs: { name: "Name" },
+      configs: { name: "Name", returnProperty: "Return key" },
       toggles: {
         validateInput: "Validate Input",
         validateOutput: "Validate Output",
         errorPort: "Error Port",
         completePort: "Complete Port",
-        statusPort: "Status Port"
+        statusPort: "Status Port",
+        returnPropertyOverride: "Override return prop key"
       }
     },
     de: {
-      configs: { name: "Name" },
+      configs: { name: "Name", returnProperty: "R\xFCckgabe-Schl\xFCssel" },
       toggles: {
         validateInput: "Eingabe validieren",
         validateOutput: "Ausgabe validieren",
         errorPort: "Fehler-Port",
         completePort: "Abschluss-Port",
-        statusPort: "Status-Port"
+        statusPort: "Status-Port",
+        returnPropertyOverride: "R\xFCckgabe-Schl\xFCssel \xFCberschreiben"
       }
     },
     "es-ES": {
-      configs: { name: "Nombre" },
+      configs: { name: "Nombre", returnProperty: "Clave de retorno" },
       toggles: {
         validateInput: "Validar entrada",
         validateOutput: "Validar salida",
         errorPort: "Puerto de error",
         completePort: "Puerto de completado",
-        statusPort: "Puerto de estado"
+        statusPort: "Puerto de estado",
+        returnPropertyOverride: "Sobrescribir clave de retorno"
       }
     },
     fr: {
-      configs: { name: "Nom" },
+      configs: { name: "Nom", returnProperty: "Cl\xE9 de retour" },
       toggles: {
         validateInput: "Valider l'entr\xE9e",
         validateOutput: "Valider la sortie",
         errorPort: "Port d'erreur",
         completePort: "Port de compl\xE9tion",
-        statusPort: "Port de statut"
+        statusPort: "Port de statut",
+        returnPropertyOverride: "Remplacer la cl\xE9 de retour"
       }
     },
     ko: {
-      configs: { name: "\uC774\uB984" },
+      configs: { name: "\uC774\uB984", returnProperty: "\uBC18\uD658 \uD0A4" },
       toggles: {
         validateInput: "\uC785\uB825 \uAC80\uC99D",
         validateOutput: "\uCD9C\uB825 \uAC80\uC99D",
         errorPort: "\uC624\uB958 \uD3EC\uD2B8",
         completePort: "\uC644\uB8CC \uD3EC\uD2B8",
-        statusPort: "\uC0C1\uD0DC \uD3EC\uD2B8"
+        statusPort: "\uC0C1\uD0DC \uD3EC\uD2B8",
+        returnPropertyOverride: "\uBC18\uD658 \uD0A4 \uC7AC\uC815\uC758"
       }
     },
     "pt-BR": {
-      configs: { name: "Nome" },
+      configs: { name: "Nome", returnProperty: "Chave de retorno" },
       toggles: {
         validateInput: "Validar Entrada",
         validateOutput: "Validar Sa\xEDda",
         errorPort: "Porta de Erro",
         completePort: "Porta de Conclus\xE3o",
-        statusPort: "Porta de Status"
+        statusPort: "Porta de Status",
+        returnPropertyOverride: "Sobrescrever chave de retorno"
       }
     },
     ru: {
-      configs: { name: "\u0418\u043C\u044F" },
+      configs: { name: "\u0418\u043C\u044F", returnProperty: "\u041A\u043B\u044E\u0447 \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430" },
       toggles: {
         validateInput: "\u041F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0432\u0445\u043E\u0434",
         validateOutput: "\u041F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0432\u044B\u0445\u043E\u0434",
         errorPort: "\u041F\u043E\u0440\u0442 \u043E\u0448\u0438\u0431\u043A\u0438",
         completePort: "\u041F\u043E\u0440\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u0438\u044F",
-        statusPort: "\u041F\u043E\u0440\u0442 \u0441\u0442\u0430\u0442\u0443\u0441\u0430"
+        statusPort: "\u041F\u043E\u0440\u0442 \u0441\u0442\u0430\u0442\u0443\u0441\u0430",
+        returnPropertyOverride: "\u041F\u0435\u0440\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0438\u0442\u044C \u043A\u043B\u044E\u0447 \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430"
       }
     },
     ja: {
-      configs: { name: "\u540D\u524D" },
+      configs: { name: "\u540D\u524D", returnProperty: "\u623B\u308A\u30AD\u30FC" },
       toggles: {
         validateInput: "\u5165\u529B\u691C\u8A3C",
         validateOutput: "\u51FA\u529B\u691C\u8A3C",
         errorPort: "\u30A8\u30E9\u30FC\u30DD\u30FC\u30C8",
         completePort: "\u5B8C\u4E86\u30DD\u30FC\u30C8",
-        statusPort: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30DD\u30FC\u30C8"
+        statusPort: "\u30B9\u30C6\u30FC\u30BF\u30B9\u30DD\u30FC\u30C8",
+        returnPropertyOverride: "\u623B\u308A\u30AD\u30FC\u3092\u4E0A\u66F8\u304D"
       }
     },
     "zh-CN": {
-      configs: { name: "\u540D\u79F0" },
+      configs: { name: "\u540D\u79F0", returnProperty: "\u8FD4\u56DE\u952E" },
       toggles: {
         validateInput: "\u9A8C\u8BC1\u8F93\u5165",
         validateOutput: "\u9A8C\u8BC1\u8F93\u51FA",
         errorPort: "\u9519\u8BEF\u7AEF\u53E3",
         completePort: "\u5B8C\u6210\u7AEF\u53E3",
-        statusPort: "\u72B6\u6001\u7AEF\u53E3"
+        statusPort: "\u72B6\u6001\u7AEF\u53E3",
+        returnPropertyOverride: "\u8986\u76D6\u8FD4\u56DE\u952E"
       }
     },
     "zh-TW": {
-      configs: { name: "\u540D\u7A31" },
+      configs: { name: "\u540D\u7A31", returnProperty: "\u8FD4\u56DE\u9375" },
       toggles: {
         validateInput: "\u9A57\u8B49\u8F38\u5165",
         validateOutput: "\u9A57\u8B49\u8F38\u51FA",
         errorPort: "\u932F\u8AA4\u7AEF\u53E3",
         completePort: "\u5B8C\u6210\u7AEF\u53E3",
-        statusPort: "\u72C0\u614B\u7AEF\u53E3"
+        statusPort: "\u72C0\u614B\u7AEF\u53E3",
+        returnPropertyOverride: "\u8986\u84CB\u8FD4\u56DE\u9375"
       }
     }
   };
@@ -1994,17 +2004,8 @@ async function build2(clientBuildOptions, buildContext) {
   }
 }
 
-// src/vite/node-red-launcher.ts
-import { spawn, execSync } from "child_process";
-import getPort from "get-port";
-import detect from "detect-port";
-import { builtinModules as builtinModules2, createRequire as createRequire3 } from "module";
-import treeKill from "tree-kill";
-import fs10 from "fs";
-import os from "os";
-import path10 from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
-import { build as esbuild } from "esbuild";
+// src/vite/node-red-launcher/index.ts
+import fs12 from "fs";
 
 // src/vite/async-utils.ts
 function withTimeout(promise, ms, fallback) {
@@ -2041,203 +2042,376 @@ async function retry(fn, options = {}) {
   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"
-    });
+// src/vite/node-red-launcher/entry-point.ts
+import { exec } from "child_process";
+import { randomUUID } from "crypto";
+import { createRequire as createRequire3 } from "module";
+import fs10 from "fs";
+import os from "os";
+import path10 from "path";
+function getNodeRedCommand(version) {
+  return version ? `node-red@${version}` : "node-red";
+}
+function resolveNodeRedFromLocalNodeModules() {
+  try {
+    const require_ = createRequire3(path10.join(process.cwd(), "package.json"));
+    const pkgJsonPath = require_.resolve("node-red/package.json");
+    const pkgDir = path10.dirname(pkgJsonPath);
+    const pkg = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["node-red"];
+    if (!bin) return null;
+    const entry = path10.resolve(pkgDir, bin);
+    return fs10.existsSync(entry) ? entry : null;
+  } catch {
+    return null;
   }
-  get preferredPort() {
-    return this.options.runtime?.port ?? 1880;
+}
+async function resolveNodeRed(options) {
+  const { version, npxTimeoutMs = 3e5, logger: logger2 } = options;
+  if (version && !/^[\w.^~<>=*-]+$/.test(version)) {
+    throw new NodeRedStartError(
+      new Error(`Invalid node-red version "${version}"`)
+    );
   }
-  get restartDelay() {
-    return this.options.restartDelay ?? 1e3;
+  const nodeRedCommand = getNodeRedCommand(version);
+  logger2.info(`Resolving ${nodeRedCommand} entry point...`);
+  const hasExplicitVersion = version !== void 0 && version !== "latest";
+  if (!hasExplicitVersion) {
+    const localEntry = resolveNodeRedFromLocalNodeModules();
+    if (localEntry) {
+      logger2.info(`Resolved from local node_modules: ${localEntry}`);
+      return localEntry;
+    }
   }
-  get pid() {
-    return this.process?.pid ?? null;
+  logger2.info(
+    hasExplicitVersion ? `Using configured version (${version}), downloading via npx...` : `Not found locally, downloading via npx (this may take a while)...`
+  );
+  const resolverScript = path10.join(
+    os.tmpdir(),
+    `nrg-resolve-node-red-${process.pid}-${randomUUID()}.cjs`
+  );
+  fs10.writeFileSync(
+    resolverScript,
+    `const fs = require("fs");
+const path = require("path");
+const isWin = process.platform === "win32";
+const binName = isWin ? "node-red.cmd" : "node-red";
+const dirs = process.env.PATH.split(path.delimiter);
+for (const d of dirs) {
+  const f = path.join(d, binName);
+  if (fs.existsSync(f)) {
+    if (isWin) {
+      const nodeRedDir = path.resolve(d, "..", "node-red");
+      const pkg = JSON.parse(fs.readFileSync(path.join(nodeRedDir, "package.json"), "utf-8"));
+      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin["node-red"];
+      process.stdout.write(path.resolve(nodeRedDir, bin));
+    } else {
+      process.stdout.write(fs.realpathSync(f));
+    }
+    break;
   }
-  get nodeRedCommand() {
-    const version = this.options.runtime?.version;
-    if (version === "latest") {
-      return "node-red@latest";
+}`
+  );
+  try {
+    const stdout = await new Promise((resolve, reject) => {
+      exec(
+        `npx --yes -p ${nodeRedCommand} node "${resolverScript}"`,
+        { timeout: npxTimeoutMs },
+        (error, stdout2) => {
+          if (error) reject(error);
+          else resolve(stdout2);
+        }
+      );
+    });
+    const entryPoint = stdout.trim();
+    if (!entryPoint || !fs10.existsSync(entryPoint)) {
+      throw new NodeRedStartError(
+        new Error(
+          `Could not resolve node-red entry point: ${entryPoint || "(empty)"}`
+        )
+      );
     }
-    if (version) {
-      return `node-red@${version}`;
+    logger2.info(`Resolved via npx: ${entryPoint}`);
+    return entryPoint;
+  } finally {
+    try {
+      fs10.unlinkSync(resolverScript);
+    } catch {
     }
-    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;
+}
+
+// src/vite/node-red-launcher/settings.ts
+import { builtinModules as builtinModules2 } from "module";
+import fs11 from "fs";
+import os2 from "os";
+import path11 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { build as esbuild } from "esbuild";
+function findUserRuntimeSettingsFilepath(settingsFilepath, logger2) {
+  if (settingsFilepath) {
+    const resolved2 = path11.resolve(settingsFilepath);
+    if (fs11.existsSync(resolved2)) {
+      return resolved2;
     }
+    logger2.warn(`Settings file not found: ${settingsFilepath}`);
     return null;
   }
-  async compileRuntimeSettingsFile(runtimeSettingsFilepath) {
-    const compiledRuntimeSettingsFilepath = path10.join(
-      os.tmpdir(),
-      `node-red.settings.${process.pid}.cjs`
+  const resolved = path11.resolve("node-red.settings.ts");
+  if (fs11.existsSync(resolved)) {
+    return resolved;
+  }
+  return null;
+}
+async function compileRuntimeSettingsFile(runtimeSettingsFilepath, port) {
+  const compiledRuntimeSettingsFilepath = path11.join(
+    os2.tmpdir(),
+    `node-red.settings.${process.pid}-${port}.cjs`
+  );
+  const nodeBuiltins2 = [
+    ...builtinModules2,
+    ...builtinModules2.map((m) => `node:${m}`)
+  ];
+  const settingsDir = path11.dirname(runtimeSettingsFilepath).split(path11.sep).join("/");
+  const settingsFile = runtimeSettingsFilepath.split(path11.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(pathToFileURL3(settingsFile).href)
+    },
+    external: [...nodeBuiltins2, "node-red", "@node-red/*"]
+  });
+  return compiledRuntimeSettingsFilepath;
+}
+async function generateRuntimeSettings(options) {
+  const { outDir, port, settingsFilepath, logger: logger2 } = options;
+  const tempFiles = [];
+  const userRuntimeSettingsFilepath = findUserRuntimeSettingsFilepath(
+    settingsFilepath,
+    logger2
+  );
+  let compiledRuntimeSettingsFilepath = null;
+  if (userRuntimeSettingsFilepath) {
+    compiledRuntimeSettingsFilepath = await compileRuntimeSettingsFile(
+      userRuntimeSettingsFilepath,
+      port
     );
-    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(pathToFileURL3(settingsFile).href)
-      },
-      external: [...nodeBuiltins2, "node-red", "@node-red/*"]
-    });
-    this.compiledRuntimeSettingsFilepath = compiledRuntimeSettingsFilepath;
-    return compiledRuntimeSettingsFilepath;
-  }
-  async generateRuntimeSettingsFile() {
-    const userRuntimeSettingsFilepath = this.findRuntimeSettingsFilepath();
-    let compiledRuntimeSettingsFilepath = null;
-    if (userRuntimeSettingsFilepath) {
-      compiledRuntimeSettingsFilepath = await this.compileRuntimeSettingsFile(
-        userRuntimeSettingsFilepath
-      );
-    }
-    const outDir = path10.resolve(this.outDir).split(path10.sep).join("/");
-    const cwd = process.cwd().split(path10.sep).join("/");
-    const userDir = path10.resolve(cwd, ".node-red").split(path10.sep).join("/");
-    const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
-const compiledRuntimeSettings = require("${compiledRuntimeSettingsFilepath.split(path10.sep).join("/")}");
+    tempFiles.push(compiledRuntimeSettingsFilepath);
+  }
+  const normalizedOutDir = path11.resolve(outDir).split(path11.sep).join("/");
+  const cwd = process.cwd().split(path11.sep).join("/");
+  const userDir = path11.resolve(cwd, ".node-red").split(path11.sep).join("/");
+  const userDirLiteral = JSON.stringify(userDir);
+  const outDirLiteral = JSON.stringify(normalizedOutDir);
+  const finalRuntimeSettingsFile = compiledRuntimeSettingsFilepath ? `
+const compiledRuntimeSettings = require(${JSON.stringify(
+    compiledRuntimeSettingsFilepath.split(path11.sep).join("/")
+  )});
 const settings = compiledRuntimeSettings.default || compiledRuntimeSettings;
-settings.uiPort = ${this.port};
+settings.uiPort = ${port};
 if(!settings.userDir){
-    settings.userDir = "${userDir}";
+    settings.userDir = ${userDirLiteral};
 }
 settings.nodesDir = settings.nodesDir || [];
-if (!settings.nodesDir.includes("${outDir}")) {
-  settings.nodesDir.push("${outDir}");
+if (!settings.nodesDir.includes(${outDirLiteral})) {
+  settings.nodesDir.push(${outDirLiteral});
 }
 if(!settings.flowFile){
   settings.flowFile = "flows.json";
 }
+// the welcome tour overlay intercepts pointer events \u2014 fatal for e2e and
+// noise for dev; explicit user settings still win
+settings.editorTheme = settings.editorTheme || {};
+if (settings.editorTheme.tours === undefined) {
+  settings.editorTheme.tours = false;
+}
 module.exports = settings;
 ` : `
 const settings = {
-  uiPort: ${this.port},
-  userDir: "${userDir}",
+  uiPort: ${port},
+  userDir: ${userDirLiteral},
   flowFile: "flows.json",
-  nodesDir: ["${outDir}"],
+  nodesDir: [${outDirLiteral}],
+  // the welcome tour overlay intercepts pointer events \u2014 fatal for e2e
+  editorTheme: { tours: false },
 };
 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;
-  }
-  resolveFromLocalNodeModules() {
-    try {
-      const require_ = createRequire3(path10.join(process.cwd(), "package.json"));
-      const pkgJsonPath = require_.resolve("node-red/package.json");
-      const pkgDir = path10.dirname(pkgJsonPath);
-      const pkg = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
-      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["node-red"];
-      if (!bin) return null;
-      const entry = path10.resolve(pkgDir, bin);
-      return fs10.existsSync(entry) ? entry : null;
-    } catch {
-      return null;
+  const finalRuntimeSettingsFilepath = path11.join(
+    os2.tmpdir(),
+    `node-red-settings-final-${process.pid}-${port}.cjs`
+  );
+  fs11.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
+  tempFiles.push(finalRuntimeSettingsFilepath);
+  return { filepath: finalRuntimeSettingsFilepath, tempFiles };
+}
+
+// src/vite/node-red-launcher/process.ts
+import { spawn } from "child_process";
+import detect from "detect-port";
+import getPort from "get-port";
+import treeKill from "tree-kill";
+var READY_MARKERS = ["Started flows", "Server now running"];
+function start(options) {
+  const { entryPoint, settingsPath, args, onLine } = options;
+  const child = spawn(
+    process.execPath,
+    [entryPoint, "-s", settingsPath, ...args],
+    {
+      stdio: ["ignore", "pipe", "pipe"]
     }
-  }
-  resolveNodeRedEntryPoint() {
-    this.logger.info(`Resolving ${this.nodeRedCommand} entry point...`);
-    const hasExplicitVersion = this.options.runtime?.version !== void 0 && this.options.runtime.version !== "latest";
-    if (!hasExplicitVersion) {
-      const localEntry = this.resolveFromLocalNodeModules();
-      if (localEntry) {
-        this.logger.info(`Resolved from local node_modules: ${localEntry}`);
-        return localEntry;
+  );
+  let isReady = false;
+  let resolveReady;
+  let rejectReady;
+  const ready = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+  const emitLine = (rawLine, source) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (!line) return;
+    onLine(line, source, isReady);
+    if (source === "stdout" && READY_MARKERS.some((marker) => line.includes(marker))) {
+      isReady = true;
+      resolveReady();
+    }
+  };
+  const remainders = { stdout: "", stderr: "" };
+  const handleData = (data, source) => {
+    const lines = (remainders[source] + data.toString()).split("\n");
+    remainders[source] = lines.pop() ?? "";
+    for (const line of lines) {
+      emitLine(line, source);
+    }
+  };
+  const flushRemainders = () => {
+    for (const source of ["stdout", "stderr"]) {
+      const rest = remainders[source];
+      remainders[source] = "";
+      if (rest) {
+        emitLine(rest, source);
       }
     }
-    this.logger.info(
-      hasExplicitVersion ? `Using configured version (${this.options.runtime.version}), downloading via npx...` : `Not found locally, downloading via npx (this may take a while)...`
-    );
-    const resolverScript = path10.join(
-      os.tmpdir(),
-      `nrg-resolve-node-red-${process.pid}.cjs`
-    );
-    fs10.writeFileSync(
-      resolverScript,
-      `const fs = require("fs");
-const path = require("path");
-const isWin = process.platform === "win32";
-const binName = isWin ? "node-red.cmd" : "node-red";
-const dirs = process.env.PATH.split(path.delimiter);
-for (const d of dirs) {
-  const f = path.join(d, binName);
-  if (fs.existsSync(f)) {
-    if (isWin) {
-      const nodeRedDir = path.resolve(d, "..", "node-red");
-      const pkg = JSON.parse(fs.readFileSync(path.join(nodeRedDir, "package.json"), "utf-8"));
-      const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin["node-red"];
-      process.stdout.write(path.resolve(nodeRedDir, bin));
-    } else {
-      process.stdout.write(fs.realpathSync(f));
+  };
+  child.stdout?.on("data", (data) => handleData(data, "stdout"));
+  child.stderr?.on("data", (data) => handleData(data, "stderr"));
+  child.on("error", (error) => {
+    rejectReady(new NodeRedStartError(error));
+  });
+  child.on("exit", (code) => {
+    flushRemainders();
+    if (!isReady && code !== 0 && code !== null) {
+      rejectReady(
+        new NodeRedStartError(new Error(`Process exited with code ${code}`))
+      );
+      return;
     }
-    break;
+    resolveReady();
+  });
+  return { child, ready };
+}
+function kill(pid) {
+  return new Promise((resolve) => {
+    treeKill(pid, "SIGKILL", () => resolve());
+  });
+}
+async function stop(options) {
+  const { child, pid, gracefulTimeoutMs = 1e4, logger: logger2 } = options;
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return;
   }
-}`
-    );
-    try {
-      const entryPoint = execSync(
-        `npx --yes -p ${this.nodeRedCommand} -c "node ${resolverScript}"`,
-        { encoding: "utf-8", timeout: 3e5 }
-      ).trim();
-      if (!entryPoint || !fs10.existsSync(entryPoint)) {
-        throw new NodeRedStartError(
-          new Error(
-            `Could not resolve node-red entry point: ${entryPoint || "(empty)"}`
-          )
-        );
-      }
-      this.logger.info(`Resolved via npx: ${entryPoint}`);
-      return entryPoint;
-    } finally {
-      try {
-        fs10.unlinkSync(resolverScript);
-      } catch {
+  const exited = new Promise((resolve) => {
+    child.once("exit", () => resolve());
+    treeKill(pid, "SIGTERM", (error) => {
+      if (error) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+          resolve();
+        }
       }
+    });
+  });
+  try {
+    await withTimeout(exited, gracefulTimeoutMs);
+  } catch {
+    logger2.warn("Graceful shutdown timed out, force killing...");
+    await kill(pid);
+  }
+}
+async function acquirePort(options) {
+  const { preferredPort, retryDelay = 2e3, logger: logger2 } = options;
+  const available = await detect(preferredPort);
+  if (available === preferredPort) {
+    return preferredPort;
+  }
+  logger2.warn(`Port ${preferredPort} is still in use, waiting...`);
+  await new Promise((resolve) => setTimeout(resolve, retryDelay));
+  const retryAvailable = await detect(preferredPort);
+  if (retryAvailable === preferredPort) {
+    return preferredPort;
+  }
+  const fallbackPort = await getPort({ port: preferredPort });
+  logger2.warn(
+    `Port ${preferredPort} still occupied, using port ${fallbackPort}`
+  );
+  return fallbackPort;
+}
+async function waitForPortRelease(port, options = {}) {
+  const { attempts = 10, delay = 300 } = options;
+  const checkPortUsage = async () => {
+    const availablePort = await detect(port);
+    if (availablePort !== port) {
+      throw new Error("Port still in use");
     }
+  };
+  try {
+    await retry(checkPortUsage, { attempts, delay });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/vite/node-red-launcher/index.ts
+var NodeRedLauncher = class {
+  operationQueue = Promise.resolve();
+  process = null;
+  unwatchExit = null;
+  nodeRedEntryPoint = null;
+  tempFiles = [];
+  bufferedLogs = [];
+  port = null;
+  outDir;
+  options;
+  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?.child.pid ?? null;
+  }
+  get nodeRedCommand() {
+    return getNodeRedCommand(this.options.runtime?.version);
   }
   log(line) {
     if (line.includes("Server now running at")) {
@@ -2245,150 +2419,121 @@ for (const d of dirs) {
     }
     this.logger.raw(line);
   }
-  async start() {
-    const available = await detect(this.preferredPort);
-    if (available === this.preferredPort) {
-      this.port = this.preferredPort;
+  handleProcessLine(line, source, ready) {
+    if (!ready) {
+      this.bufferedLogs.push(line);
+    } else if (source === "stderr") {
+      this.logger.error(line);
     } else {
+      this.log(line);
+    }
+  }
+  async killProcess() {
+    if (!this.process) return;
+    this.stopWatchingExit();
+    const pid = this.process.child.pid;
+    if (pid) {
+      await kill(pid);
+    }
+    this.process = null;
+  }
+  watchForUnexpectedExit(managed) {
+    const onExit = (code, signal) => {
+      this.unwatchExit = null;
+      this.process = null;
       this.logger.warn(
-        `Port ${this.preferredPort} is still in use, waiting...`
+        `Node-RED exited unexpectedly (${signal ?? `code ${code}`})`
       );
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const retryAvailable = await detect(this.preferredPort);
-      if (retryAvailable === this.preferredPort) {
-        this.port = this.preferredPort;
-      } else {
-        this.logger.warn(
-          `Port ${this.preferredPort} still occupied, using port ${retryAvailable}`
-        );
-        this.port = await getPort({ port: this.preferredPort });
-      }
-    }
-    const nodeRedEntryPoint = this.resolveNodeRedEntryPoint();
-    const startProcess = () => {
-      return new Promise(async (resolve, reject) => {
-        try {
-          const settingsPath = await this.generateRuntimeSettingsFile();
-          const args = this.options.args ?? [];
-          this.bufferedLogs = [];
-          this.isReady = false;
-          this.process = spawn(
-            process.execPath,
-            [nodeRedEntryPoint, "-s", settingsPath, ...args],
-            {
-              stdio: ["ignore", "pipe", "pipe"]
-            }
-          );
-          this.process.stdout?.on("data", (data) => {
-            const lines = data.toString().split("\n").filter(Boolean);
-            for (const line of lines) {
-              if (this.isReady) {
-                this.log(line);
-              } else {
-                this.bufferedLogs.push(line);
-              }
-              if (line.includes("Started flows") || line.includes("Server now running")) {
-                this.isReady = true;
-                resolve(void 0);
-              }
-            }
-          });
-          this.process.stderr?.on("data", (data) => {
-            const lines = data.toString().split("\n").filter(Boolean);
-            for (const line of lines) {
-              if (this.isReady) {
-                this.logger.error(`${line}`);
-              } else {
-                this.bufferedLogs.push(line);
-              }
-            }
-          });
-          this.process.on("error", (error) => {
-            reject(new NodeRedStartError(error));
-          });
-          this.process.on("exit", (code) => {
-            if (!this.isReady && code !== 0 && code !== null) {
-              reject(
-                new NodeRedStartError(
-                  new Error(`Process exited with code ${code}`)
-                )
-              );
-            }
-            resolve(void 0);
-          });
-        } catch (error) {
-          reject(new NodeRedStartError(error));
-        }
-      });
     };
+    managed.child.once("exit", onExit);
+    this.unwatchExit = () => managed.child.off("exit", onExit);
+  }
+  stopWatchingExit() {
+    this.unwatchExit?.();
+    this.unwatchExit = null;
+  }
+  // start/stop interleaving (e.g. SIGINT while Node-RED is booting) would
+  // race on process/port state and could leak a spawned process, so all
+  // lifecycle operations run strictly one at a time
+  enqueue(operation) {
+    const result = this.operationQueue.then(operation, operation);
+    this.operationQueue = result.catch(() => {
+    });
+    return result;
+  }
+  async start() {
+    return this.enqueue(() => this.doStart());
+  }
+  async stop(skipPortUsageCheck = false) {
+    return this.enqueue(() => this.doStop(skipPortUsageCheck));
+  }
+  async doStart() {
     try {
+      this.port = await acquirePort({
+        preferredPort: this.preferredPort,
+        logger: this.logger
+      });
+      if (!this.nodeRedEntryPoint || !fs12.existsSync(this.nodeRedEntryPoint)) {
+        this.nodeRedEntryPoint = await resolveNodeRed({
+          version: this.options.runtime?.version,
+          logger: this.logger
+        });
+      }
+      const nodeRedEntryPoint = this.nodeRedEntryPoint;
+      const settings = await generateRuntimeSettings({
+        outDir: this.outDir,
+        port: this.port,
+        settingsFilepath: this.options.runtime?.settingsFilepath,
+        logger: this.logger
+      });
+      for (const file of settings.tempFiles) {
+        if (!this.tempFiles.includes(file)) {
+          this.tempFiles.push(file);
+        }
+      }
+      const startProcess = async () => {
+        await this.killProcess();
+        this.bufferedLogs = [];
+        this.process = start({
+          entryPoint: nodeRedEntryPoint,
+          settingsPath: settings.filepath,
+          args: this.options.args ?? [],
+          onLine: (line, source, ready) => this.handleProcessLine(line, source, ready)
+        });
+        await this.process.ready;
+      };
       await retry(startProcess, { attempts: 3, delay: 100 });
+      this.watchForUnexpectedExit(this.process);
       return this.port;
     } catch (error) {
-      if (this.process) {
-        const pid = this.process.pid;
-        if (pid) {
-          treeKill(pid, "SIGKILL");
-        }
-        this.process = null;
-      }
-      throw new NodeRedStartError(error);
+      await this.killProcess();
+      throw error instanceof NodeRedStartError ? error : new NodeRedStartError(error);
     }
   }
-  async stop(skipPortUsageCheck = false) {
+  async doStop(skipPortUsageCheck) {
     if (!this.process) return;
-    const pid = this.process.pid;
+    this.stopWatchingExit();
+    const pid = this.process.child.pid;
     const currentPort = this.port;
     if (!pid) {
       this.process = null;
+      this.port = null;
       return;
     }
-    const stopProcess = new Promise((resolve) => {
-      this.process.once("exit", () => {
-        this.process = null;
-        resolve(void 0);
-      });
-      treeKill(pid, "SIGTERM", (error) => {
-        if (error) {
-          try {
-            process.kill(pid, "SIGTERM");
-          } catch {
-            this.process = null;
-            resolve(void 0);
-          }
-        }
-      });
+    await stop({
+      child: this.process.child,
+      pid,
+      logger: this.logger
     });
-    try {
-      await withTimeout(stopProcess, 1e4);
-    } catch {
-      this.logger.warn("Graceful shutdown timed out, force killing...");
-      await new Promise((resolve) => {
-        treeKill(pid, "SIGKILL", () => {
-          this.process = null;
-          resolve(void 0);
-        });
-      });
-    }
+    this.process = null;
     if (!skipPortUsageCheck && currentPort) {
-      const checkPortUsage = async () => {
-        const availablePort = await detect(currentPort);
-        if (availablePort !== currentPort) {
-          throw new Error("Port still in use");
-        }
-      };
-      try {
-        await retry(checkPortUsage, { attempts: 10, delay: 300 });
-      } catch {
+      const released = await waitForPortRelease(currentPort);
+      if (!released) {
         this.logger.warn(
           `Port ${currentPort} still in use after stop. Force killing...`
         );
-        if (pid) {
-          await new Promise((resolve) => {
-            treeKill(pid, "SIGKILL", () => resolve());
-          });
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-        }
+        await kill(pid);
+        await waitForPortRelease(currentPort);
       }
     }
     this.port = null;
@@ -2400,10 +2545,13 @@ for (const d of dirs) {
     this.bufferedLogs = [];
   }
   cleanup() {
-    if (this.compiledRuntimeSettingsFilepath && fs10.existsSync(this.compiledRuntimeSettingsFilepath)) {
-      fs10.unlinkSync(this.compiledRuntimeSettingsFilepath);
-      this.compiledRuntimeSettingsFilepath = null;
+    for (const file of this.tempFiles) {
+      try {
+        fs12.unlinkSync(file);
+      } catch {
+      }
     }
+    this.tempFiles = [];
   }
 };
 
@@ -2419,10 +2567,10 @@ var NodeRedTestEnvironment = class {
   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.projectDir = path12.resolve(options.projectDir ?? process.cwd());
+    this.outDir = path12.join(this.projectDir, "dist-e2e");
+    this.nodeRedDir = path12.join(this.projectDir, ".node-red");
+    this.installedPkgDir = path12.join(
       this.nodeRedDir,
       "node_modules",
       options.packageName
@@ -2434,15 +2582,15 @@ var NodeRedTestEnvironment = class {
   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 });
+    if (fs13.existsSync(this.outDir)) fs13.rmSync(this.outDir, { recursive: true });
+    fs13.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"),
+      srcDir: path12.join(this.projectDir, "src/server"),
       entry: "index.ts",
       format: "esm",
       bundled: [],
@@ -2452,7 +2600,7 @@ var NodeRedTestEnvironment = class {
     };
     await build(serverOpts, buildContext);
     const clientOpts = {
-      srcDir: path11.join(this.projectDir, "src/client"),
+      srcDir: path12.join(this.projectDir, "src/client"),
       entry: "index.ts",
       name: this.options.clientName ?? "NodeRedNodes",
       format: "es",
@@ -2461,18 +2609,18 @@ var NodeRedTestEnvironment = class {
       ...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"),
+    fs13.mkdirSync(this.installedPkgDir, { recursive: true });
+    fs13.cpSync(this.outDir, this.installedPkgDir, { recursive: true });
+    fs13.mkdirSync(this.nodeRedDir, { recursive: true });
+    fs13.writeFileSync(
+      path12.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(
+      launcherOpts.runtime.settingsFilepath = path12.resolve(
         this.projectDir,
         this.options.settingsFile
       );
@@ -2507,9 +2655,9 @@ var NodeRedTestEnvironment = class {
       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 });
+    if (fs13.existsSync(this.outDir)) fs13.rmSync(this.outDir, { recursive: true });
+    if (fs13.existsSync(this.nodeRedDir)) {
+      fs13.rmSync(this.nodeRedDir, { recursive: true });
     }
     this.port = null;
   }
@@ -2524,7 +2672,7 @@ var defaultConfig = {
 var _env = null;
 async function setup(options) {
   const packageName = JSON.parse(
-    fs12.readFileSync(path12.join(process.cwd(), "package.json"), "utf-8")
+    fs14.readFileSync(path13.join(process.cwd(), "package.json"), "utf-8")
   ).name;
   _env = new NodeRedTestEnvironment({
     packageName,
@@ -2553,8 +2701,8 @@ var NodeRedEditor = class {
   errors = [];
   screenshotDir;
   async screenshot(name) {
-    fs12.mkdirSync(this.screenshotDir, { recursive: true });
-    const filePath = path12.join(this.screenshotDir, `${name}.png`);
+    fs14.mkdirSync(this.screenshotDir, { recursive: true });
+    const filePath = path13.join(this.screenshotDir, `${name}.png`);
     await this.page.screenshot({ path: filePath, fullPage: true });
     return filePath;
   }
@@ -2605,31 +2753,159 @@ var NodeRedEditor = class {
     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
-    });
+    await this.#closeTray("node-dialog-ok");
   }
   async clickCancel() {
-    await this.page.evaluate(() => {
-      globalThis.document.getElementById("node-dialog-cancel").click();
-    });
-    await this.page.waitForSelector(".red-ui-tray", {
-      state: "hidden",
-      timeout: 5e3
-    });
+    await this.#closeTray("node-dialog-cancel");
+  }
+  // Waits for the tray COUNT to drop rather than for all trays to be hidden,
+  // so a leftover tray from an earlier (failed) test can't poison the wait.
+  async #closeTray(buttonId) {
+    const before = await this.page.locator(".red-ui-tray").count();
+    await this.page.evaluate((id) => {
+      globalThis.document.getElementById(id).click();
+    }, buttonId);
+    await this.page.waitForFunction(
+      (count) => document.querySelectorAll(".red-ui-tray").length < count,
+      before,
+      { timeout: 5e3 }
+    );
+  }
+  /**
+   * Best-effort close of every open tray — call from afterEach so a failed
+   * test never leaves a tray open for the next one.
+   */
+  async closeAllTrays() {
+    for (let attempt = 0; attempt < 5; attempt++) {
+      const count = await this.page.locator(".red-ui-tray").count();
+      if (count === 0) return;
+      const cancel = this.page.locator("#node-config-dialog-cancel, #node-dialog-cancel").last();
+      if (await cancel.count() > 0) {
+        await cancel.click({ force: true }).catch(() => {
+        });
+      } else {
+        await this.page.keyboard.press("Escape");
+      }
+      await this.page.waitForTimeout(400);
+    }
+  }
+  /**
+   * Closes the config-node tray (stacked above the node tray) with its own
+   * Done button. The node tray underneath stays open — use clickDone() for it.
+   */
+  async clickConfigDone() {
+    await this.page.click("#node-config-dialog-ok");
+    await this.page.locator("#node-config-dialog-ok").waitFor({ state: "hidden", timeout: 5e3 });
+    await this.page.waitForTimeout(300);
+  }
+  async clickConfigCancel() {
+    await this.page.click("#node-config-dialog-cancel");
+    await this.page.locator("#node-config-dialog-cancel").waitFor({ state: "hidden", timeout: 5e3 });
+    await this.page.waitForTimeout(300);
   }
   field(label) {
     return new NodeRedField(this.page, label);
   }
+  /**
+   * Returns a JSON-safe snapshot of a node in the editor's model — use it to
+   * assert values persisted after clickDone(). Functions, internals
+   * (underscore-prefixed keys like `_def`), config `users` back-references,
+   * and any circular references are stripped.
+   */
+  async getNode(nodeId) {
+    return this.page.evaluate((id) => {
+      const r = globalThis.RED;
+      const node = r?.nodes?.node(id);
+      if (!node) return null;
+      const seen = /* @__PURE__ */ new WeakSet();
+      return JSON.parse(
+        JSON.stringify(node, (key, value) => {
+          if (typeof value === "function") return void 0;
+          if (key.startsWith("_") || key === "users") return void 0;
+          if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) return void 0;
+            seen.add(value);
+          }
+          return value;
+        })
+      );
+    }, nodeId);
+  }
+  /**
+   * Clicks the editor's Deploy button and waits until the workspace is clean.
+   * Flows with invalid or unused nodes trigger a confirmation dialog — it is
+   * confirmed automatically.
+   */
+  async clickDeploy() {
+    await this.page.click("#red-ui-header-button-deploy");
+    const confirm = this.page.locator(".red-ui-notification button.primary").first();
+    const confirmationShown = await confirm.waitFor({ state: "visible", timeout: 2e3 }).then(() => true).catch(() => false);
+    if (confirmationShown) await confirm.click();
+    await this.page.waitForFunction(
+      () => {
+        const r = globalThis.RED;
+        return r?.nodes?.dirty?.() === false;
+      },
+      { timeout: 15e3 }
+    );
+  }
+  /** Fetches the currently deployed flow from the runtime (GET /flows). */
+  async getDeployedFlow() {
+    const res = await fetch(`http://localhost:${this.port}/flows`);
+    if (!res.ok) {
+      throw new Error(
+        `Failed to fetch flows: ${res.status} ${await res.text()}`
+      );
+    }
+    return res.json();
+  }
+  /** Counts the output ports rendered for a node on the canvas. */
+  async getNodePortCount(nodeId) {
+    const group = await this.#nodeGroup(nodeId);
+    return group.locator(".red-ui-flow-port-output").count();
+  }
+  /** Returns the node's label text as rendered on the canvas. */
+  async getNodeLabel(nodeId) {
+    const group = await this.#nodeGroup(nodeId);
+    const label = group.locator(".red-ui-flow-node-label").first();
+    return (await label.textContent() ?? "").trim();
+  }
+  /** Returns the status text rendered under a node, or "" when none is set. */
+  async getNodeStatus(nodeId) {
+    const group = await this.#nodeGroup(nodeId);
+    const status = group.locator(".red-ui-flow-node-status-label").first();
+    if (await status.count() === 0) return "";
+    return (await status.textContent() ?? "").trim();
+  }
+  async #nodeGroup(nodeId) {
+    await this.page.waitForFunction(
+      (id) => {
+        const groups = Array.from(
+          document.querySelectorAll(".red-ui-flow-node-group")
+        );
+        return groups.some((el) => el.__data__?.id === id);
+      },
+      nodeId,
+      { timeout: 1e4 }
+    );
+    const index = await this.page.evaluate((id) => {
+      const groups = Array.from(
+        document.querySelectorAll(".red-ui-flow-node-group")
+      );
+      return groups.findIndex((el) => el.__data__?.id === id);
+    }, nodeId);
+    return this.page.locator(".red-ui-flow-node-group").nth(index);
+  }
+  /**
+   * Asserts no uncaught page errors occurred, then clears the collected list
+   * so each test only fails for its own errors — call it from afterEach.
+   */
   expectNoPageErrors() {
-    if (this.errors.length > 0) {
+    const errors = this.errors.splice(0);
+    if (errors.length > 0) {
       throw new Error(
         `Page errors detected:
-${this.errors.map((e) => `  - ${e}`).join("\n")}`
+${errors.map((e) => `  - ${e}`).join("\n")}`
       );
     }
   }
@@ -2641,7 +2917,7 @@ var NodeRedField = class {
   constructor(page, label) {
     this.page = page;
     this.label = label;
-    this.row = page.locator(`.form-row:has(:text("${label}"))`).first();
+    this.row = page.locator(".red-ui-tray").last().locator(`.form-row:has(:text("${label}"))`).first();
   }
   row;
   get input() {
@@ -2716,6 +2992,18 @@ var NodeRedField = class {
   get addButton() {
     return this.row.locator("a.red-ui-button:has(i.fa-plus)");
   }
+  /** Clicks the + button of a config field and waits for the config tray. */
+  async openAddConfig() {
+    await this.addButton.click();
+    await this.page.locator("#node-config-dialog-ok").waitFor({ state: "visible", timeout: 1e4 });
+    await this.page.waitForTimeout(500);
+  }
+  /** Clicks the pencil button of a config field and waits for the config tray. */
+  async openEditConfig() {
+    await this.editButton.click();
+    await this.page.locator("#node-config-dialog-ok").waitFor({ state: "visible", timeout: 1e4 });
+    await this.page.waitForTimeout(500);
+  }
   async getSelectedOption() {
     return this.select.inputValue();
   }
@@ -2731,6 +3019,56 @@ var NodeRedField = class {
   get editorWrapper() {
     return this.row.locator(".editor-wrapper");
   }
+  /** Reads the value of the field's code editor (Monaco, ACE fallback). */
+  async getEditorValue() {
+    return this.editorWrapper.evaluate((el) => {
+      const w = globalThis;
+      const editors = w.monaco?.editor?.getEditors?.() ?? [];
+      const monacoEditor = editors.find(
+        (e) => el.contains(e.getContainerDomNode())
+      );
+      if (monacoEditor) return monacoEditor.getValue();
+      const aceEl = el.querySelector(".ace_editor");
+      if (aceEl && w.ace) return w.ace.edit(aceEl).getValue();
+      throw new Error("No code editor instance found in this field");
+    });
+  }
+  /** Sets the value of the field's code editor (Monaco, ACE fallback). */
+  async setEditorValue(value) {
+    await this.editorWrapper.evaluate((el, newValue) => {
+      const w = globalThis;
+      const editors = w.monaco?.editor?.getEditors?.() ?? [];
+      const monacoEditor = editors.find(
+        (e) => el.contains(e.getContainerDomNode())
+      );
+      if (monacoEditor) {
+        monacoEditor.setValue(newValue);
+        return;
+      }
+      const aceEl = el.querySelector(".ace_editor");
+      if (aceEl && w.ace) {
+        w.ace.edit(aceEl).setValue(newValue, 1);
+        return;
+      }
+      throw new Error("No code editor instance found in this field");
+    }, value);
+  }
+  /**
+   * Types into the field and returns the labels of the autocomplete
+   * suggestions that appear (TypedInput types with an `autoComplete` source).
+   */
+  async getAutoCompleteSuggestions(prefix) {
+    const input = this.row.locator("input:visible").first();
+    await input.fill("", { force: true });
+    await input.pressSequentially(prefix, { delay: 30 });
+    const menu = this.page.locator(".red-ui-autoComplete-container:visible").first();
+    await menu.waitFor({ state: "visible", timeout: 5e3 });
+    const labels = await menu.locator("li").evaluateAll(
+      (els) => els.map((el) => el.textContent?.trim() ?? "").filter(Boolean)
+    );
+    await this.page.keyboard.press("Escape");
+    return labels;
+  }
   get expandButton() {
     return this.row.locator(".expand-button");
   }