@bonsae/nrg 0.21.1 → 0.22.0

package/test/client/e2e/index.js

@@ -1,10 +1,10 @@
 // src/test/client/e2e/index.ts
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 
 // src/test/client/e2e/environment.ts
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 
 // src/vite/server/build.ts
 import { build as viteBuild } from "vite";
@@ -115,6 +115,26 @@ import dts from "vite-plugin-dts";
 import fs from "fs";
 import path from "path";
 import ts from "typescript";
+var RUNTIME_TYPE_REWRITES = {
+  "@bonsae/nrg/server": "@bonsae/nrg-runtime/server",
+  "@bonsae/nrg/client": "@bonsae/nrg-runtime/client"
+};
+function rewriteRuntimeTypeImports(outDir, entryNames) {
+  for (const name of entryNames) {
+    const dtsPath = path.join(outDir, `${name}.d.ts`);
+    if (!fs.existsSync(dtsPath)) continue;
+    const original = fs.readFileSync(dtsPath, "utf-8");
+    let rewritten = original;
+    for (const [from, to] of Object.entries(RUNTIME_TYPE_REWRITES)) {
+      const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(`(['"])${escaped}\\1`, "g");
+      rewritten = rewritten.replace(re, `$1${to}$1`);
+    }
+    if (rewritten !== original) {
+      fs.writeFileSync(dtsPath, rewritten);
+    }
+  }
+}
 function collectTsFiles(dir) {
   if (!fs.existsSync(dir)) return [];
   return fs.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
@@ -489,18 +509,23 @@ ${reexports}
 }
 
 // src/vite/server/plugins/output-wrapper.ts
-function cjsWrapper() {
+function nrgServerSpecifier(isDev) {
+  return isDev ? "@bonsae/nrg/server" : "@bonsae/nrg-runtime/server";
+}
+function cjsWrapper(isDev = false) {
+  const serverSpecifier = nrgServerSpecifier(isDev);
   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;}});}})();`;
+      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(${JSON.stringify(serverSpecifier)});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() {
+function esmWrapper(isDev = false) {
+  const serverSpecifier = nrgServerSpecifier(isDev);
   return {
     name: "vite-plugin-node-red:server:esm-wrapper",
     renderChunk(code, chunk, outputOptions) {
@@ -526,7 +551,9 @@ function esmWrapper() {
         `import { dirname as __nrgDirname } from "path";`,
         `var __filename = __nrgFileURLToPath(import.meta.url);`,
         `var __dirname = __nrgDirname(__filename);`,
-        `import { registerTypes as __nrgRegisterTypes } from "@bonsae/nrg/server";`,
+        `import { registerTypes as __nrgRegisterTypes } from ${JSON.stringify(
+          serverSpecifier
+        )};`,
         ``
       ].join("\n");
       const replacement = [
@@ -550,6 +577,12 @@ var nodeBuiltins = /* @__PURE__ */ new Set([
   ...builtinModules,
   ...builtinModules.map((m) => `node:${m}`)
 ]);
+var RUNTIME_REWRITES = {
+  "@bonsae/nrg/server": "@bonsae/nrg-runtime/server"
+};
+var RUNTIME_VERSION_SOURCE = {
+  "@bonsae/nrg-runtime": "@bonsae/nrg"
+};
 function buildTypesPath(entryName) {
   return `./${entryName}.d.ts`;
 }
@@ -606,7 +639,8 @@ function packageJsonGenerator(options) {
     bundled = [],
     types = false,
     entryNames = [],
-    format = "cjs"
+    format = "cjs",
+    isDev = false
   } = options;
   const trackedDependencies = /* @__PURE__ */ new Set();
   return {
@@ -624,12 +658,13 @@ function packageJsonGenerator(options) {
         if (nodeBuiltins.has(source)) {
           return { id: source, external: true };
         }
-        const packageName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+        const resolved = isDev ? source : RUNTIME_REWRITES[source] ?? source;
+        const packageName = resolved.startsWith("@") ? resolved.split("/").slice(0, 2).join("/") : resolved.split("/")[0];
         if (bundled.includes(packageName)) {
           return null;
         }
         trackedDependencies.add(packageName);
-        return { id: source, external: true };
+        return { id: resolved, external: true };
       }
     },
     closeBundle() {
@@ -642,14 +677,19 @@ function packageJsonGenerator(options) {
         fs2.readFileSync(rootPackageJsonPath, "utf-8")
       );
       const sourceDeps = rootPackageJson.dependencies ?? {};
+      const devDeps = rootPackageJson.devDependencies ?? {};
       const peerDeps = rootPackageJson.peerDependencies ?? {};
       let distDependencies = {};
       for (const dep of trackedDependencies) {
         if (peerDeps[dep]) {
           continue;
         }
+        const versionSource = RUNTIME_VERSION_SOURCE[dep];
+        const sourceVersion = versionSource ? sourceDeps[versionSource] ?? devDeps[versionSource] : void 0;
         if (sourceDeps[dep]) {
           distDependencies[dep] = sourceDeps[dep];
+        } else if (sourceVersion) {
+          distDependencies[dep] = sourceVersion;
         } else {
           const dependencyPackageJsonPath = path2.resolve(
             `./node_modules/${dep}/package.json`
@@ -736,9 +776,10 @@ async function build(serverOpts, buildContext) {
       bundled,
       types: types && !buildContext.isDev,
       entryNames: Object.keys(entryPoints),
-      format
+      format,
+      isDev: buildContext.isDev
     }),
-    isEsm ? esmWrapper() : cjsWrapper()
+    isEsm ? esmWrapper(buildContext.isDev) : cjsWrapper(buildContext.isDev)
   ];
   if (types && !buildContext.isDev) {
     plugins.push(
@@ -780,6 +821,9 @@ async function build(serverOpts, buildContext) {
   };
   try {
     await viteBuild(config);
+    if (types && !buildContext.isDev) {
+      rewriteRuntimeTypeImports(buildContext.outDir, Object.keys(entryPoints));
+    }
     if (isEsm) {
       const bridgeCode = `'use strict';
 // CJS bridge \u2014 auto-generated by @bonsae/nrg/vite
