@bonsae/nrg 0.14.0 → 0.15.0

package/server/index.cjs

@@ -30,11 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/server/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CompletePortSchema: () => CompletePortSchema,
   ConfigNode: () => ConfigNode,
+  ErrorPortSchema: () => ErrorPortSchema,
   IONode: () => IONode,
   Node: () => Node,
   NrgError: () => NrgError,
   SchemaType: () => SchemaType,
+  StatusPortSchema: () => StatusPortSchema,
   defineConfigNode: () => defineConfigNode,
   defineIONode: () => defineIONode,
   defineModule: () => defineModule,
@@ -44,20 +47,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/server/utils.ts
-function getCredentialsFromSchema(schema) {
-  const result = {};
-  for (const [key, value] of Object.entries(schema.properties)) {
-    const property = value;
-    result[key] = {
-      // NOTE: required is always false because it is controlled by the JSON Schema and AJV validation instead of using node-red client core
-      required: false,
-      type: property.format === "password" ? "password" : "text",
-      value: property.default ?? void 0
-    };
-  }
-  return result;
-}
+// src/core/server/nodes/utils.ts
+var import_typebox = require("@sinclair/typebox");
 
 // src/core/errors.ts
 var NrgError = class _NrgError extends Error {
@@ -111,6 +102,9 @@ var TypedInput = class {
 };
 
 // src/core/server/nodes/utils.ts
+function isSchemaLike(obj) {
+  return obj != null && typeof obj === "object" && import_typebox.Kind in obj;
+}
 function setupContext(context, store) {
   return {
     get: (key) => new Promise(
@@ -189,29 +183,32 @@ function setupConfigProxy(opts) {
   return createProxy(config);
 }
 
+// src/core/server/utils.ts
+function getCredentialsFromSchema(schema) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema.properties)) {
+    const property = value;
+    result[key] = {
+      // NOTE: required is always false because it is controlled by the JSON Schema and AJV validation instead of using node-red client core
+      required: false,
+      type: property.format === "password" ? "password" : "text",
+      value: property.default ?? void 0
+    };
+  }
+  return result;
+}
+
+// src/core/server/nodes/symbols.ts
+var WIRE_HANDLERS = Symbol("wireHandlers");
+
 // src/core/server/nodes/node.ts
-var Node = class {
+var cachedSettingsMap = /* @__PURE__ */ new WeakMap();
+var Node = class _Node {
   static type;
   static category;
   static configSchema;
   static credentialsSchema;
   static settingsSchema;
-  static _cachedSettings = null;
-  /** @internal */
-  static _settings() {
-    if (!this.settingsSchema) return;
-    const settings = {};
-    const prefix = this.type.replace(/-./g, (x) => x[1].toUpperCase());
-    for (const [key, prop] of Object.entries(this.settingsSchema.properties)) {
-      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
-      settings[settingKey] = {
-        value: prop.default,
-        exportable: prop.exportable ?? false
-      };
-    }
-    return settings;
-  }
-  // NOTE:
   static validateSettings(RED) {
     if (!this.settingsSchema) return;
     RED.log.info("Validating settings");
@@ -237,9 +234,61 @@ var Node = class {
       cacheKey: this.settingsSchema.$id || `${this.type}:settings`,
       throwOnError: true
     });
-    this._cachedSettings = settings;
+    cachedSettingsMap.set(this, settings);
     RED.log.info("Settings are valid");
   }
+  static #buildSettings(NC) {
+    if (!NC.settingsSchema) return;
+    const settings = {};
+    const prefix = NC.type.replace(/-./g, (x) => x[1].toUpperCase());
+    for (const [key, prop] of Object.entries(NC.settingsSchema.properties)) {
+      const settingKey = prefix + key.charAt(0).toUpperCase() + key.slice(1);
+      settings[settingKey] = {
+        value: prop.default,
+        exportable: prop.exportable ?? false
+      };
+    }
+    return settings;
+  }
+  /**
+   * Registers this node class with Node-RED. Handles instance creation,
+   * event handler wiring, settings validation, and the user's registered() hook.
+   */
+  static async register(RED) {
+    const NodeClass = this;
+    if (NodeClass.color && !/^#[0-9A-Fa-f]{6}$/.test(NodeClass.color)) {
+      throw new NrgError(
+        `Invalid color for ${NodeClass.type}: ${NodeClass.color} color must be in hex format`
+      );
+    }
+    RED.nodes.registerType(
+      NodeClass.type,
+      function(config) {
+        RED.nodes.createNode(this, config);
+        const node = new NodeClass(RED, this, config, this.credentials);
+        Object.defineProperty(this, "_node", {
+          value: node,
+          writable: false,
+          configurable: false,
+          enumerable: false
+        });
+        const createdPromise = Promise.resolve(node.created?.()).catch(
+          (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error("Error during created hook: " + message);
+            throw error;
+          }
+        );
+        node[WIRE_HANDLERS](this, createdPromise);
+      },
+      {
+        credentials: NodeClass.credentialsSchema ? getCredentialsFromSchema(NodeClass.credentialsSchema) : {},
+        settings: _Node.#buildSettings(this)
+      }
+    );
+    NodeClass.validateSettings(RED);
+    await Promise.resolve(NodeClass.registered?.(RED));
+  }
   RED;
   node;
   context;
@@ -289,6 +338,39 @@ var Node = class {
       }
     }
   }
