@bonsae/nrg 0.13.1 → 0.15.0

package/server/index.cjs

@@ -30,203 +30,25 @@ 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,
   defineSchema: () => defineSchema,
-  initValidator: () => initValidator,
   registerType: () => registerType,
   registerTypes: () => registerTypes
 });
 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/validator.ts
-var import_ajv = __toESM(require("ajv"), 1);
-var import_ajv_formats = __toESM(require("ajv-formats"), 1);
-var import_ajv_errors = __toESM(require("ajv-errors"), 1);
-var Validator = class {
-  ajv;
-  constructor(options) {
-    const { customKeywords, customFormats, ...ajvOptions } = options || {};
-    this.ajv = new import_ajv.default({
-      allErrors: true,
-      code: {
-        source: false
-      },
-      coerceTypes: true,
-      removeAdditional: false,
-      strict: false,
-      strictSchema: false,
-      useDefaults: true,
-      validateFormats: true,
-      // NOTE: typebox handles validation via typescript
-      // NOTE: if true, types that are not serializable JSON, like Function, would not work
-      validateSchema: false,
-      verbose: true,
-      ...ajvOptions
-    });
-    (0, import_ajv_formats.default)(this.ajv);
-    (0, import_ajv_errors.default)(this.ajv);
-    this.addCustomKeywords(customKeywords || []);
-    this.addCustomFormats(customFormats || {});
-  }
-  /**
-   * Add custom keywords to the validator
-   */
-  addCustomKeywords(keywords) {
-    if (!keywords) return;
-    keywords.forEach((keyword) => {
-      this.ajv.addKeyword(keyword);
-    });
-  }
-  /**
-   * Add custom formats to the validator
-   */
-  addCustomFormats(formats) {
-    if (!formats) return;
-    Object.entries(formats).forEach(([name, validator2]) => {
-      if (validator2 instanceof RegExp) {
-        this.ajv.addFormat(name, validator2);
-      } else {
-        this.ajv.addFormat(name, { validate: validator2 });
-      }
-    });
-  }
-  /**
-   * Create a validator function with caching
-   * @param schema - JSON Schema to validate against
-   * @param cacheKey - Optional cache key for reusing validators
-   */
-  createValidator(schema, cacheKey) {
-    if (cacheKey && !schema.$id) {
-      schema.$id = cacheKey;
-    }
-    if (schema.$id) {
-      const cached = this.ajv.getSchema(schema.$id);
-      if (cached) return cached;
-    }
-    const validator2 = this.ajv.compile(schema);
-    return validator2;
-  }
-  /**
-   * Validate data against a schema and return a structured result
-   */
-  validate(data, schema, options) {
-    const validator2 = this.createValidator(schema, options?.cacheKey);
-    const valid = validator2(data);
-    if (!valid) {
-      const errorMessage = this.formatErrors(validator2.errors);
-      if (options?.throwOnError) {
-        throw new ValidationError(errorMessage, validator2.errors || []);
-      }
-      return {
-        valid: false,
-        errors: validator2.errors || void 0,
-        errorMessage
-      };
-    }
-    return {
-      valid: true,
-      data
-    };
-  }
-  /**
-   * Format errors into a human-readable string
-   */
-  formatErrors(errors, options) {
-    if (!errors || errors.length === 0) {
-      return "No errors";
-    }
-    return this.ajv.errorsText(errors, {
-      separator: "; ",
-      dataVar: "data",
-      ...options
-    });
-  }
-  /**
-   * Get detailed error information
-   */
-  getDetailedErrors(errors) {
-    if (!errors || errors.length === 0) return [];
-    return errors.map((error) => ({
-      field: error.instancePath || "/",
-      message: error.message || "Validation failed",
-      keyword: error.keyword,
-      params: error.params,
-      schemaPath: error.schemaPath
-    }));
-  }
-  /**
-   * Add a schema to the validator for reference
-   */
-  addSchema(schema, key) {
-    this.ajv.addSchema(schema, key);
-    return this;
-  }
-  /**
-   * Remove a schema from the validator
-   */
-  removeSchema(key) {
-    this.ajv.removeSchema(key);
-    return this;
-  }
-};
-var ValidationError = class _ValidationError extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-
-// src/core/server/validation.ts
-var validator = void 0;
-function initValidator(RED) {
-  validator = new Validator({
-    customKeywords: [
-      {
-        keyword: "x-nrg-skip-validation",
-        schemaType: "boolean",
-        valid: true
-      },
-      {
-        keyword: "x-nrg-node-type",
-        type: "string",
-        validate: (schemaValue, dataValue) => {
-          if (!dataValue) return true;
-          const node = RED.nodes.getNode(dataValue);
-          return node?.type === schemaValue;
-        }
-      }
-    ],
-    customFormats: {
-      "node-id": /^[a-zA-Z0-9-_]+$/,
-      "flow-id": /^[a-f0-9]{16}$/,
-      "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
-    }
-  });
-}
+// src/core/server/nodes/utils.ts
+var import_typebox = require("@sinclair/typebox");
 
 // src/core/errors.ts
 var NrgError = class _NrgError extends Error {
@@ -280,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(
@@ -358,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");
@@ -402,13 +230,65 @@ var Node = class {
         }
       }
     }