@@ -806,12 +850,13 @@ module.exports = function (RED) {
 // 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";
+import fs10 from "fs";
+import path10 from "path";
+import crypto from "crypto";
 
 // src/vite/client/plugins/help-generator.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { pathToFileURL } from "url";
 import { createRequire } from "module";
 
@@ -1042,8 +1087,127 @@ function getHelpTranslations(lang) {
   return translations[lang] ?? translations["en-US"];
 }
 
+// src/vite/client/plugins/unsafe-types.ts
+import ts2 from "typescript";
+import fs4 from "fs";
+import path4 from "path";
+var NRG_SERVER_MODULE = "@bonsae/nrg/server";
+function normalizeType(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function resolveImports(sf) {
+  const defineSchema = /* @__PURE__ */ new Set();
+  const schemaType = /* @__PURE__ */ new Set();
+  sf.forEachChild((node) => {
+    if (!ts2.isImportDeclaration(node) || !ts2.isStringLiteral(node.moduleSpecifier) || node.moduleSpecifier.text !== NRG_SERVER_MODULE || !node.importClause?.namedBindings || !ts2.isNamedImports(node.importClause.namedBindings)) {
+      return;
+    }
+    for (const el of node.importClause.namedBindings.elements) {
+      const imported = (el.propertyName ?? el.name).text;
+      const local = el.name.text;
+      if (imported === "defineSchema") defineSchema.add(local);
+      if (imported === "SchemaType") schemaType.add(local);
+    }
+  });
+  return { defineSchema, schemaType };
+}
+function staticPropName(name) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteralLike(name)) return name.text;
+  return void 0;
+}
+function unsafeTypeArg(node, sf, schemaType) {
+  if (!ts2.isCallExpression(node) || !ts2.isPropertyAccessExpression(node.expression) || !ts2.isIdentifier(node.expression.expression) || !schemaType.has(node.expression.expression.text)) {
+    return void 0;
+  }
+  const method = node.expression.name.text;
+  if (method === "Unsafe" && node.typeArguments?.length) {
+    return normalizeType(node.typeArguments[0].getText(sf));
+  }
+  if (method === "Array" && node.arguments.length) {
+    const inner = unsafeTypeArg(node.arguments[0], sf, schemaType);
+    if (inner) return `${inner}[]`;
+  }
+  return void 0;
+}
+function readSchemaCall(call, sf, schemaType) {
+  const [propsArg, optsArg] = call.arguments;
+  if (!propsArg || !optsArg || !ts2.isObjectLiteralExpression(propsArg) || !ts2.isObjectLiteralExpression(optsArg)) {
+    return void 0;
+  }
+  let id;
+  for (const p of optsArg.properties) {
+    if (ts2.isPropertyAssignment(p) && staticPropName(p.name) === "$id" && ts2.isStringLiteralLike(p.initializer)) {
+      id = p.initializer.text;
+    }
+  }
+  if (!id) return void 0;
+  const props = {};
+  for (const p of propsArg.properties) {
+    if (!ts2.isPropertyAssignment(p)) continue;
+    const key = staticPropName(p.name);
+    if (key === void 0) continue;
+    const type = unsafeTypeArg(p.initializer, sf, schemaType);
+    if (type) props[key] = type;
+  }
+  return { id, props };
+}
+function extractUnsafeTypesFromSource(fileName, code) {
+  const out = /* @__PURE__ */ new Map();
+  const sf = ts2.createSourceFile(fileName, code, ts2.ScriptTarget.Latest, true);
+  const { defineSchema, schemaType } = resolveImports(sf);
+  if (defineSchema.size === 0 || schemaType.size === 0) return out;
+  const visit = (node) => {
+    if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && defineSchema.has(node.expression.text)) {
+      const result = readSchemaCall(node, sf, schemaType);
+      if (result && Object.keys(result.props).length > 0) {
+        if (out.has(result.id)) {
+          throw new Error(
+            `Duplicate schema $id "${result.id}" in ${fileName} \u2014 $id must be unique`
+          );
+        }
+        out.set(result.id, result.props);
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+function collectTsFiles2(dir) {
+  const out = [];
+  if (!fs4.existsSync(dir)) return out;
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    const full = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules") continue;
+      out.push(...collectTsFiles2(full));
+    } else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function extractUnsafeTypes(srcDir) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of collectTsFiles2(srcDir).sort()) {
+    const perFile = extractUnsafeTypesFromSource(
+      file,
+      fs4.readFileSync(file, "utf-8")
+    );
+    for (const [id, props] of perFile) {
+      if (merged.has(id)) {
+        throw new Error(
+          `Duplicate schema $id "${id}" across ${srcDir} \u2014 $id must be unique`
+        );
+      }
+      merged.set(id, props);
+    }
+  }
+  return merged;
+}
+
 // src/vite/client/plugins/help-generator.ts
-function buildPropertyRow(name, schema, required, label) {
+function buildPropertyRow(name, schema, required, label, parsedType) {
   let type = "";
   if (schema["x-nrg-node-type"]) {
     type = `NodeRef \u2192 ${schema["x-nrg-node-type"]}`;
@@ -1051,6 +1215,8 @@ function buildPropertyRow(name, schema, required, label) {
     type = "TypedInput";
   } else if (schema.type) {
     type = String(schema.type);
+  } else if (parsedType) {
+    type = parsedType;
   }
   if (schema.enum) type += ` (${schema.enum.join(", ")})`;
   const constraints = [];
@@ -1086,16 +1252,19 @@ function generateSchemaSection(options) {
     t,
     labels,
     heading = "###",
-    includeDefault = true
+    includeDefault = true,
+    unsafeTypes
   } = options;
   if (!schema?.properties) return "";
+  const parsed = unsafeTypes?.get(schema.$id);
   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]
+      labels?.[key],
+      parsed?.[key]
     )
   );
   if (rows.length === 0) return "";
@@ -1133,9 +1302,9 @@ ${table}
 `;
 }
 function loadNodeLabels(labelPath) {
-  if (!fs4.existsSync(labelPath)) return {};
+  if (!fs5.existsSync(labelPath)) return {};
   try {
-    const raw = JSON.parse(fs4.readFileSync(labelPath, "utf-8"));
+    const raw = JSON.parse(fs5.readFileSync(labelPath, "utf-8"));
     return {
       description: raw.description,
       configs: raw.configs,
@@ -1147,7 +1316,7 @@ function loadNodeLabels(labelPath) {
     return {};
   }
 }
-function generateHelpDoc(nodeClass, labels, t) {
+function generateHelpDoc(nodeClass, labels, t, unsafeTypes) {
   const lines = [];
   if (labels.description) {
     lines.push(`<p>${labels.description}</p>`);
@@ -1156,14 +1325,16 @@ function generateHelpDoc(nodeClass, labels, t) {
     title: t.sections.properties,
     schema: nodeClass.configSchema,
     t,
-    labels: labels.configs
+    labels: labels.configs,
+    unsafeTypes
   });
   if (configSection) lines.push(configSection);
   const credsSection = generateSchemaSection({
     title: t.sections.credentials,
     schema: nodeClass.credentialsSchema,
     t,
-    labels: labels.credentials
+    labels: labels.credentials,
+    unsafeTypes
   });
   if (credsSection) lines.push(credsSection);
   if (nodeClass.inputSchema) {
@@ -1172,7 +1343,8 @@ function generateHelpDoc(nodeClass, labels, t) {
       schema: nodeClass.inputSchema,
       t,
       labels: labels.input,
-      includeDefault: false
+      includeDefault: false,
+      unsafeTypes
     });
     if (inputSection) lines.push(inputSection);
   }
@@ -1189,7 +1361,8 @@ function generateHelpDoc(nodeClass, labels, t) {
           t,
           labels: portPropLabels,
           heading: "####",
-          includeDefault: false
+          includeDefault: false,
+          unsafeTypes
         });
         if (section) portSections.push(section);
       });
@@ -1209,7 +1382,8 @@ ${portSections.join("\n")}`
           t,
           labels: portPropLabels,
           heading: "####",
-          includeDefault: false
+          includeDefault: false,
+          unsafeTypes
         });
         if (section) portSections.push(section);
       }