+  [WIRE_HANDLERS](nodeRedNode, createdPromise) {
+    nodeRedNode.on(
+      "close",
+      async (removed, done) => {
+        try {
+          this.log("Calling closed");
+          await this.#closed(removed);
+          this.log("Node was closed");
+          done();
+        } catch (error) {
+          if (error instanceof Error) {
+            this.error("Error while closing node: " + error.message);
+            done(error);
+          } else {
+            this.error("Unknown error occurred while closing node");
+            done(new Error("Unknown error occurred while closing node"));
+          }
+        }
+      }
+    );
+  }
+  async #closed(removed) {
+    try {
+      await Promise.resolve(this.closed?.(removed));
+    } finally {
+      this.log("clearing timers and intervals");
+      this.timers.forEach((t) => clearTimeout(t));
+      this.intervals.forEach((i) => clearInterval(i));
+      this.timers.clear();
+      this.intervals.clear();
+      this.log("timers and intervals cleared");
+    }
+  }
   i18n(key, substitutions) {
     const nodeType = this.constructor.type;
     return this.RED._(`${nodeType}.${key}`, substitutions);
@@ -314,20 +396,6 @@ var Node = class {
     clearInterval(interval);
     this.intervals.delete(interval);
   }
-  // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's closed again
-  /** @internal */
-  async _closed(removed) {
-    try {
-      await Promise.resolve(this.closed?.(removed));
-    } finally {
-      this.log("clearing timers and intervals");
-      this.timers.forEach((t) => clearTimeout(t));
-      this.intervals.forEach((i) => clearInterval(i));
-      this.timers.clear();
-      this.intervals.clear();
-      this.log("timers and intervals cleared");
-    }
-  }
   on(event, callback) {
     this.node.on(event, callback);
   }
@@ -354,7 +422,7 @@ var Node = class {
   }
   get settings() {
     const constructor = this.constructor;
-    return constructor._cachedSettings ?? {};
+    return cachedSettingsMap.get(constructor) ?? {};
   }
 };
 