-    validator.validate(settings, this.settingsSchema, {
+    RED.validator.validate(settings, this.settingsSchema, {
       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;
@@ -421,7 +301,7 @@ var Node = class {
     const constructor = this.constructor;
     if (constructor.configSchema) {
       this.log("Validating configs");
-      const configResult = validator.validate(
+      const configResult = this.RED.validator.validate(
         config,
         constructor.configSchema,
         {
@@ -443,7 +323,7 @@ var Node = class {
     });
     if (constructor.credentialsSchema && credentials) {
       this.log("Validating credentials");
-      const credResult = validator.validate(
+      const credResult = this.RED.validator.validate(
         credentials,
         constructor.credentialsSchema,
         {
@@ -458,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);
@@ -483,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);
   }
@@ -523,7 +422,7 @@ var Node = class {
   }
   get settings() {
     const constructor = this.constructor;
-    return constructor._cachedSettings ?? {};
+    return cachedSettingsMap.get(constructor) ?? {};
   }
 };
 
@@ -541,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();
@@ -563,26 +466,73 @@ 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) {
       this.log("Validating input");
-      validator.validate(msg, NodeClass.inputSchema, {
+      this.RED.validator.validate(msg, NodeClass.inputSchema, {
         cacheKey: NodeClass.inputSchema.$id || `${NodeClass.type}:input-schema`,
         throwOnError: true
       });
       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) {
@@ -590,78 +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;
-          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;
-          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 {
-        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;
   }
-  /** @internal */
-  _sendToPort(portIndex, msg) {
-    const out = Array(this._totalOutputs).fill(null);
+  /**
+   * Send a message to a specific output port by index or name.
+   * 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);
+  }
+  #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.#getNamedPortIndex(port);
+      if (portIndex === null) return;
+    }
+    const out = Array(this.totalOutputs).fill(null);
     out[portIndex] = msg;
     this.node.send(out);
   }
-  /** @internal */
-  _getErrorPortIndex() {
-    if (!this.config.emitError) return null;
-    return this._baseOutputs;
-  }
-  /** @internal */
-  _getCompletePortIndex() {
-    if (!this.config.emitComplete) return null;
-    let idx = this._baseOutputs;
-    if (this.config.emitError) idx++;
-    return idx;
-  }
-  /** @internal */
-  _getStatusPortIndex() {
-    if (!this.config.emitStatus) return null;
-    let idx = this._baseOutputs;
-    if (this.config.emitError) idx++;
-    if (this.config.emitComplete) idx++;
-    return idx;
-  }
-  _nodeSource() {
+  #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.errorPort ? this.baseOutputs : null;
+    }
+    let idx = this.baseOutputs;
+    if (config.errorPort) idx++;
+    if (name === "complete") {
+      return config.completePort ? idx : null;
+    }
+    if (config.completePort) idx++;
+    return config.statusPort ? idx : null;
+  }
+  #nodeSource() {
     return {
       id: this.id,
       type: this.constructor.type,
@@ -670,23 +650,19 @@ var IONode = class extends Node {
   }
   status(status) {
     this.node.status(status);
-    const portIdx = this._getStatusPortIndex();
-    if (portIdx !== null) {
-      this._sendToPort(portIdx, {
-        status,
-        source: this._nodeSource()
-      });
-    }
+    this.#sendToPort("status", {
+      status,
+      source: this.#nodeSource()
+    });
   }
   error(message, msg) {
     super.error(message, msg);
-    const portIdx = this._getErrorPortIndex();
-    if (portIdx !== null && msg) {
-      this._sendToPort(portIdx, {
+    if (msg) {
+      this.#sendToPort("error", {
         ...msg,
         error: {
           message,
-          source: this._nodeSource()
+          source: this.#nodeSource()
         }
       });
     }
@@ -718,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();
@@ -765,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) {
@@ -794,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() {
@@ -815,29 +783,208 @@ function defineConfigNode(def) {
   return NodeClass;
 }
 
-// src/core/server/api/nrg-assets.ts
+// src/core/validator.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_ajv_errors = __toESM(require("ajv-errors"), 1);
+var Validator = class {
+  ajv;
+  constructor(options) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+    this.ajv = new import_ajv.default({
+      allErrors: true,
+      code: {
+        source: false
+      },
+      coerceTypes: true,
+      removeAdditional: false,
+      strict: false,
+      strictSchema: false,
+      useDefaults: true,
+      validateFormats: true,
+      // NOTE: typebox handles validation via typescript
+      // NOTE: if true, types that are not serializable JSON, like Function, would not work
+      validateSchema: false,
+      verbose: true,
+      ...ajvOptions
+    });
+    (0, import_ajv_formats.default)(this.ajv);
+    (0, import_ajv_errors.default)(this.ajv);
+    this.addCustomKeywords(customKeywords || []);
+    this.addCustomFormats(customFormats || {});
+  }
+  /**
+   * Add custom keywords to the validator
+   */
+  addCustomKeywords(keywords) {
+    if (!keywords) return;
+    keywords.forEach((keyword) => {
+      this.ajv.addKeyword(keyword);
+    });
+  }
+  /**
+   * Add custom formats to the validator
+   */
+  addCustomFormats(formats) {
+    if (!formats) return;
+    Object.entries(formats).forEach(([name, validator]) => {
+      if (validator instanceof RegExp) {
+        this.ajv.addFormat(name, validator);
+      } else {
+        this.ajv.addFormat(name, { validate: validator });
+      }
+    });
+  }
+  /**
+   * Create a validator function with caching
+   * @param schema - JSON Schema to validate against
+   * @param cacheKey - Optional cache key for reusing validators
+   */
+  createValidator(schema, cacheKey) {
+    if (cacheKey && !schema.$id) {
+      schema.$id = cacheKey;
+    }
+    if (schema.$id) {
+      const cached = this.ajv.getSchema(schema.$id);
+      if (cached) return cached;
+    }
+    const validator = this.ajv.compile(schema);
+    return validator;
+  }
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  validate(data, schema, options) {
+    const validator = this.createValidator(schema, options?.cacheKey);
+    const valid = validator(data);
+    if (!valid) {
+      const errorMessage = this.formatErrors(validator.errors);
+      if (options?.throwOnError) {
+        throw new ValidationError(errorMessage, validator.errors || []);
+      }
+      return {
+        valid: false,
+        errors: validator.errors || void 0,
+        errorMessage
+      };
+    }
+    return {
+      valid: true,
+      data
+    };
+  }
+  /**
+   * Format errors into a human-readable string
+   */
+  formatErrors(errors, options) {
+    if (!errors || errors.length === 0) {
+      return "No errors";
+    }
+    return this.ajv.errorsText(errors, {
+      separator: "; ",
+      dataVar: "data",
+      ...options
+    });
+  }
+  /**
+   * Get detailed error information
+   */
+  getDetailedErrors(errors) {
+    if (!errors || errors.length === 0) return [];
+    return errors.map((error) => ({
+      field: error.instancePath || "/",
+      message: error.message || "Validation failed",
+      keyword: error.keyword,
+      params: error.params,
+      schemaPath: error.schemaPath
+    }));
+  }
+  /**
+   * Add a schema to the validator for reference
+   */
+  addSchema(schema, key) {
+    this.ajv.addSchema(schema, key);
+    return this;
+  }
+  /**
+   * Remove a schema from the validator
+   */
+  removeSchema(key) {
+    this.ajv.removeSchema(key);
+    return this;
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+
+// src/core/server/validation.ts
+function initValidator(RED) {
+  const nrg = {
+    validator: new Validator({
+      customKeywords: [
+        {
+          keyword: "x-nrg-skip-validation",
+          schemaType: "boolean",
+          valid: true
+        },
+        {
+          keyword: "x-nrg-node-type",
+          type: "string",
+          validate: (schemaValue, dataValue) => {
+            if (!dataValue) return true;
+            const node = RED.nodes.getNode(dataValue);
+            return node?.type === schemaValue;
+          }
+        }
+      ],
+      customFormats: {
+        "node-id": /^[a-zA-Z0-9-_]+$/,
+        "flow-id": /^[a-f0-9]{16}$/,
+        "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
+      }
+    })
+  };
+  Object.defineProperty(RED, "_nrg", {
+    value: nrg,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(RED, "validator", {
+    get: () => nrg.validator,
+    enumerable: false,
+    configurable: false
+  });
+}
+
+// src/core/server/api/assets.ts
 var import_path = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
-var RESOURCES_DIR = import_path.default.resolve(__dirname, "./resources");
-var ALLOWED_FILES = /* @__PURE__ */ new Set([
-  "nrg-client.js",
-  "vue.esm-browser.prod.js",
-  "vue.esm-browser.js"
-]);
-var handleNrgAsset = (req, res, next) => {
-  let fileName = req.params[0];
-  if (fileName === "vue.esm-browser.prod.js" && process.env.NODE_ENV !== "production") {
-    fileName = "vue.esm-browser.js";
-  }
-  if (!ALLOWED_FILES.has(fileName)) return next();
-  const filePath = import_path.default.join(RESOURCES_DIR, fileName);
-  if (!import_fs.default.existsSync(filePath)) return next();
-  res.setHeader("Content-Type", "application/javascript");
-  import_fs.default.createReadStream(filePath).pipe(res);
-};
-function initNrgAssetsRoute(router) {
-  if (!import_fs.default.existsSync(RESOURCES_DIR)) return;
-  router.get("/nrg/assets/*", handleNrgAsset);
+var import_module = require("module");
+function serveFile(filePath) {
+  return (_req, res, next) => {
+    if (!import_fs.default.existsSync(filePath)) return next();
+    res.setHeader("Content-Type", "application/javascript");
+    import_fs.default.createReadStream(filePath).pipe(res);
+  };
+}
+function initAssetsRoutes(router) {
+  const resourcesDir = import_path.default.resolve(__dirname, "./resources");
+  if (!import_fs.default.existsSync(resourcesDir)) return;
+  const _require = (0, import_module.createRequire)(import_path.default.join(__dirname, "package.json"));
+  const vueFile = process.env.NODE_ENV !== "production" ? _require.resolve("vue/dist/vue.esm-browser.js") : _require.resolve("vue/dist/vue.esm-browser.prod.js");
+  router.get(
+    "/nrg/assets/nrg-client.js",
+    serveFile(import_path.default.join(resourcesDir, "nrg-client.js"))
+  );
+  router.get("/nrg/assets/vue.esm-browser.prod.js", serveFile(vueFile));
+  router.get("/nrg/assets/vue.esm-browser.js", serveFile(vueFile));
 }
 
 // src/core/server/api/routes.ts
@@ -845,7 +992,42 @@ var _initialized = false;
 function initRoutes(RED) {
   if (_initialized) return;
   _initialized = true;
-  initNrgAssetsRoute(RED.httpAdmin);
+  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
@@ -867,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) {
@@ -885,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
 });
@@ -980,145 +1162,59 @@ 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));
-            const completeIdx = node._getCompletePortIndex();
-            if (completeIdx !== null) {
-              node._sendToPort(completeIdx, {
-                ...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,
   defineSchema,
-  initValidator,
   registerType,
   registerTypes
 });