@@ -1226,7 +1400,8 @@ ${portSections.join("\n")}`
         schema: os3,
         t,
         labels: outputPropLabels,
-        includeDefault: false
+        includeDefault: false,
+        unsafeTypes
       });
       if (section) lines.push(section);
     }
@@ -1234,26 +1409,26 @@ ${portSections.join("\n")}`
   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"));
+  const nodeLabelsDir = path5.join(labelsDir, nodeType);
+  if (!fs5.existsSync(nodeLabelsDir)) return [];
+  return fs5.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path5.basename(f, ".json"));
 }
 function helpGenerator(options) {
-  const { outDir, localesOutDir, docsDir, labelsDir } = options;
+  const { outDir, localesOutDir, docsDir, labelsDir, srcDir } = 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");
+      const esmPath = path5.resolve(outDir, "index.mjs");
+      const cjsPath = path5.resolve(outDir, "index.js");
       let packageFn;
       try {
-        if (fs4.existsSync(esmPath)) {
+        if (fs5.existsSync(esmPath)) {
           const fileUrl = pathToFileURL(esmPath).href + `?t=${Date.now()}`;
           const mod = await import(fileUrl);
           packageFn = mod?.default ?? mod;
-        } else if (fs4.existsSync(cjsPath)) {
+        } else if (fs5.existsSync(cjsPath)) {
           const require2 = createRequire(import.meta.url);
           delete require2.cache[cjsPath];
           const rawMod = require2(cjsPath);
@@ -1263,6 +1438,7 @@ function helpGenerator(options) {
         return;
       }
       const nodeClasses = packageFn?.nodes ?? [];
+      const unsafeTypes = srcDir ? extractUnsafeTypes(srcDir) : void 0;
       const helpByLang = /* @__PURE__ */ new Map();
       for (const NodeClass of nodeClasses) {
         const type = NodeClass.type;
@@ -1270,13 +1446,13 @@ function helpGenerator(options) {
         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 manualMd = path5.join(docsDir, type, `${lang}.md`);
+          const manualHtml = path5.join(docsDir, type, `${lang}.html`);
+          if (fs5.existsSync(manualMd) || fs5.existsSync(manualHtml)) continue;
+          const labelPath = path5.join(labelsDir, type, `${lang}.json`);
           const labels = loadNodeLabels(labelPath);
           const t = getHelpTranslations(lang);
-          const content = generateHelpDoc(NodeClass, labels, t);
+          const content = generateHelpDoc(NodeClass, labels, t, unsafeTypes);
           if (!content) continue;
           if (!helpByLang.has(lang)) helpByLang.set(lang, []);
           helpByLang.get(lang).push(
@@ -1287,11 +1463,11 @@ ${content}
         }
       }
       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(
+        const langDir = path5.join(localesOutDir, lang);
+        fs5.mkdirSync(langDir, { recursive: true });
+        const indexPath = path5.join(langDir, "index.html");
+        const existing = fs5.existsSync(indexPath) ? fs5.readFileSync(indexPath, "utf-8") : "";
+        fs5.writeFileSync(
           indexPath,
           existing + (existing ? "\n" : "") + scripts.join("\n"),
           "utf-8"
@@ -1303,8 +1479,8 @@ ${content}
 
 // src/vite/client/plugins/html-generator.ts
 import mime from "mime-types";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function htmlGenerator(options) {
   const { packageName, licensePath } = options;
   return {
@@ -1314,7 +1490,7 @@ function htmlGenerator(options) {
     generateBundle(_, bundle) {
       const resourcesTags = Object.keys(bundle).map((fileName) => {
         const asset = bundle[fileName];
-        const srcPath = path5.join(
+        const srcPath = path6.join(
           "resources",
           packageName,
           fileName.replace(/^resources\/?/, "")
@@ -1342,8 +1518,8 @@ function htmlGenerator(options) {
             return null;
         }
       }).filter(Boolean).join("\n");
-      const licenseBanner = licensePath && fs5.existsSync(licensePath) ? `<!--
-${fs5.readFileSync(licensePath, "utf-8")}
+      const licenseBanner = licensePath && fs6.existsSync(licensePath) ? `<!--
+${fs6.readFileSync(licensePath, "utf-8")}
 -->` : "";
       this.emitFile({
         type: "asset",
@@ -1356,8 +1532,8 @@ ${resourcesTags}`
 }
 
 // src/vite/client/plugins/locales-generator.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { merge } from "es-toolkit";
 function localesGenerator(options) {
   const { outDir, docsDir, labelsDir } = options;
@@ -1740,17 +1916,17 @@ 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());
+        if (!fs7.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs7.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
         for (const nodeDir of nodeDirs) {
           const nodeType = nodeDir.name;
-          const nodePath = path6.join(baseDir, nodeType);
-          const files = fs6.readdirSync(nodePath);
+          const nodePath = path7.join(baseDir, nodeType);
+          const files = fs7.readdirSync(nodePath);
           for (const file of files) {
-            const ext = path6.extname(file);
+            const ext = path7.extname(file);
             if (!fileExtensions.includes(ext)) continue;
-            const lang = path6.basename(file, ext);
-            const filePath = path6.join(nodePath, file);
+            const lang = path7.basename(file, ext);
+            const filePath = path7.join(nodePath, file);
             validateLanguage(lang, filePath);
             const value = processFile({ ext, filePath, nodeType });
             if (value == null) continue;
@@ -1768,10 +1944,10 @@ Supported: ${languages.join(", ")}`
       }
       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),
+          const langOutDir = path7.join(outDir, lang);
+          fs7.mkdirSync(langOutDir, { recursive: true });
+          fs7.writeFileSync(
+            path7.join(langOutDir, fileName),
             serialize(data),
             "utf-8"
           );
@@ -1783,7 +1959,7 @@ Supported: ${languages.join(", ")}`
         ({ 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");
+          const content = fs7.readFileSync(filePath, "utf-8");
           return [
             `<script type="${type}" data-help-name="${nodeType}">
 ${content}
@@ -1800,7 +1976,7 @@ ${content}
         labelsDir,
         [".json"],
         ({ filePath, nodeType }) => {
-          const parsed = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+          const parsed = JSON.parse(fs7.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`
@@ -1850,8 +2026,8 @@ function minifier() {
 // 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 path8 from "path";
+import fs8 from "fs";
 import mime2 from "mime-types";
 var VIRTUAL_ID = "virtual:nrg/node-definitions";
 var RESOLVED_ID = "\0" + VIRTUAL_ID;
@@ -1882,17 +2058,68 @@ function getCredentialsFromSchema(schema) {
   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;
+  if (!fs8.existsSync(iconsDir)) return void 0;
+  return fs8.readdirSync(iconsDir).find((f) => {
+    if (path8.basename(f, path8.extname(f)) !== type) return false;
     const mimeType = mime2.lookup(f);
     return mimeType !== false && mimeType.startsWith("image/");
   });
 }
-function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true) {
+var RUNTIME_SPECIFIER = "@bonsae/nrg-runtime/server";
+var RUNTIME_SPECIFIER_RE = /(['"])@bonsae\/nrg-runtime\/server\1/g;
+function resolveRuntimeServer(serverOutDir) {
+  const roots = [path8.join(serverOutDir, "index.js"), import.meta.url];
+  for (const root of roots) {
+    try {
+      return createRequire2(root).resolve(RUNTIME_SPECIFIER);
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function loadServerPackageExport(serverOutDir) {
+  const esmEntryPath = path8.resolve(serverOutDir, "index.mjs");
+  const cjsEntryPath = path8.resolve(serverOutDir, "index.js");
+  const isEsm = fs8.existsSync(esmEntryPath);
+  const entryPath = isEsm ? esmEntryPath : fs8.existsSync(cjsEntryPath) ? cjsEntryPath : void 0;
+  if (!entryPath) return void 0;
+  const code = fs8.readFileSync(entryPath, "utf-8");
+  const runtimeServer = code.includes(RUNTIME_SPECIFIER) ? resolveRuntimeServer(serverOutDir) : void 0;
+  let tempPath;
+  let loadPath = entryPath;
+  if (runtimeServer) {
+    const replacement = isEsm ? JSON.stringify(pathToFileURL2(runtimeServer).href) : JSON.stringify(runtimeServer);
+    const rewritten = code.replace(RUNTIME_SPECIFIER_RE, replacement);
+    tempPath = path8.resolve(
+      serverOutDir,
+      `.nrg-server-${Date.now()}${isEsm ? ".mjs" : ".cjs"}`
+    );
+    fs8.writeFileSync(tempPath, rewritten);
+    loadPath = tempPath;
+  }
+  const require2 = createRequire2(import.meta.url);
+  try {
+    if (isEsm) {
+      const fileUrl = pathToFileURL2(loadPath).href + `?t=${Date.now()}`;
+      const mod = await import(fileUrl);
+      return mod?.default ?? mod;
+    }
+    delete require2.cache[loadPath];
+    const rawMod = require2(loadPath);
+    return rawMod?.default ?? rawMod;
+  } finally {
+    if (tempPath) {
+      try {
+        delete require2.cache[tempPath];
+        fs8.rmSync(tempPath);
+      } catch {
+      }
+    }
+  }
+}
+function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true, cacheDir = path8.resolve("node_modules", ".nrg", "client")) {
   let _nodeTypes = [];
   let _definitions = {};
-  const cacheDir = path7.resolve("node_modules", ".nrg", "client");
   return {
     name: "vite-plugin-node-red:client:node-definitions-inliner",
     enforce: "pre",
@@ -1901,19 +2128,7 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     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 packageFn = await loadServerPackageExport(serverOutDir);
       const nodeClasses = packageFn?.nodes ?? [];
       for (const NodeClass of nodeClasses) {
         const type = NodeClass.type;
@@ -1944,19 +2159,22 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
           icon: iconsDir ? resolveIcon(iconsDir, type) : void 0,
           inputs: NodeClass.inputs,
           outputs: NodeClass.outputs,
+          // Resolved server-side (Kind symbol intact) so the editor labels
+          // named output ports without guessing from the serialized schema.
+          outputPortNames: NodeClass.outputPortNames ?? void 0,
           inputSchema,
           outputsSchema
         };
       }
       if (!hasUserEntry) {
-        const nodesCache = path7.resolve(cacheDir, "nodes");
-        if (fs7.existsSync(nodesCache)) {
-          fs7.rmSync(nodesCache, { recursive: true });
+        const nodesCache = path8.resolve(cacheDir, "nodes");
+        if (fs8.existsSync(nodesCache)) {
+          fs8.rmSync(nodesCache, { recursive: true });
         }
-        fs7.mkdirSync(nodesCache, { recursive: true });
+        fs8.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 userTsPath = nodesDir ? path8.resolve(nodesDir, `${type}.ts`) : null;
+          if (userTsPath && fs8.existsSync(userTsPath)) continue;
           const content = [
             `// auto-generated by nrg`,
             `import { defineNode } from "@bonsae/nrg/client";`,
@@ -1966,13 +2184,13 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
             `});`,
             ``
           ].join("\n");
-          fs7.writeFileSync(path7.resolve(nodesCache, `${type}.ts`), content);
+          fs8.writeFileSync(path8.resolve(nodesCache, `${type}.ts`), content);
         }
         const entryContent = generateEntryCode("");
-        fs7.mkdirSync(path7.dirname(path7.resolve(cacheDir, "index.ts")), {
+        fs8.mkdirSync(path8.dirname(path8.resolve(cacheDir, "index.ts")), {
           recursive: true
         });
-        fs7.writeFileSync(path7.resolve(cacheDir, "index.ts"), entryContent);
+        fs8.writeFileSync(path8.resolve(cacheDir, "index.ts"), entryContent);
       }
     },
     resolveId(id) {
@@ -1995,12 +2213,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     const nrgImports = /* @__PURE__ */ new Set(["__setSchemas"]);
     const lines = [`import __nrgSchemas from "${VIRTUAL_ID}";`];
     const postLines = [`__setSchemas(__nrgSchemas);`];
-    if (componentsDir && fs7.existsSync(componentsDir)) {
+    if (componentsDir && fs8.existsSync(componentsDir)) {
       const formImports = [];
       const formEntries = [];
       for (const type of _nodeTypes) {
-        const componentPath = path7.resolve(componentsDir, `${type}.vue`);
-        if (fs7.existsSync(componentPath)) {
+        const componentPath = path8.resolve(componentsDir, `${type}.vue`);
+        if (fs8.existsSync(componentPath)) {
           const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
           formImports.push(
             `import ${varName} from ${JSON.stringify(componentPath)};`
@@ -2015,12 +2233,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
       }
     }
     if (!hasUserEntry) {
-      const nodesCache = path7.resolve(cacheDir, "nodes");
+      const nodesCache = path8.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`);
+        const userTsPath = nodesDir ? path8.resolve(nodesDir, `${type}.ts`) : null;
+        const tsPath = userTsPath && fs8.existsSync(userTsPath) ? userTsPath : path8.resolve(nodesCache, `${type}.ts`);
         lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
         defVarNames.push(varName);
       }
@@ -2038,8 +2256,8 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
 }
 
 // src/vite/client/plugins/static-copy.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function staticCopy(options) {
   const { targets } = options;
   return {
@@ -2048,23 +2266,23 @@ function staticCopy(options) {
     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 (!fs9.existsSync(src)) continue;
+        fs9.mkdirSync(dest, { recursive: true });
+        const stat = fs9.statSync(src);
         if (stat.isDirectory()) {
-          const files = fs8.readdirSync(src);
+          const files = fs9.readdirSync(src);
           for (const file of files) {
-            const srcFile = path8.join(src, file);
-            const destFile = path8.join(dest, file);
-            const fileStat = fs8.statSync(srcFile);
+            const srcFile = path9.join(src, file);
+            const destFile = path9.join(dest, file);
+            const fileStat = fs9.statSync(srcFile);
             if (fileStat.isDirectory()) {
-              fs8.cpSync(srcFile, destFile, { recursive: true });
+              fs9.cpSync(srcFile, destFile, { recursive: true });
             } else {
-              fs8.copyFileSync(srcFile, destFile);
+              fs9.copyFileSync(srcFile, destFile);
             }
           }
         } else {
-          fs8.copyFileSync(src, dest);
+          fs9.copyFileSync(src, dest);
         }
       }
     }
@@ -2072,6 +2290,11 @@ function staticCopy(options) {
 }
 
 // src/vite/client/build.ts
+function cacheKeyFor(outDir) {
+  const abs = path10.resolve(outDir);
+  const hash = crypto.createHash("sha1").update(abs).digest("hex").slice(0, 8);
+  return `${path10.basename(abs) || "client"}-${hash}`;
+}
 async function build2(clientBuildOptions, buildContext) {
   const {
     srcDir = "./client",
@@ -2085,74 +2308,81 @@ async function build2(clientBuildOptions, buildContext) {
     globals = {},
     manualChunks
   } = clientBuildOptions;
-  const physicalEntryPath = path9.resolve(srcDir, entry);
+  const cacheDir = path10.resolve(
+    "node_modules",
+    ".nrg",
+    "client",
+    cacheKeyFor(buildContext.outDir)
+  );
+  const physicalEntryPath = path10.resolve(srcDir, entry);
   let entryPath;
   let generatedEntry = false;
-  if (fs9.existsSync(physicalEntryPath)) {
+  if (fs10.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 });
+    const cachedEntryPath = path10.resolve(cacheDir, entry);
+    if (!fs10.existsSync(cacheDir)) {
+      fs10.mkdirSync(cacheDir, { recursive: true });
     }
-    fs9.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    fs10.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 iconsDir = path10.resolve(
+    staticDirs.icons ?? path10.join(path10.dirname(path10.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
+      fs10.existsSync(iconsDir) ? iconsDir : void 0,
+      path10.resolve(srcDir, "components"),
+      path10.resolve(srcDir, "nodes"),
+      !generatedEntry,
+      cacheDir
     )
   ];
   plugins.push(
     htmlGenerator({
       packageName: buildContext.packageName,
-      licensePath: licensePath ? path9.resolve(licensePath) : void 0
+      licensePath: licensePath ? path10.resolve(licensePath) : void 0
     })
   );
   if (locales) {
     const { docsDir = "./locales/docs", labelsDir = "./locales/labels" } = locales;
-    const localesOutDir = path9.join(buildContext.outDir, "locales");
+    const localesOutDir = path10.join(buildContext.outDir, "locales");
     plugins.push(
       localesGenerator({
         outDir: localesOutDir,
-        docsDir: path9.resolve(docsDir),
-        labelsDir: path9.resolve(labelsDir)
+        docsDir: path10.resolve(docsDir),
+        labelsDir: path10.resolve(labelsDir)
       })
     );
     plugins.push(
       helpGenerator({
         outDir: buildContext.outDir,
         localesOutDir,
-        docsDir: path9.resolve(docsDir),
-        labelsDir: path9.resolve(labelsDir)
+        docsDir: path10.resolve(docsDir),
+        labelsDir: path10.resolve(labelsDir),
+        srcDir: buildContext.serverSrcDir
       })
     );
   }
   const copyTargets = [];
-  const publicDir = path9.resolve(
-    staticDirs.public ?? path9.join(srcDir, "public")
+  const publicDir = path10.resolve(
+    staticDirs.public ?? path10.join(srcDir, "public")
   );
-  if (fs9.existsSync(publicDir)) {
+  if (fs10.existsSync(publicDir)) {
     copyTargets.push({
       src: publicDir,
-      dest: path9.join(buildContext.outDir, "resources")
+      dest: path10.join(buildContext.outDir, "resources")
     });
   }
-  if (fs9.existsSync(iconsDir)) {
+  if (fs10.existsSync(iconsDir)) {
     copyTargets.push({
       src: iconsDir,
-      dest: path9.join(buildContext.outDir, "icons")
+      dest: path10.join(buildContext.outDir, "icons")
     });
   }
   if (copyTargets.length > 0) {
@@ -2180,10 +2410,10 @@ async function build2(clientBuildOptions, buildContext) {
     configFile: false,
     logLevel: "warn",
     base: `/resources/${buildContext.packageName}`,
-    publicDir: path9.resolve(srcDir, "public"),
+    publicDir: path10.resolve(srcDir, "public"),
     resolve: {
       alias: {
-        "@": path9.resolve(srcDir)
+        "@": path10.resolve(srcDir)
       }
     },
     plugins,
@@ -2237,15 +2467,15 @@ async function build2(clientBuildOptions, buildContext) {
     throw new BuildError("client", error);
   } finally {
     if (generatedEntry) {
-      if (fs9.existsSync(entryPath)) {
-        fs9.unlinkSync(entryPath);
+      if (fs10.existsSync(entryPath)) {
+        fs10.unlinkSync(entryPath);
       }
     }
   }
 }
 
 // src/vite/node-red-launcher/index.ts
-import fs12 from "fs";
+import fs13 from "fs";
 
 // src/vite/async-utils.ts
 function withTimeout(promise, ms, fallback) {
@@ -2286,22 +2516,22 @@ async function retry(fn, options = {}) {
 import { exec } from "child_process";
 import { randomUUID } from "crypto";
 import { createRequire as createRequire3 } from "module";
-import fs10 from "fs";
+import fs11 from "fs";
 import os from "os";
-import path10 from "path";
+import path11 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 require_ = createRequire3(path11.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 pkgDir = path11.dirname(pkgJsonPath);
+    const pkg = JSON.parse(fs11.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;
+    const entry = path11.resolve(pkgDir, bin);
+    return fs11.existsSync(entry) ? entry : null;
   } catch {
     return null;
   }
@@ -2326,11 +2556,11 @@ async function resolveNodeRed(options) {
   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(
+  const resolverScript = path11.join(
     os.tmpdir(),
     `nrg-resolve-node-red-${process.pid}-${randomUUID()}.cjs`
   );
-  fs10.writeFileSync(
+  fs11.writeFileSync(
     resolverScript,
     `const fs = require("fs");
 const path = require("path");
@@ -2364,7 +2594,7 @@ for (const d of dirs) {
       );
     });
     const entryPoint = stdout.trim();
-    if (!entryPoint || !fs10.existsSync(entryPoint)) {
+    if (!entryPoint || !fs11.existsSync(entryPoint)) {
       throw new NodeRedStartError(
         new Error(
           `Could not resolve node-red entry point: ${entryPoint || "(empty)"}`
@@ -2375,7 +2605,7 @@ for (const d of dirs) {
     return entryPoint;
   } finally {
     try {
-      fs10.unlinkSync(resolverScript);
+      fs11.unlinkSync(resolverScript);
     } catch {
     }
   }
@@ -2383,28 +2613,28 @@ for (const d of dirs) {
 
 // src/vite/node-red-launcher/settings.ts
 import { builtinModules as builtinModules2 } from "module";
-import fs11 from "fs";
+import fs12 from "fs";
 import os2 from "os";
-import path11 from "path";
+import path12 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)) {
+    const resolved2 = path12.resolve(settingsFilepath);
+    if (fs12.existsSync(resolved2)) {
       return resolved2;
     }
     logger2.warn(`Settings file not found: ${settingsFilepath}`);
     return null;
   }
-  const resolved = path11.resolve("node-red.settings.ts");
-  if (fs11.existsSync(resolved)) {
+  const resolved = path12.resolve("node-red.settings.ts");
+  if (fs12.existsSync(resolved)) {
     return resolved;
   }
   return null;
 }
 async function compileRuntimeSettingsFile(runtimeSettingsFilepath, port) {
-  const compiledRuntimeSettingsFilepath = path11.join(
+  const compiledRuntimeSettingsFilepath = path12.join(
     os2.tmpdir(),
     `node-red.settings.${process.pid}-${port}.cjs`
   );
@@ -2412,8 +2642,8 @@ async function compileRuntimeSettingsFile(runtimeSettingsFilepath, port) {
     ...builtinModules2,
     ...builtinModules2.map((m) => `node:${m}`)
   ];
-  const settingsDir = path11.dirname(runtimeSettingsFilepath).split(path11.sep).join("/");
-  const settingsFile = runtimeSettingsFilepath.split(path11.sep).join("/");
+  const settingsDir = path12.dirname(runtimeSettingsFilepath).split(path12.sep).join("/");
+  const settingsFile = runtimeSettingsFilepath.split(path12.sep).join("/");
   await esbuild({
     entryPoints: [runtimeSettingsFilepath],
     outfile: compiledRuntimeSettingsFilepath,
@@ -2445,14 +2675,14 @@ async function generateRuntimeSettings(options) {
     );
     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 normalizedOutDir = path12.resolve(outDir).split(path12.sep).join("/");
+  const cwd = process.cwd().split(path12.sep).join("/");
+  const userDir = path12.resolve(cwd, ".node-red").split(path12.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("/")
+    compiledRuntimeSettingsFilepath.split(path12.sep).join("/")
   )});
 const settings = compiledRuntimeSettings.default || compiledRuntimeSettings;
 settings.uiPort = ${port};
@@ -2484,11 +2714,11 @@ const settings = {
 };
 module.exports = settings;
 `;
-  const finalRuntimeSettingsFilepath = path11.join(
+  const finalRuntimeSettingsFilepath = path12.join(
     os2.tmpdir(),
     `node-red-settings-final-${process.pid}-${port}.cjs`
   );
-  fs11.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
+  fs12.writeFileSync(finalRuntimeSettingsFilepath, finalRuntimeSettingsFile);
   tempFiles.push(finalRuntimeSettingsFilepath);
   return { filepath: finalRuntimeSettingsFilepath, tempFiles };
 }
@@ -2713,7 +2943,7 @@ var NodeRedLauncher = class {
         preferredPort: this.preferredPort,
         logger: this.logger
       });
-      if (!this.nodeRedEntryPoint || !fs12.existsSync(this.nodeRedEntryPoint)) {
+      if (!this.nodeRedEntryPoint || !fs13.existsSync(this.nodeRedEntryPoint)) {
         this.nodeRedEntryPoint = await resolveNodeRed({
           version: this.options.runtime?.version,
           logger: this.logger
@@ -2787,7 +3017,7 @@ var NodeRedLauncher = class {
   cleanup() {
     for (const file of this.tempFiles) {
       try {
-        fs12.unlinkSync(file);
+        fs13.unlinkSync(file);
       } catch {
       }
     }
@@ -2807,10 +3037,10 @@ var NodeRedTestEnvironment = class {
   options;
   constructor(options) {
     this.options = options;
-    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.projectDir = path13.resolve(options.projectDir ?? process.cwd());
+    this.outDir = path13.join(this.projectDir, "dist-e2e");
+    this.nodeRedDir = path13.join(this.projectDir, ".node-red");
+    this.installedPkgDir = path13.join(
       this.nodeRedDir,
       "node_modules",
       options.packageName
@@ -2822,15 +3052,15 @@ var NodeRedTestEnvironment = class {
   async setup() {
     this.originalCwd = process.cwd();
     process.chdir(this.projectDir);
-    if (fs13.existsSync(this.outDir)) fs13.rmSync(this.outDir, { recursive: true });
-    fs13.mkdirSync(this.outDir, { recursive: true });
+    if (fs14.existsSync(this.outDir)) fs14.rmSync(this.outDir, { recursive: true });
+    fs14.mkdirSync(this.outDir, { recursive: true });
     const buildContext = {
       outDir: this.outDir,
       packageName: this.options.packageName,
       isDev: false
     };
     const serverOpts = {
-      srcDir: path12.join(this.projectDir, "src/server"),
+      srcDir: path13.join(this.projectDir, "src/server"),
       entry: "index.ts",
       format: "esm",
       bundled: [],
@@ -2840,7 +3070,7 @@ var NodeRedTestEnvironment = class {
     };
     await build(serverOpts, buildContext);
     const clientOpts = {
-      srcDir: path12.join(this.projectDir, "src/client"),
+      srcDir: path13.join(this.projectDir, "src/client"),
       entry: "index.ts",
       name: this.options.clientName ?? "NodeRedNodes",
       format: "es",
@@ -2849,18 +3079,18 @@ var NodeRedTestEnvironment = class {
       ...this.options.client
     };
     await build2(clientOpts, buildContext);
-    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"),
+    fs14.mkdirSync(this.installedPkgDir, { recursive: true });
+    fs14.cpSync(this.outDir, this.installedPkgDir, { recursive: true });
+    fs14.mkdirSync(this.nodeRedDir, { recursive: true });
+    fs14.writeFileSync(
+      path13.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 = path12.resolve(
+      launcherOpts.runtime.settingsFilepath = path13.resolve(
         this.projectDir,
         this.options.settingsFile
       );
@@ -2895,25 +3125,19 @@ var NodeRedTestEnvironment = class {
       this.launcher.cleanup();
       this.launcher = null;
     }
-    if (fs13.existsSync(this.outDir)) fs13.rmSync(this.outDir, { recursive: true });
-    if (fs13.existsSync(this.nodeRedDir)) {
-      fs13.rmSync(this.nodeRedDir, { recursive: true });
+    if (fs14.existsSync(this.outDir)) fs14.rmSync(this.outDir, { recursive: true });
+    if (fs14.existsSync(this.nodeRedDir)) {
+      fs14.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"],
-  include: ["tests/client/e2e/**/*.test.ts"]
-};
 var _env = null;
 async function setup(options) {
   const packageName = JSON.parse(
-    fs14.readFileSync(path13.join(process.cwd(), "package.json"), "utf-8")
+    fs15.readFileSync(path14.join(process.cwd(), "package.json"), "utf-8")
   ).name;
   _env = new NodeRedTestEnvironment({
     packageName,
@@ -2945,8 +3169,8 @@ var NodeRedEditor = class {
   errors = [];
   screenshotDir;
   async screenshot(name) {
-    fs14.mkdirSync(this.screenshotDir, { recursive: true });
-    const filePath = path13.join(this.screenshotDir, `${name}.png`);
+    fs15.mkdirSync(this.screenshotDir, { recursive: true });
+    const filePath = path14.join(this.screenshotDir, `${name}.png`);
     await this.page.screenshot({ path: filePath, fullPage: true });
     return filePath;
   }
@@ -3350,7 +3574,6 @@ export {
   NodeRedEditor,
   NodeRedField,
   NodeRedTestEnvironment,
-  defaultConfig,
   setup,
   teardown
 };