@@ -372,16 +440,20 @@ var IONode = class extends Node {
   static get outputs() {
     const s = this.outputsSchema;
     if (!s) return 0;
-    return Array.isArray(s) ? s.length : 1;
+    if (Array.isArray(s)) return s.length;
+    if (isSchemaLike(s)) return 1;
+    const keys = Object.keys(s);
+    for (const key of keys) {
+      if (/^\d+$/.test(key)) {
+        throw new NrgError(
+          `outputsSchema record key "${key}" in ${this.type} looks numeric. Use descriptive string names (e.g. "success", "failure") to avoid JavaScript object key ordering issues.`
+        );
+      }
+    }
+    return keys.length;
   }
-  _send;
+  #send;
   context;
-  // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's input again
-  /** @internal */
-  static _registered(RED) {
-    this.validateSettings(RED);
-    return this.registered?.(RED);
-  }
   constructor(RED, node, config, credentials) {
     super(RED, node, config, credentials);
     const context = node.context();
@@ -394,11 +466,58 @@ var IONode = class extends Node {
     fn.global = setupContext(context.global);
     this.context = fn;
   }
+  [WIRE_HANDLERS](nodeRedNode, createdPromise) {
+    super[WIRE_HANDLERS](nodeRedNode, createdPromise);
+    const NC = this.constructor;
+    nodeRedNode.on(
+      "input",
+      async (msg, send, done) => {
+        try {
+          await createdPromise;
+        } catch {
+          done(new Error("Node failed to initialize"));
+          return;
+        }
+        try {
+          nodeRedNode.log("Calling input");
+          await Promise.resolve(this.#input(msg, send));
+          this.#sendToPort("complete", {
+            ...msg,
+            complete: {
+              source: this.#nodeSource()
+            }
+          });
+          done();
+          nodeRedNode.log("Input processed");
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Unknown error during input handling";
+          this.#sendToPort("error", {
+            ...msg,
+            error: {
+              message: errorMsg,
+              source: this.#nodeSource()
+            }
+          });
+          if (error instanceof Error) {
+            nodeRedNode.error(
+              "Error while processing input: " + error.message,
+              msg
+            );
+            done(error);
+          } else {
+            nodeRedNode.error(
+              "Unknown error occurred during input handling",
+              msg
+            );
+            done(new Error(errorMsg));
+          }
+        }
+      }
+    );
+  }
   input(msg) {
   }
-  // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's input again
-  /** @internal */
-  async _input(msg, send) {
+  async #input(msg, send) {
     const NodeClass = this.constructor;
     const shouldValidateInput = this.config.validateInput ?? NodeClass.validateInput;
     if (shouldValidateInput && NodeClass.inputSchema) {
@@ -409,11 +528,11 @@ var IONode = class extends Node {
       });
       this.log("Input is valid");
     }
