@bonsae/nrg 0.21.1 → 0.22.0

package/vite/index.js

@@ -1,5 +1,5 @@
 // src/vite/plugin.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/vite/defaults.ts
 var DEFAULT_OUTPUT_DIR = "./dist";
@@ -766,7 +766,7 @@ var NodeRedLauncher = class {
 // src/vite/plugins/server.ts
 import chokidar from "chokidar";
 import treeKill2 from "tree-kill";
-import path13 from "path";
+import path14 from "path";
 
 // src/vite/server/build.ts
 import { build as viteBuild } from "vite";
@@ -778,6 +778,26 @@ import dts from "vite-plugin-dts";
 import fs5 from "fs";
 import path4 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 = path4.join(outDir, `${name}.d.ts`);
+    if (!fs5.existsSync(dtsPath)) continue;
+    const original = fs5.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) {
+      fs5.writeFileSync(dtsPath, rewritten);
+    }
+  }
+}
 function collectTsFiles(dir) {
   if (!fs5.existsSync(dir)) return [];
   return fs5.readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
@@ -1152,18 +1172,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) {
@@ -1189,7 +1214,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 = [
@@ -1213,6 +1240,12 @@ var nodeBuiltins = /* @__PURE__ */ new Set([
   ...builtinModules2,
   ...builtinModules2.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`;
 }
@@ -1269,7 +1302,8 @@ function packageJsonGenerator(options) {
     bundled = [],
     types = false,
     entryNames = [],
-    format = "cjs"
+    format = "cjs",
+    isDev = false
   } = options;
   const trackedDependencies = /* @__PURE__ */ new Set();
   return {
@@ -1287,12 +1321,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() {
@@ -1305,14 +1340,19 @@ function packageJsonGenerator(options) {
         fs6.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 = path5.resolve(
             `./node_modules/${dep}/package.json`
@@ -1399,9 +1439,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(
@@ -1443,6 +1484,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
@@ -1469,12 +1513,13 @@ module.exports = function (RED) {
 // src/vite/client/build.ts
 import { build as viteBuild2 } from "vite";
 import vue from "@vitejs/plugin-vue";
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
+import crypto from "crypto";
 
 // src/vite/client/plugins/help-generator.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { createRequire as createRequire2 } from "module";
 
@@ -1705,8 +1750,127 @@ function getHelpTranslations(lang) {
   return translations[lang] ?? translations["en-US"];
 }
 
+// src/vite/client/plugins/unsafe-types.ts
+import ts2 from "typescript";
+import fs8 from "fs";
+import path7 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 (!fs8.existsSync(dir)) return out;
+  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+    const full = path7.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,
+      fs8.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"]}`;
@@ -1714,6 +1878,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 = [];
@@ -1749,16 +1915,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 "";
@@ -1796,9 +1965,9 @@ ${table}
 `;
 }
 function loadNodeLabels(labelPath) {
-  if (!fs8.existsSync(labelPath)) return {};
+  if (!fs9.existsSync(labelPath)) return {};
   try {
-    const raw = JSON.parse(fs8.readFileSync(labelPath, "utf-8"));
+    const raw = JSON.parse(fs9.readFileSync(labelPath, "utf-8"));
     return {
       description: raw.description,
       configs: raw.configs,
@@ -1810,7 +1979,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>`);
@@ -1819,14 +1988,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) {
@@ -1835,7 +2006,8 @@ function generateHelpDoc(nodeClass, labels, t) {
       schema: nodeClass.inputSchema,
       t,
       labels: labels.input,
-      includeDefault: false
+      includeDefault: false,
+      unsafeTypes
     });
     if (inputSection) lines.push(inputSection);
   }
@@ -1852,7 +2024,8 @@ function generateHelpDoc(nodeClass, labels, t) {
           t,
           labels: portPropLabels,
           heading: "####",
-          includeDefault: false
+          includeDefault: false,
+          unsafeTypes
         });
         if (section) portSections.push(section);
       });