-    this._send = send;
+    this.#send = send;
     try {
       await Promise.resolve(this.input(msg));
     } finally {
-      this._send = void 0;
+      this.#send = void 0;
     }
   }
   send(msg) {
@@ -421,87 +540,108 @@ var IONode = class extends Node {
     const shouldValidateOutput = this.config.validateOutput ?? NodeClass.validateOutput;
     if (shouldValidateOutput && NodeClass.outputsSchema) {
       this.log("Validating output");
-      const schemas = NodeClass.outputsSchema;
-      if (Array.isArray(schemas)) {
+      const rawSchema = NodeClass.outputsSchema;
+      if (Array.isArray(rawSchema)) {
         const msgs = msg;
-        for (let i = 0; i < schemas.length; i++) {
+        for (let i = 0; i < rawSchema.length; i++) {
           if (msgs[i] == null) continue;
-          this.RED.validator.validate(msgs[i], schemas[i], {
-            cacheKey: schemas[i].$id || `${NodeClass.type}:output-schema:${i}`,
+          this.RED.validator.validate(msgs[i], rawSchema[i], {
+            cacheKey: rawSchema[i].$id || `${NodeClass.type}:output-schema:${i}`,
             throwOnError: true
           });
         }
-      } else if (Array.isArray(msg)) {
-        for (let i = 0; i < msg.length; i++) {
-          if (msg[i] == null) continue;
-          this.RED.validator.validate(msg[i], schemas, {
-            cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
+      } else if (isSchemaLike(rawSchema)) {
+        if (Array.isArray(msg)) {
+          const msgs = msg;
+          for (let i = 0; i < msgs.length; i++) {
+            if (msgs[i] == null) continue;
+            this.RED.validator.validate(msgs[i], rawSchema, {
+              cacheKey: rawSchema.$id || `${NodeClass.type}:output-schema`,
+              throwOnError: true
+            });
+          }
+        } else {
+          this.RED.validator.validate(msg, rawSchema, {
+            cacheKey: rawSchema.$id || `${NodeClass.type}:output-schema`,
             throwOnError: true
           });
         }
       } else {
-        this.RED.validator.validate(msg, schemas, {
-          cacheKey: schemas.$id || `${NodeClass.type}:output-schema`,
-          throwOnError: true
-        });
+        const schemaArray = Object.values(rawSchema);
+        const msgs = msg;
+        for (let i = 0; i < schemaArray.length; i++) {
+          if (msgs[i] == null) continue;
+          this.RED.validator.validate(msgs[i], schemaArray[i], {
+            cacheKey: schemaArray[i].$id || `${NodeClass.type}:output-schema:${i}`,
+            throwOnError: true
+          });
+        }
       }
       this.log("Output is valid");
     }
-    if (this._send) {
-      this._send(msg);
+    if (this.#send) {
+      this.#send(msg);
     } else {
       this.node.send(msg);
     }
   }
-  // --- Emit port management ---
-  /** @internal */
-  get _baseOutputs() {
+  // --- Built-in port management ---
+  get baseOutputs() {
     return this.constructor.outputs ?? 0;
   }
-  /** @internal */
-  get _totalOutputs() {
-    let count = this._baseOutputs;
-    if (this.config.emitError) count++;
-    if (this.config.emitComplete) count++;
-    if (this.config.emitStatus) count++;
+  get totalOutputs() {
+    const config = this.config;
+    let count = this.baseOutputs;
+    if (config.errorPort) count++;
+    if (config.completePort) count++;
+    if (config.statusPort) count++;
     return count;
   }
   /**
    * Send a message to a specific output port by index or name.
-   * Named ports: `"error"`, `"complete"`, `"status"` — resolved automatically
-   * based on the node's emit port configuration.
+   * Built-in ports: `"error"`, `"complete"`, `"status"` — resolved automatically
+   * based on the node's built-in port configuration.
+   * Custom named ports are resolved from `outputsSchema` when it is a record.
    * Numeric indices refer to the base output ports (0-based).
    */
   sendToPort(port, msg) {
-    this._sendToPort(port, msg);
+    this.#sendToPort(port, msg);
   }
-  /** @internal */
-  _sendToPort(port, msg) {
+  #sendToPort(port, msg) {
     let portIndex;
     if (typeof port === "number") {
       portIndex = port;
+    } else if (port === "error" || port === "complete" || port === "status") {
+      portIndex = this.#getBuiltinPortIndex(port);
+      if (portIndex === null) return;
     } else {
-      portIndex = this._getEmitPortIndex(port);
+      portIndex = this.#getNamedPortIndex(port);
       if (portIndex === null) return;
     }
-    const out = Array(this._totalOutputs).fill(null);
+    const out = Array(this.totalOutputs).fill(null);
     out[portIndex] = msg;
     this.node.send(out);
   }
-  _getEmitPortIndex(name) {
+  #getNamedPortIndex(name) {
+    const schema = this.constructor.outputsSchema;
+    if (!schema || Array.isArray(schema) || isSchemaLike(schema)) return null;
+    const idx = Object.keys(schema).indexOf(name);
+    return idx === -1 ? null : idx;
+  }
+  #getBuiltinPortIndex(name) {
     const config = this.config;
     if (name === "error") {
-      return config.emitError ? this._baseOutputs : null;
+      return config.errorPort ? this.baseOutputs : null;
     }
-    let idx = this._baseOutputs;
-    if (config.emitError) idx++;
+    let idx = this.baseOutputs;
+    if (config.errorPort) idx++;
     if (name === "complete") {
-      return config.emitComplete ? idx : null;
+      return config.completePort ? idx : null;
     }
-    if (config.emitComplete) idx++;
-    return config.emitStatus ? idx : null;
+    if (config.completePort) idx++;
+    return config.statusPort ? idx : null;
   }
-  _nodeSource() {
+  #nodeSource() {
     return {
       id: this.id,
       type: this.constructor.type,
@@ -510,19 +650,19 @@ var IONode = class extends Node {
   }
   status(status) {
     this.node.status(status);
-    this._sendToPort("status", {
+    this.#sendToPort("status", {
       status,
-      source: this._nodeSource()
+      source: this.#nodeSource()
     });
   }
   error(message, msg) {
     super.error(message, msg);
     if (msg) {
-      this._sendToPort("error", {
+      this.#sendToPort("error", {
         ...msg,
         error: {
           message,
-          source: this._nodeSource()
+          source: this.#nodeSource()
         }
       });
     }
@@ -554,12 +694,6 @@ var IONode = class extends Node {
 var ConfigNode = class extends Node {
   static category = "config";
   context;
-  // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's input again
-  /** @internal */
-  static _registered(RED) {
-    this.validateSettings(RED);
-    return this.registered?.(RED);
-  }
   constructor(RED, node, config, credentials) {
     super(RED, node, config, credentials);
     const context = node.context();
@@ -601,8 +735,7 @@ function defineIONode(def) {
     static outputsSchema = def.outputsSchema;
     static validateInput = def.validateInput ?? false;
     static validateOutput = def.validateOutput ?? false;
-    static _registered(RED) {
-      this.validateSettings(RED);
+    static registered(RED) {
       return def.registered?.(RED);
     }
     async input(msg) {
@@ -630,8 +763,7 @@ function defineConfigNode(def) {
     static configSchema = def.configSchema;
     static credentialsSchema = def.credentialsSchema;
     static settingsSchema = def.settingsSchema;
-    static _registered(RED) {
-      this.validateSettings(RED);
+    static registered(RED) {
       return def.registered?.(RED);
     }
     async created() {
@@ -863,6 +995,41 @@ function initRoutes(RED) {
   initAssetsRoutes(RED.httpAdmin);
 }
 
+// src/core/server/registration.ts
+async function registerType(RED, NodeClass) {
+  RED.log.debug(`Registering Type: ${NodeClass.type}`);
+  if (!(NodeClass.prototype instanceof Node)) {
+    throw new NrgError(
+      `${NodeClass.name} must extend IONode or ConfigNode classes`
+    );
+  }
+  if (!NodeClass.type) {
+    throw new NrgError("type must be provided when registering the node");
+  }
+  await NodeClass.register(RED);
+  RED.log.debug(`Type registered: ${NodeClass.type}`);
+}
+function registerTypes(nodes) {
+  const fn = Object.assign(
+    async function(RED) {
+      initValidator(RED);
+      initRoutes(RED);
+      try {
+        RED.log.info("Registering node types in series");
+        for (const NodeClass of nodes) {
+          await registerType(RED, NodeClass);
+        }
+        RED.log.info("All node types registered in series");
+      } catch (error) {
+        RED.log.error("Error registering node types:", error);
+        throw error;
+      }
+    },
+    { nodes }
+  );
+  return fn;
+}
+
 // src/core/constants.ts
 var TYPED_INPUT_TYPES = [
   "msg",
@@ -882,17 +1049,17 @@ var TYPED_INPUT_TYPES = [
 ];
 
 // src/core/server/schemas/type.ts
-var import_typebox = require("@sinclair/typebox");
+var import_typebox2 = require("@sinclair/typebox");
 var import_rules = require("ajv/dist/compile/rules");
 function NodeRef(nodeClass, options) {
   return {
-    ...import_typebox.Type.String({
+    ...import_typebox2.Type.String({
       description: options?.description || `Reference to ${nodeClass.type}`,
       format: "node-id"
     }),
     "x-nrg-node-type": nodeClass.type,
     ...options,
-    [import_typebox.Kind]: "NodeRef"
+    [import_typebox2.Kind]: "NodeRef"
   };
 }
 function TypedInput2(options) {
@@ -900,10 +1067,10 @@ function TypedInput2(options) {
     ...TypedInputSchema,
     "x-nrg-typed-input": true,
     ...options,
-    [import_typebox.Kind]: "TypedInput"
+    [import_typebox2.Kind]: "TypedInput"
   };
 }
-var SchemaType = Object.assign({}, import_typebox.Type, {
+var SchemaType = Object.assign({}, import_typebox2.Type, {
   NodeRef,
   TypedInput: TypedInput2
 });
@@ -995,137 +1162,55 @@ var TypedInputSchema = SchemaType.Object(
     }
   }
 );
+var NodeSourceSchema = SchemaType.Object({
+  id: SchemaType.String(),
+  type: SchemaType.String(),
+  name: SchemaType.String()
+});
+var ErrorPortSchema = SchemaType.Object({
+  error: SchemaType.Object({
+    message: SchemaType.String(),
+    source: NodeSourceSchema
+  })
+});
+var CompletePortSchema = SchemaType.Object({
+  complete: SchemaType.Object({
+    source: NodeSourceSchema
+  })
+});
+var StatusPortSchema = SchemaType.Object({
+  status: SchemaType.Object({
+    fill: SchemaType.Optional(
+      SchemaType.Union([
+        SchemaType.Literal("red"),
+        SchemaType.Literal("green")
+      ])
+    ),
+    shape: SchemaType.Optional(
+      SchemaType.Union([
+        SchemaType.Literal("dot"),
+        SchemaType.Literal("string")
+      ])
+    ),
+    text: SchemaType.Optional(SchemaType.String())
+  }),
+  source: NodeSourceSchema
+});
 
 // src/core/server/index.ts
-async function registerType(RED, NodeClass) {
-  const NC = NodeClass;
-  RED.log.debug(`Registering Type: ${NC.type}`);
-  if (!(NC.prototype instanceof Node)) {
-    throw new NrgError(`${NC.name} must extend IONode or ConfigNode classes`);
-  }
-  if (!NC.type) {
-    throw new NrgError("type must be provided when registering the node");
-  }
-  if (NC.color && !/^#[0-9A-Fa-f]{6}$/.test(NC.color)) {
-    throw new NrgError(
-      `Invalid color for ${NodeClass.type}: ${NC.color} color must be in hex format`
-    );
-  }
-  RED.nodes.registerType(
-    NC.type,
-    function(config) {
-      RED.nodes.createNode(this, config);
-      const node = new NC(RED, this, config, this.credentials);
-      Object.defineProperty(this, "_node", {
-        value: node,
-        writable: false,
-        configurable: false,
-        enumerable: false
-      });
-      const createdPromise = Promise.resolve(node.created?.()).catch(
-        (error) => {
-          this.error("Error during created hook: " + error.message);
-          throw error;
-        }
-      );
-      this.on(
-        "input",
-        async (msg, send, done) => {
-          try {
-            await createdPromise;
-          } catch {
-            done(new Error("Node failed to initialize"));
-            return;
-          }
-          try {
-            this.log("Calling input");
-            await Promise.resolve(node._input(msg, send));
-            node._sendToPort("complete", {
-              ...msg,
-              complete: {
-                source: { id: node.id, type: NC.type, name: node.name }
-              }
-            });
-            done();
-            this.log("Input processed");
-          } catch (error) {
-            const errorMsg = error instanceof Error ? error.message : "Unknown error during input handling";
-            const errorIdx = node._getErrorPortIndex();
-            if (errorIdx !== null) {
-              node._sendToPort(errorIdx, {
-                ...msg,
-                error: {
-                  message: errorMsg,
-                  source: { id: node.id, type: NC.type, name: node.name }
-                }
-              });
-            }
-            if (error instanceof Error) {
-              this.error("Error while processing input: " + error.message, msg);
-              done(error);
-            } else {
-              this.error("Unknown error occurred during input handling", msg);
-              done(new Error(errorMsg));
-            }
-          }
-        }
-      );
-      this.on(
-        "close",
-        async (removed, done) => {
-          try {
-            this.log("Calling closed");
-            await Promise.resolve(node._closed(removed));
-            this.log("Node was closed");
-            done();
-          } catch (error) {
-            if (error instanceof Error) {
-              this.error("Error while closing node: " + error.message);
-              done(error);
-            } else {
-              this.error("Unknown error occurred while closing node");
-              done(new Error("Unknown error occurred while closing node"));
-            }
-          }
-        }
-      );
-    },
-    {
-      credentials: NC.credentialsSchema ? getCredentialsFromSchema(NC.credentialsSchema) : {},
-      settings: NC._settings?.()
-    }
-  );
-  await Promise.resolve(NC._registered?.(RED));
-  RED.log.debug(`Type registered: ${NC.type}`);
-}
-function registerTypes(nodes) {
-  const fn = async function(RED) {
-    initValidator(RED);
-    initRoutes(RED);
-    try {
-      RED.log.info("Registering node types in series");
-      for (const NodeClass of nodes) {
-        await registerType(RED, NodeClass);
-      }
-      RED.log.info("All node types registered in series");
-    } catch (error) {
-      RED.log.error("Error registering node types:", error);
-      throw error;
-    }
-  };
-  fn.nodes = nodes;
-  return fn;
-}
 function defineModule(definition) {
   return definition;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CompletePortSchema,
   ConfigNode,
+  ErrorPortSchema,
   IONode,
   Node,
   NrgError,
   SchemaType,
+  StatusPortSchema,
   defineConfigNode,
   defineIONode,
   defineModule,