@@ -1872,7 +2045,8 @@ ${portSections.join("\n")}`
           t,
           labels: portPropLabels,
           heading: "####",
-          includeDefault: false
+          includeDefault: false,
+          unsafeTypes
         });
         if (section) portSections.push(section);
       }
@@ -1889,7 +2063,8 @@ ${portSections.join("\n")}`
         schema: os3,
         t,
         labels: outputPropLabels,
-        includeDefault: false
+        includeDefault: false,
+        unsafeTypes
       });
       if (section) lines.push(section);
     }
@@ -1897,26 +2072,26 @@ ${portSections.join("\n")}`
   return lines.join("\n").trim();
 }
 function discoverLanguages(labelsDir, nodeType) {
-  const nodeLabelsDir = path7.join(labelsDir, nodeType);
-  if (!fs8.existsSync(nodeLabelsDir)) return [];
-  return fs8.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path7.basename(f, ".json"));
+  const nodeLabelsDir = path8.join(labelsDir, nodeType);
+  if (!fs9.existsSync(nodeLabelsDir)) return [];
+  return fs9.readdirSync(nodeLabelsDir).filter((f) => f.endsWith(".json")).map((f) => path8.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 = path7.resolve(outDir, "index.mjs");
-      const cjsPath = path7.resolve(outDir, "index.js");
+      const esmPath = path8.resolve(outDir, "index.mjs");
+      const cjsPath = path8.resolve(outDir, "index.js");
       let packageFn;
       try {
-        if (fs8.existsSync(esmPath)) {
+        if (fs9.existsSync(esmPath)) {
           const fileUrl = pathToFileURL2(esmPath).href + `?t=${Date.now()}`;
           const mod = await import(fileUrl);
           packageFn = mod?.default ?? mod;
-        } else if (fs8.existsSync(cjsPath)) {
+        } else if (fs9.existsSync(cjsPath)) {
           const require2 = createRequire2(import.meta.url);
           delete require2.cache[cjsPath];
           const rawMod = require2(cjsPath);
@@ -1926,6 +2101,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;
@@ -1933,13 +2109,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 = path7.join(docsDir, type, `${lang}.md`);
-          const manualHtml = path7.join(docsDir, type, `${lang}.html`);
-          if (fs8.existsSync(manualMd) || fs8.existsSync(manualHtml)) continue;
-          const labelPath = path7.join(labelsDir, type, `${lang}.json`);
+          const manualMd = path8.join(docsDir, type, `${lang}.md`);
+          const manualHtml = path8.join(docsDir, type, `${lang}.html`);
+          if (fs9.existsSync(manualMd) || fs9.existsSync(manualHtml)) continue;
+          const labelPath = path8.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(
@@ -1950,11 +2126,11 @@ ${content}
         }
       }
       for (const [lang, scripts] of helpByLang) {
-        const langDir = path7.join(localesOutDir, lang);
-        fs8.mkdirSync(langDir, { recursive: true });
-        const indexPath = path7.join(langDir, "index.html");
-        const existing = fs8.existsSync(indexPath) ? fs8.readFileSync(indexPath, "utf-8") : "";
-        fs8.writeFileSync(
+        const langDir = path8.join(localesOutDir, lang);
+        fs9.mkdirSync(langDir, { recursive: true });
+        const indexPath = path8.join(langDir, "index.html");
+        const existing = fs9.existsSync(indexPath) ? fs9.readFileSync(indexPath, "utf-8") : "";
+        fs9.writeFileSync(
           indexPath,
           existing + (existing ? "\n" : "") + scripts.join("\n"),
           "utf-8"
@@ -1966,8 +2142,8 @@ ${content}
 
 // src/vite/client/plugins/html-generator.ts
 import mime from "mime-types";
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 function htmlGenerator(options) {
   const { packageName, licensePath } = options;
   return {
@@ -1977,7 +2153,7 @@ function htmlGenerator(options) {
     generateBundle(_, bundle) {
       const resourcesTags = Object.keys(bundle).map((fileName) => {
         const asset = bundle[fileName];
-        const srcPath = path8.join(
+        const srcPath = path9.join(
           "resources",
           packageName,
           fileName.replace(/^resources\/?/, "")
@@ -2005,8 +2181,8 @@ function htmlGenerator(options) {
             return null;
         }
       }).filter(Boolean).join("\n");
-      const licenseBanner = licensePath && fs9.existsSync(licensePath) ? `<!--
-${fs9.readFileSync(licensePath, "utf-8")}
+      const licenseBanner = licensePath && fs10.existsSync(licensePath) ? `<!--
+${fs10.readFileSync(licensePath, "utf-8")}
 -->` : "";
       this.emitFile({
         type: "asset",
@@ -2019,8 +2195,8 @@ ${resourcesTags}`
 }
 
 // src/vite/client/plugins/locales-generator.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { merge } from "es-toolkit";
 function localesGenerator(options) {
   const { outDir, docsDir, labelsDir } = options;
@@ -2403,17 +2579,17 @@ Supported: ${languages.join(", ")}`
       }
       function forEachFile(baseDir, fileExtensions, processFile) {
         const langMap = /* @__PURE__ */ new Map();
-        if (!fs10.existsSync(baseDir)) return langMap;
-        const nodeDirs = fs10.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+        if (!fs11.existsSync(baseDir)) return langMap;
+        const nodeDirs = fs11.readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory());
         for (const nodeDir of nodeDirs) {
           const nodeType = nodeDir.name;
-          const nodePath = path9.join(baseDir, nodeType);
-          const files = fs10.readdirSync(nodePath);
+          const nodePath = path10.join(baseDir, nodeType);
+          const files = fs11.readdirSync(nodePath);
           for (const file of files) {
-            const ext = path9.extname(file);
+            const ext = path10.extname(file);
             if (!fileExtensions.includes(ext)) continue;
-            const lang = path9.basename(file, ext);
-            const filePath = path9.join(nodePath, file);
+            const lang = path10.basename(file, ext);
+            const filePath = path10.join(nodePath, file);
             validateLanguage(lang, filePath);
             const value = processFile({ ext, filePath, nodeType });
             if (value == null) continue;
@@ -2431,10 +2607,10 @@ Supported: ${languages.join(", ")}`
       }
       function writeOutput(langMap, fileName, serialize) {
         for (const [lang, data] of langMap.entries()) {
-          const langOutDir = path9.join(outDir, lang);
-          fs10.mkdirSync(langOutDir, { recursive: true });
-          fs10.writeFileSync(
-            path9.join(langOutDir, fileName),
+          const langOutDir = path10.join(outDir, lang);
+          fs11.mkdirSync(langOutDir, { recursive: true });
+          fs11.writeFileSync(
+            path10.join(langOutDir, fileName),
             serialize(data),
             "utf-8"
           );
@@ -2446,7 +2622,7 @@ Supported: ${languages.join(", ")}`
         ({ ext, filePath, nodeType }) => {
           const type = ext === ".html" ? "text/html" : ext === ".md" ? "text/markdown" : null;
           if (!type) return null;
-          const content = fs10.readFileSync(filePath, "utf-8");
+          const content = fs11.readFileSync(filePath, "utf-8");
           return [
             `<script type="${type}" data-help-name="${nodeType}">
 ${content}
@@ -2463,7 +2639,7 @@ ${content}
         labelsDir,
         [".json"],
         ({ filePath, nodeType }) => {
-          const parsed = JSON.parse(fs10.readFileSync(filePath, "utf-8"));
+          const parsed = JSON.parse(fs11.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`
@@ -2513,8 +2689,8 @@ function minifier() {
 // src/vite/client/plugins/node-definitions-inliner.ts
 import { createRequire as createRequire3 } from "module";
 import { pathToFileURL as pathToFileURL3 } from "url";
-import path10 from "path";
-import fs11 from "fs";
+import path11 from "path";
+import fs12 from "fs";
 import mime2 from "mime-types";
 var VIRTUAL_ID = "virtual:nrg/node-definitions";
 var RESOLVED_ID = "\0" + VIRTUAL_ID;
@@ -2545,17 +2721,68 @@ function getCredentialsFromSchema(schema) {
   return result;
 }
 function resolveIcon(iconsDir, type) {
-  if (!fs11.existsSync(iconsDir)) return void 0;
-  return fs11.readdirSync(iconsDir).find((f) => {
-    if (path10.basename(f, path10.extname(f)) !== type) return false;
+  if (!fs12.existsSync(iconsDir)) return void 0;
+  return fs12.readdirSync(iconsDir).find((f) => {
+    if (path11.basename(f, path11.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 = [path11.join(serverOutDir, "index.js"), import.meta.url];
+  for (const root of roots) {
+    try {
+      return createRequire3(root).resolve(RUNTIME_SPECIFIER);
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function loadServerPackageExport(serverOutDir) {
+  const esmEntryPath = path11.resolve(serverOutDir, "index.mjs");
+  const cjsEntryPath = path11.resolve(serverOutDir, "index.js");
+  const isEsm = fs12.existsSync(esmEntryPath);
+  const entryPath = isEsm ? esmEntryPath : fs12.existsSync(cjsEntryPath) ? cjsEntryPath : void 0;
+  if (!entryPath) return void 0;
+  const code = fs12.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(pathToFileURL3(runtimeServer).href) : JSON.stringify(runtimeServer);
+    const rewritten = code.replace(RUNTIME_SPECIFIER_RE, replacement);
+    tempPath = path11.resolve(
+      serverOutDir,
+      `.nrg-server-${Date.now()}${isEsm ? ".mjs" : ".cjs"}`
+    );
+    fs12.writeFileSync(tempPath, rewritten);
+    loadPath = tempPath;
+  }
+  const require2 = createRequire3(import.meta.url);
+  try {
+    if (isEsm) {
+      const fileUrl = pathToFileURL3(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];
+        fs12.rmSync(tempPath);
+      } catch {
+      }
+    }
+  }
+}
+function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir, nodesDir, hasUserEntry = true, cacheDir = path11.resolve("node_modules", ".nrg", "client")) {
   let _nodeTypes = [];
   let _definitions = {};
-  const cacheDir = path10.resolve("node_modules", ".nrg", "client");
   return {
     name: "vite-plugin-node-red:client:node-definitions-inliner",
     enforce: "pre",
@@ -2564,19 +2791,7 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
     async buildStart() {
       _nodeTypes = [];
       _definitions = {};
-      const esmEntryPath = path10.resolve(serverOutDir, "index.mjs");
-      const cjsEntryPath = path10.resolve(serverOutDir, "index.js");
-      let packageFn;
-      if (fs11.existsSync(esmEntryPath)) {
-        const fileUrl = pathToFileURL3(esmEntryPath).href + `?t=${Date.now()}`;
-        const mod = await import(fileUrl);
-        packageFn = mod?.default ?? mod;
-      } else if (fs11.existsSync(cjsEntryPath)) {
-        const require2 = createRequire3(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;
@@ -2607,19 +2822,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 = path10.resolve(cacheDir, "nodes");
-        if (fs11.existsSync(nodesCache)) {
-          fs11.rmSync(nodesCache, { recursive: true });
+        const nodesCache = path11.resolve(cacheDir, "nodes");
+        if (fs12.existsSync(nodesCache)) {
+          fs12.rmSync(nodesCache, { recursive: true });
         }
-        fs11.mkdirSync(nodesCache, { recursive: true });
+        fs12.mkdirSync(nodesCache, { recursive: true });
         for (const type of _nodeTypes) {
-          const userTsPath = nodesDir ? path10.resolve(nodesDir, `${type}.ts`) : null;
-          if (userTsPath && fs11.existsSync(userTsPath)) continue;
+          const userTsPath = nodesDir ? path11.resolve(nodesDir, `${type}.ts`) : null;
+          if (userTsPath && fs12.existsSync(userTsPath)) continue;
           const content = [
             `// auto-generated by nrg`,
             `import { defineNode } from "@bonsae/nrg/client";`,
@@ -2629,13 +2847,13 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
             `});`,
             ``
           ].join("\n");
-          fs11.writeFileSync(path10.resolve(nodesCache, `${type}.ts`), content);
+          fs12.writeFileSync(path11.resolve(nodesCache, `${type}.ts`), content);
         }
         const entryContent = generateEntryCode("");
-        fs11.mkdirSync(path10.dirname(path10.resolve(cacheDir, "index.ts")), {
+        fs12.mkdirSync(path11.dirname(path11.resolve(cacheDir, "index.ts")), {
           recursive: true
         });
-        fs11.writeFileSync(path10.resolve(cacheDir, "index.ts"), entryContent);
+        fs12.writeFileSync(path11.resolve(cacheDir, "index.ts"), entryContent);
       }
     },
     resolveId(id) {
@@ -2658,12 +2876,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 && fs11.existsSync(componentsDir)) {
+    if (componentsDir && fs12.existsSync(componentsDir)) {
       const formImports = [];
       const formEntries = [];
       for (const type of _nodeTypes) {
-        const componentPath = path10.resolve(componentsDir, `${type}.vue`);
-        if (fs11.existsSync(componentPath)) {
+        const componentPath = path11.resolve(componentsDir, `${type}.vue`);
+        if (fs12.existsSync(componentPath)) {
           const varName = `__nrgForm_${type.replace(/-/g, "_")}`;
           formImports.push(
             `import ${varName} from ${JSON.stringify(componentPath)};`
@@ -2678,12 +2896,12 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
       }
     }
     if (!hasUserEntry) {
-      const nodesCache = path10.resolve(cacheDir, "nodes");
+      const nodesCache = path11.resolve(cacheDir, "nodes");
       const defVarNames = [];
       for (const type of _nodeTypes) {
         const varName = `__nrgNodeDef_${type.replace(/-/g, "_")}`;
-        const userTsPath = nodesDir ? path10.resolve(nodesDir, `${type}.ts`) : null;
-        const tsPath = userTsPath && fs11.existsSync(userTsPath) ? userTsPath : path10.resolve(nodesCache, `${type}.ts`);
+        const userTsPath = nodesDir ? path11.resolve(nodesDir, `${type}.ts`) : null;
+        const tsPath = userTsPath && fs12.existsSync(userTsPath) ? userTsPath : path11.resolve(nodesCache, `${type}.ts`);
         lines.push(`import ${varName} from ${JSON.stringify(tsPath)};`);
         defVarNames.push(varName);
       }
@@ -2701,8 +2919,8 @@ function nodeDefinitionsInliner(serverOutDir, entryPath, iconsDir, componentsDir
 }
 
 // src/vite/client/plugins/static-copy.ts
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 function staticCopy(options) {
   const { targets } = options;
   return {
@@ -2711,23 +2929,23 @@ function staticCopy(options) {
     enforce: "post",
     closeBundle() {
       for (const { src, dest } of targets) {
-        if (!fs12.existsSync(src)) continue;
-        fs12.mkdirSync(dest, { recursive: true });
-        const stat = fs12.statSync(src);
+        if (!fs13.existsSync(src)) continue;
+        fs13.mkdirSync(dest, { recursive: true });
+        const stat = fs13.statSync(src);
         if (stat.isDirectory()) {
-          const files = fs12.readdirSync(src);
+          const files = fs13.readdirSync(src);
           for (const file of files) {
-            const srcFile = path11.join(src, file);
-            const destFile = path11.join(dest, file);
-            const fileStat = fs12.statSync(srcFile);
+            const srcFile = path12.join(src, file);
+            const destFile = path12.join(dest, file);
+            const fileStat = fs13.statSync(srcFile);
             if (fileStat.isDirectory()) {
-              fs12.cpSync(srcFile, destFile, { recursive: true });
+              fs13.cpSync(srcFile, destFile, { recursive: true });
             } else {
-              fs12.copyFileSync(srcFile, destFile);
+              fs13.copyFileSync(srcFile, destFile);
             }
           }
         } else {
-          fs12.copyFileSync(src, dest);
+          fs13.copyFileSync(src, dest);
         }
       }
     }
@@ -2735,6 +2953,11 @@ function staticCopy(options) {
 }
 
 // src/vite/client/build.ts
+function cacheKeyFor(outDir) {
+  const abs = path13.resolve(outDir);
+  const hash = crypto.createHash("sha1").update(abs).digest("hex").slice(0, 8);
+  return `${path13.basename(abs) || "client"}-${hash}`;
+}
 async function build2(clientBuildOptions, buildContext) {
   const {
     srcDir = "./client",
@@ -2748,74 +2971,81 @@ async function build2(clientBuildOptions, buildContext) {
     globals = {},
     manualChunks
   } = clientBuildOptions;
-  const physicalEntryPath = path12.resolve(srcDir, entry);
+  const cacheDir = path13.resolve(
+    "node_modules",
+    ".nrg",
+    "client",
+    cacheKeyFor(buildContext.outDir)
+  );
+  const physicalEntryPath = path13.resolve(srcDir, entry);
   let entryPath;
   let generatedEntry = false;
-  if (fs13.existsSync(physicalEntryPath)) {
+  if (fs14.existsSync(physicalEntryPath)) {
     entryPath = physicalEntryPath;
   } else {
-    const cacheDir = path12.resolve("node_modules", ".nrg", "client");
-    const cachedEntryPath = path12.resolve(cacheDir, entry);
-    if (!fs13.existsSync(cacheDir)) {
-      fs13.mkdirSync(cacheDir, { recursive: true });
+    const cachedEntryPath = path13.resolve(cacheDir, entry);
+    if (!fs14.existsSync(cacheDir)) {
+      fs14.mkdirSync(cacheDir, { recursive: true });
     }
-    fs13.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
+    fs14.writeFileSync(cachedEntryPath, "// auto-generated entry\n");
     entryPath = cachedEntryPath;
     generatedEntry = true;
   }
-  const iconsDir = path12.resolve(
-    staticDirs.icons ?? path12.join(path12.dirname(path12.resolve(srcDir)), "icons")
+  const iconsDir = path13.resolve(
+    staticDirs.icons ?? path13.join(path13.dirname(path13.resolve(srcDir)), "icons")
   );
   const plugins = [
     vue(),
     nodeDefinitionsInliner(
       buildContext.outDir,
       entryPath,
-      fs13.existsSync(iconsDir) ? iconsDir : void 0,
-      path12.resolve(srcDir, "components"),
-      path12.resolve(srcDir, "nodes"),
-      !generatedEntry
+      fs14.existsSync(iconsDir) ? iconsDir : void 0,
+      path13.resolve(srcDir, "components"),
+      path13.resolve(srcDir, "nodes"),
+      !generatedEntry,
+      cacheDir
     )
   ];
   plugins.push(
     htmlGenerator({
       packageName: buildContext.packageName,
-      licensePath: licensePath ? path12.resolve(licensePath) : void 0
+      licensePath: licensePath ? path13.resolve(licensePath) : void 0
     })
   );
   if (locales) {
     const { docsDir = "./locales/docs", labelsDir = "./locales/labels" } = locales;
-    const localesOutDir = path12.join(buildContext.outDir, "locales");
+    const localesOutDir = path13.join(buildContext.outDir, "locales");
     plugins.push(
       localesGenerator({
         outDir: localesOutDir,
-        docsDir: path12.resolve(docsDir),
-        labelsDir: path12.resolve(labelsDir)
+        docsDir: path13.resolve(docsDir),
+        labelsDir: path13.resolve(labelsDir)
       })
     );
     plugins.push(
       helpGenerator({
         outDir: buildContext.outDir,
         localesOutDir,
-        docsDir: path12.resolve(docsDir),
-        labelsDir: path12.resolve(labelsDir)
+        docsDir: path13.resolve(docsDir),
+        labelsDir: path13.resolve(labelsDir),
+        srcDir: buildContext.serverSrcDir
       })
     );
   }
   const copyTargets = [];
-  const publicDir = path12.resolve(
-    staticDirs.public ?? path12.join(srcDir, "public")
+  const publicDir = path13.resolve(
+    staticDirs.public ?? path13.join(srcDir, "public")
   );
-  if (fs13.existsSync(publicDir)) {
+  if (fs14.existsSync(publicDir)) {
     copyTargets.push({
       src: publicDir,
-      dest: path12.join(buildContext.outDir, "resources")
+      dest: path13.join(buildContext.outDir, "resources")
     });
   }
-  if (fs13.existsSync(iconsDir)) {
+  if (fs14.existsSync(iconsDir)) {
     copyTargets.push({
       src: iconsDir,
-      dest: path12.join(buildContext.outDir, "icons")
+      dest: path13.join(buildContext.outDir, "icons")
     });
   }
   if (copyTargets.length > 0) {
@@ -2843,10 +3073,10 @@ async function build2(clientBuildOptions, buildContext) {
     configFile: false,
     logLevel: "warn",
     base: `/resources/${buildContext.packageName}`,
-    publicDir: path12.resolve(srcDir, "public"),
+    publicDir: path13.resolve(srcDir, "public"),
     resolve: {
       alias: {
-        "@": path12.resolve(srcDir)
+        "@": path13.resolve(srcDir)
       }
     },
     plugins,
@@ -2900,8 +3130,8 @@ async function build2(clientBuildOptions, buildContext) {
     throw new BuildError("client", error);
   } finally {
     if (generatedEntry) {
-      if (fs13.existsSync(entryPath)) {
-        fs13.unlinkSync(entryPath);
+      if (fs14.existsSync(entryPath)) {
+        fs14.unlinkSync(entryPath);
       }
     }
   }
@@ -3060,20 +3290,20 @@ function serverPlugin(options) {
       });
       logger.startGroup("Node-RED");
       nodeRedLauncher.flushLogs();
-      const serverSrcDir = path13.resolve(
+      const serverSrcDir = path14.resolve(
         serverBuildOptions.srcDir ?? "./server"
       );
-      const clientSrcDir = path13.resolve(
+      const clientSrcDir = path14.resolve(
         clientBuildOptions.srcDir ?? "./client"
       );
-      const localesDocsDir = path13.resolve(
+      const localesDocsDir = path14.resolve(
         clientBuildOptions.locales?.docsDir ?? "./locales/docs"
       );
-      const localesLabelsDir = path13.resolve(
+      const localesLabelsDir = path14.resolve(
         clientBuildOptions.locales?.labelsDir ?? "./locales/labels"
       );
-      const iconsDir = path13.resolve(
-        clientBuildOptions.staticDirs?.icons ?? path13.join(path13.dirname(clientSrcDir), "icons")
+      const iconsDir = path14.resolve(
+        clientBuildOptions.staticDirs?.icons ?? path14.join(path14.dirname(clientSrcDir), "icons")
       );
       const watchPaths = [
         serverSrcDir,
@@ -3093,7 +3323,7 @@ function serverPlugin(options) {
       );
       const handleFileChange = (file, event) => {
         if (!initialStartDone) return;
-        logger.info(`${event}: ${path13.relative(process.cwd(), file)}`);
+        logger.info(`${event}: ${path14.relative(process.cwd(), file)}`);
         debounceBeforeStart();
       };
       watcher.on("change", (file) => handleFileChange(file, "Changed"));
@@ -3187,11 +3417,12 @@ function nrg(options = {}) {
     server.nodeRed
   );
   const extraFilesCopyTargets = build3.extraFilesCopyTargets ?? DEFAULT_EXTRA_FILES_COPY_TARGETS;
-  const resolvedOutDir = path14.resolve(outDir);
+  const resolvedOutDir = path15.resolve(outDir);
   const buildContext = {
     outDir: resolvedOutDir,
     packageName: getPackageName(),
-    isDev: process.env.NODE_ENV === "development"
+    isDev: process.env.NODE_ENV === "development",
+    serverSrcDir: path15.resolve(serverBuildOptions.srcDir ?? "./server")
   };
   const nodeRedLauncher = new NodeRedLauncher(
     resolvedOutDir,